import { A as AIContext, R as Renderable, a as AIObjectComponent, b as AIComponent, c as AINode, P as PlainObject, M as MaybePromise, d as PropsOfAIComponent, e as AIContextValues, J as JSX } from './jsx-dev-runtime-Cxb4uzJk.js';
export { k as AIElement, g as AIFragment, L as Literal, h as PlainArray, i as ReturnTypeOfAIComponent, j as attachedContextSymbol, f as createAIElement } from './jsx-dev-runtime-Cxb4uzJk.js';
import { ZodObject, ZodRawShape, z } from 'zod';
import { OpenAI } from 'openai';
export { OpenAI as OpenAIClient } from 'openai';
import { ReasoningEffort } from 'openai/resources';
import AnthropicClient from '@anthropic-ai/sdk';
export { default as AnthropicClient } from '@anthropic-ai/sdk';
import { GenerateContentParameters, Content, GenerateContentResponsePromptFeedback, GoogleGenAI, HarmCategory, HarmBlockThreshold } from '@google/genai';
export { GoogleGenAI, HarmBlockThreshold as GoogleHarmBlockThreshold, HarmCategory as GoogleHarmCategory } from '@google/genai';

declare const RenderModeContext: AIContext<"stream" | "render">;
type RenderXmlOptions = {
    renderedProps?: {
        [tagName: string]: {
            [propName: string]: boolean;
        };
    };
};
declare function renderXml(renderable: Renderable, opts?: RenderXmlOptions): Promise<string> | string;
declare function renderText(renderable: Renderable): Promise<string>;
declare function streamText(renderable: Renderable): AsyncGenerator<string, void>;
interface RenderObjectOptions {
    contextValues?: Record<symbol, any>;
}
declare function renderObject<P extends Record<string, any>, C extends AIObjectComponent<P>, 
/**
 * This is a convenience type to get two different ways of defining an AIObjectComponet
 * 1. Explicit where the component directly has the type AIObjectComponent<P, O>
 * 2. Implicit where the object component is only inferrable when the props are passed
 * this assumes the convention is that the prop schema will be the return type via z.infer
 */
O extends any = P['schema'] extends ZodObject<ZodRawShape> ? z.infer<P['schema']> : ReturnType<C>>(component: C, props: P, opts?: RenderObjectOptions): Promise<O>;

declare function createContext<T>(defaultValue: T): AIContext<T>;
declare function getContext<T>(context: AIContext<T>): T;

declare const SUPPORTED_TYPES: readonly ["image/jpeg", "image/png", "image/gif", "image/webp"];
type ImageMediaType = (typeof SUPPORTED_TYPES)[number];
type ImageMessageExtraProps = {
    dimensions?: {
        width: number;
        height: number;
    };
    detail?: 'auto' | 'high' | 'low';
    failOnError?: boolean;
    fallbackText?: string;
};
type Base64ImageMessageProps = {
    data: string;
    mediaType: ImageMediaType;
} & ImageMessageExtraProps;
type UrlImageMessageProps = {
    url: string;
} & ImageMessageExtraProps;
type ImagePartProps = Base64ImageMessageProps | UrlImageMessageProps;
declare const ImagePart: (_props: ImagePartProps) => null;
type ImageMessageData = ({
    url: string;
    data: null;
    mediaType: null;
} & ImageMessageExtraProps) | ({
    url: string;
    data: string;
    mediaType: ImageMediaType;
} & ImageMessageExtraProps) | ({
    url: null;
    data: string;
    mediaType: ImageMediaType;
} & ImageMessageExtraProps);

type ChatRole = 'user' | 'system' | 'assistant';
type UserImagePart = {
    type: 'image';
    image: ImageMessageData;
};
type UserTextPart = {
    type: 'text';
    text: string;
};
type UserChatMessage = {
    role: 'user';
    content: (UserTextPart | UserImagePart)[];
    cachePrompt?: boolean;
};
type ChatMessage = {
    role: 'system';
    content: string;
    cachePrompt?: boolean;
} | {
    role: 'assistant';
    content: string;
    cachePrompt?: boolean;
} | UserChatMessage;
type DebugMessage = {
    role: ChatRole;
    content: string;
};
declare const toDebugMessage: (message: ChatMessage) => DebugMessage;

type ChatCompletionUsage = {
    prompt: number;
    completion: number;
    total: number;
    cachedPromptTokensCreated: number;
    cachedPromptTokensRead: number;
    webSearchRequests?: number;
};

/**
 * This can be extended using declare module to add additional providers.
 */
interface ChatCompletionRequestPayloads {
}
interface LogChatCompletionRequest<R extends Record<string, any> = ChatCompletionRequestPayloads[keyof ChatCompletionRequestPayloads]> {
    startTime: number;
    model: string;
    providerRegion?: string;
    provider?: string;
    inputMessages: DebugMessage[];
    request: R;
}
interface LogChatCompletionResponse<R extends Record<string, any> = ChatCompletionRequestPayloads[keyof ChatCompletionRequestPayloads]> extends LogChatCompletionRequest<R> {
    latency: number;
    finishReason: string | null;
    tokensUsed: ChatCompletionUsage;
    messageId?: string;
    inheritedSpanAttributes?: Record<string, any>;
}
type LogLevel = 'error' | 'warn' | 'info' | 'debug';
type Loggable = string | number | boolean | undefined | null | object;
type Logger = {
    error: (...msg: Loggable[]) => void;
    warn: (...msg: Loggable[]) => void;
    info: (...msg: Loggable[]) => void;
    debug: (...msg: Loggable[]) => void;
    logException: (exception: unknown) => void;
    chatCompletionRequest: <K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionRequest<ChatCompletionRequestPayloads[K]>) => void;
    chatCompletionResponse: <K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>) => void;
};
interface LogImplementation {
    log(level: LogLevel, message: string): void;
    logException(exception: unknown): void;
    chatCompletionRequest<K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionRequest<ChatCompletionRequestPayloads[K]>): void;
    chatCompletionResponse<K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>): void;
}

declare class LoggingAPI implements Logger {
    private static _instance?;
    private impl;
    /** Empty private constructor prevents end users from constructing a new instance of the API */
    private constructor();
    static getInstance(): LoggingAPI;
    setLogImplementation(impl: LogImplementation): void;
    error: (...msgs: Loggable[]) => void;
    warn: (...msgs: Loggable[]) => void;
    info: (...msgs: Loggable[]) => void;
    debug: (...msgs: Loggable[]) => void;
    logException: (exception: unknown) => void;
    chatCompletionRequest: <K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionRequest<ChatCompletionRequestPayloads[K]>) => void;
    chatCompletionResponse: <K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>) => void;
    private formatMessage;
}
declare const logger: LoggingAPI;

declare abstract class BaseLogImplementation implements LogImplementation {
    protected readonly loggedExceptions: WeakMap<object, boolean>;
    /**
     * @param ctx The current RenderContext
     * @param level The log level, e.g. 'error', 'warn', 'info', 'debug'
     * @param message
     */
    abstract log(level: LogLevel, message: string): void;
    /**
     * Logs exceptions thrown during an element's render.
     */
    logException(exception: unknown): void;
    chatCompletionRequest<K extends keyof ChatCompletionRequestPayloads>(_provider: K, _payload: LogChatCompletionRequest<ChatCompletionRequestPayloads[K]>): void;
    chatCompletionResponse<K extends keyof ChatCompletionRequestPayloads>(_provider: K, _payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>): void;
}

declare class ConsoleLogger extends BaseLogImplementation {
    log(level: LogLevel, message: string): void;
}

declare class NoopLogImplementation extends BaseLogImplementation {
    log(_level: LogLevel, _message: string): void;
}

type SpanContext = {
    traceId: string;
    spanId: string;
};
type SpanLink = {
    context: SpanContext;
    attributes?: SpanAttributes;
};
type ParentSpanContext = {
    traceId: string;
    spanId: string | null;
};
type SpanOptions = {
    attributes?: SpanAttributes;
    parent?: ParentSpanContext;
    links?: SpanLink[];
    startTime?: [number, number];
    spanId?: string;
};
type SpanAttributes = Record<string, any>;
type SpanStatus = 'unset' | 'ok' | 'error';
interface ReadableSpan<Attrs extends SpanAttributes = SpanAttributes> {
    name: string;
    status: SpanStatus;
    spanContext: SpanContext;
    parentSpanId: string | null;
    attributes: Attrs;
    events: SpanEvent[];
    links: SpanLink[];
    startTime: string;
    endTime: string | null;
    ended: boolean;
    duration: number;
}
interface Span<Attrs extends SpanAttributes = SpanAttributes> extends ReadableSpan<Attrs> {
    setAttributes(attributes: Partial<Attrs>): this;
    addLink(context: SpanContext, attributes?: SpanAttributes): this;
    end(endTime?: [number, number]): void;
    addEvent(name: string, attributes: SpanAttributes, startTime?: [number, number]): this;
    recordException(exception: Error | string, time?: [number, number]): this;
}
interface SpanEvent {
    name: string;
    timestamp: string;
    time: [number, number];
    attributes: SpanAttributes;
}
interface SpanProcessor {
    /**
     * Called when a {@link Span} is started, if the `span.isRecording()`
     * returns true.
     * @param span the Span that just started.
     */
    onStart?(span: ReadableSpan): void;
    onSpanEvent?(event: SpanEvent, span: ReadableSpan): void;
    onSpanException?(exceptionEvent: SpanEvent, span: ReadableSpan): void;
    /**
     * Called when a {@link ReadableSpan} is ended, if the `span.isRecording()`
     * returns true.
     * @param span the Span that just ended.
     */
    onEnd(span: ReadableSpan): void;
}
interface Tracer {
    setSpanProcessor(processor: SpanProcessor): void;
    getActiveSpan(): Span | null;
    createSpan(name: string, options?: SpanOptions): Span;
    startSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
    trace<F extends (span: Span) => ReturnType<F>>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
}
interface SpanExporter {
    export(spans: ReadableSpan[]): Promise<void>;
    shutdown?(): Promise<void>;
}

declare class AITraceAPI {
    private static _instance?;
    private aiTracer;
    private noopTracer;
    private enabled;
    /** Empty private constructor prevents end users from constructing a new instance of the API */
    private constructor();
    /** Get the singleton instance of the Trace API */
    static getInstance(): AITraceAPI;
    private get tracer();
    setSpanProcessor(processor: SpanProcessor): void;
    getActiveSpan(): Span | null;
    createSpan(name: string, options?: SpanOptions): Span<SpanAttributes>;
    startSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
    trace<F extends (span: Span) => ReturnType<F>>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
    createTracer(): Tracer;
    enable(): void;
    disable(): void;
    addLink(context: SpanContext, attributes?: SpanAttributes): boolean;
    createLink(context: SpanContext, attributes?: SpanAttributes): SpanLink;
    withSpanContext<F extends (...args: any[]) => ReturnType<F>>(spanContext: SpanContext, fn: F): ReturnType<F>;
}
declare const tracer: AITraceAPI;

declare class AISpanProcessor implements SpanProcessor {
    private readonly exporter;
    constructor(exporter: SpanExporter);
    onStart(_span: ReadableSpan): Promise<void>;
    onEnd(span: ReadableSpan): Promise<void>;
    shutdown(): Promise<void> | undefined;
}

type TraceProps = {
    children: AINode;
    name: string;
    attributes?: SpanAttributes;
};
declare const Trace: AIComponent<TraceProps, AsyncGenerator<string>>;

declare class ChatCompletionError extends Error {
    readonly chatCompletionRequest: Partial<LogChatCompletionRequest>;
    readonly status: number | undefined;
    readonly shouldRetry: boolean;
    readonly originalError?: Error | undefined;
    readonly name = "ChatCompletionError";
    constructor(message: string, chatCompletionRequest: Partial<LogChatCompletionRequest>, status: number | undefined, shouldRetry?: boolean, originalError?: Error | undefined);
}

declare const SystemMessage: (props: {
    children: AINode;
    cachePrompt?: boolean;
}) => AINode;
declare const UserMessage: (props: {
    children: AINode;
    cachePrompt?: boolean;
}) => AINode;
declare const AssistantMessage: (props: {
    children: AINode;
    cachePrompt?: boolean;
}) => AINode;

type ChatCompletionClientAndProvider<K> = {
    client: K;
    provider?: string;
    providerRegion?: string;
    costFn?: (model: string, usage: Omit<ChatCompletionUsage, 'total'>) => number;
};
type GetChatCompletionClientAndProvider<Model, Client> = (model: Model, args: {
    retryCount: number;
    lastError?: Error | null;
}) => Promise<ChatCompletionClientAndProvider<Client>>;

type EvaluatorPrimitive = string | number | boolean;
type EvaluatorResult = {
    key: string;
    passes: boolean;
    result?: EvaluatorPrimitive | EvaluatorPrimitive[];
    score?: number;
    debug?: any;
};
type EvaluatorFn<V extends Record<string, any> = Record<string, any>, O = any> = (variables: V, result: O) => Promise<EvaluatorResult | EvaluatorResult[]>;
interface BasePrompt<V extends Record<string, any> = Record<string, any>, O extends PlainObject | string = any> {
    key: string;
    component: AIComponent<V, Renderable>;
    schema: ZodObject<ZodRawShape>;
    outputSchema?: ZodObject<ZodRawShape>;
    evaluators?: EvaluatorFn<V, O>[];
    llmEvaluators?: EvaluatorFn<V, O>[];
    metadata?: Record<string, any>;
}
interface ObjectPrompt<V extends Record<string, any> = Record<string, any>, O extends PlainObject = PlainObject> extends BasePrompt<V, O> {
    type: 'object';
    component: AIComponent<V, MaybePromise<O>>;
}
interface TextPrompt<V extends Record<string, any> = Record<string, any>> extends BasePrompt<V, string> {
    type: 'text';
}
type Prompt<V extends Record<string, any> = Record<string, any>, O extends PlainObject = PlainObject> = TextPrompt<V> | ObjectPrompt<V, O>;
type InferPromptOutput<P extends Prompt<any, any>> = P extends TextPrompt<any> ? string : P extends ObjectPrompt<any, infer O> ? O : never;
declare const isTextPrompt: <V extends Record<string, any>>(prompt: Prompt<V, any>) => prompt is TextPrompt<V>;
declare const isObjectPrompt: <V extends Record<string, any>, O extends PlainObject>(prompt: Prompt<V, O>) => prompt is ObjectPrompt<V, O>;

type Cost = number;
declare namespace AISpanAttributes {
    type Prompt = {
        promptKey: string;
        variables: Record<string, any>;
        latency?: number;
        timeToFirstToken?: number | null;
        output: string | PlainObject;
        evaluatorError?: string;
        evaluatorResults?: Record<string, EvaluatorResult>;
        parentPromptKey: string | null;
        rootPromptKey: string;
        totalUsage?: ChatCompletionUsage;
        totalCost?: Cost;
        priority?: number | null;
    };
    type Eval = {
        parentPromptKey: string;
        evaluatorResults: Record<string, EvaluatorResult>;
    };
    type ChatCompletion<K extends keyof ChatCompletionRequestPayloads = keyof ChatCompletionRequestPayloads> = {
        model: string;
        cost?: number;
        provider?: string;
        providerRegion?: string;
        retryCount?: number;
        requestType: K;
        chatCompletionRequest: ChatCompletionRequestPayloads[K];
        inputMessages: DebugMessage[];
        finishReason: string | null;
        latency?: number;
        timeToFirstToken?: number | null;
        output?: string;
        structuredOutput?: any;
        tokensUsed: ChatCompletionUsage;
        parentPromptKey?: string;
        rootPromptKey?: string;
        providerMetadata?: Record<string, any>;
        [key: string]: any;
    };
}

declare class HrTime {
    readonly time: [number, number];
    constructor(time: [number, number]);
    static from(time: [number, number]): HrTime;
    static now(): [number, number];
    toISOString(): string;
    minus(other: HrTime): number;
}

type ExcludeNumber<E extends number, T = number> = T extends E ? never : T;
type RetryCountContextValue = {
    retryCount: 0;
    lastError: null;
} | {
    retryCount: ExcludeNumber<0>;
    lastError: Error;
};
declare const RetryCountContext: AIContext<RetryCountContextValue>;
declare const RetryLastErrorContext: AIContext<Error | null>;
declare const DefaultMaxRetriesContext: AIContext<number>;
type RetryProps = {
    shouldRetry: (error: Error) => boolean;
    retries?: number;
    lastError?: Error;
    maxRetries?: number;
    children: AINode;
};
declare const Retry: AIComponent<RetryProps, AsyncGenerator<string>>;
type AccumulatorProps = {
    enabled?: boolean;
    children: AINode;
};
/**
 * If enabled, renders its children and accumulates the output instead of passing the stream through
 */
declare const Accumulate: AIComponent<AccumulatorProps, Promise<string | AINode>>;

type FallbackProps = {
    fallback: AINode;
    shouldFallback?: (error: Error) => boolean;
    children: AINode;
};
declare function Fallback({ shouldFallback, fallback, children, }: FallbackProps): AsyncGenerator<string, void, unknown>;

type ContinuableProps = {
    prevOutput?: string;
};
type ContinuousOutputOpts<C extends AIComponent<ContinuableProps, Renderable>> = {
    isDone: (props: PropsOfAIComponent<C>, yielded: string[]) => boolean;
    transform?: (chunk: string) => AsyncGenerator<string, string | void>;
    throwOnMaxRetries?: boolean;
};
declare class MaxRetriesError extends Error {
    readonly shouldRetry: boolean;
    readonly name = "MaxRetriesError";
    constructor(message: string, shouldRetry?: boolean);
}
declare function withContinuousOutput<C extends AIComponent<ContinuableProps, Renderable>>(Comp: C, opts: ContinuousOutputOpts<C>): AIComponent<PropsOfAIComponent<C> & {
    maxRetries?: number;
}, Renderable>;

declare function createPrompt<V extends Record<string, any>, O extends PlainObject, P extends {
    type: 'object';
    key: string;
    component: AIComponent<V, MaybePromise<O>>;
    schema: ZodObject<ZodRawShape>;
    outputSchema?: ZodObject<ZodRawShape>;
    evaluators?: EvaluatorFn<V, O>[];
    llmEvaluators?: EvaluatorFn<V, O>[];
    metadata?: Record<string, any>;
}, Ret extends ObjectPrompt<V, O> = P>(prompt: P): Ret;
declare function createPrompt<V extends Record<string, any>, P extends {
    type: 'text';
    key: string;
    component: AIComponent<V, Renderable>;
    schema: ZodObject<ZodRawShape>;
    outputSchema?: ZodObject<ZodRawShape>;
    evaluators?: EvaluatorFn<V, string>[];
    llmEvaluators?: EvaluatorFn<V, string>[];
    metadata?: Record<string, any>;
}, Ret extends TextPrompt<V> = P>(prompt: P): Ret;
declare function createPrompt<V extends Record<string, any>, P extends {
    type?: undefined;
    key: string;
    component: AIComponent<V, Renderable>;
    schema: ZodObject<ZodRawShape>;
    outputSchema?: ZodObject<ZodRawShape>;
    evaluators?: EvaluatorFn<V, string>[];
    llmEvaluators?: EvaluatorFn<V, string>[];
    metadata?: Record<string, any>;
}, Ret extends TextPrompt<V> = P & {
    type: 'text';
}>(prompt: P): Ret;

declare class ParseVariablesError extends Error {
    name: string;
}
declare class PromptInvalidOutputError extends Error {
}

declare function runEvaluators<V extends Record<string, any>, O extends PlainObject | string>(evaluators: EvaluatorFn<V>[], variables: V, output: O): Promise<Record<string, EvaluatorResult>>;
type PromptEvaluatorResults = {
    evaluatorResults: Record<string, EvaluatorResult>;
    totalCost: number;
    totalUsage: ChatCompletionUsage;
};
declare function runPromptEvaluators<V extends Record<string, any>, P extends Prompt<V, any>, O extends PlainObject | string = InferPromptOutput<P>>({ prompt, variables, output, runLlmEvaluators, }: {
    prompt: P;
    variables: V;
    output: O;
    runLlmEvaluators?: boolean;
}): Promise<PromptEvaluatorResults>;

type BasePromptOptions = {
    validateInput?: boolean;
    runLlmEvaluators?: boolean;
    contextValues?: AIContextValues;
    spanAttributes?: SpanAttributes;
    parentSpanContext?: {
        traceId: string;
        spanId: string | null;
    };
    spanLinks?: SpanLink[];
};
type StreamPromptOptions = BasePromptOptions & {};
type RenderPromptOptions = BasePromptOptions & {
    validateOutput?: boolean;
};
declare function renderPrompt<V extends Record<string, any>, O extends PlainObject, P extends Prompt<V, O>>(prompt: P, variables: V, options?: RenderPromptOptions): Promise<InferPromptOutput<P>>;
declare function streamPrompt<V extends Record<string, any>, P extends TextPrompt<V>>(prompt: P, variables: V, options?: StreamPromptOptions): AsyncGenerator<string, void>;

declare const PromptUsageContext: AIContext<PromptUsageTracker | null>;
type PromptHeirarchy = {
    promptKey: string;
    parentPromptKey: string | null;
    rootPromptKey: string;
};
declare class PromptUsageTracker {
    private readonly heirarchy;
    private readonly inheritedSpanAttributes?;
    private readonly onRootChatCompletion?;
    protected ttft: number | null;
    protected totalCost: number;
    protected totalUsage: ChatCompletionUsage;
    constructor(heirarchy: PromptHeirarchy, inheritedSpanAttributes?: Record<string, any> | undefined, onRootChatCompletion?: ((usage: ChatCompletionUsage, cost: number) => void) | undefined);
    onChatCompletion(usage: ChatCompletionUsage, cost: number | undefined): void;
    getInheritedSpanAttributes(): {
        parentPromptKey: string;
        rootPromptKey: string;
    };
    getPromptAttributes(): {
        totalCost: number;
        totalUsage: ChatCompletionUsage;
        rootPromptKey: string;
        parentPromptKey: string | null;
    };
    /**
     * Creates a new PromptUsageTracker, does not contribute to parent PromptUsageTrackers
     *
     * This is useful if you want to "cut off" child chat completions from contributing
     * upwards to the parent prompt
     */
    static create(promptKey: string, inheritedSpanAttributes?: Record<string, any>): PromptUsageTracker;
    /**
     * Creates a new prompt tracker that contributes to the parent prompt
     *
     * This is useful for tracking nested prompt calls, where we want the totalUsage
     * to be contributed to the root prompt
     */
    static inherit(promptKey: string, inheritedSpanAttributes?: Record<string, any>): PromptUsageTracker;
}

type ImageCacheEntry = {
    url: string;
    data: string;
    contentType: string;
};
interface ImageCache {
    fetch(url: string): Promise<ImageCacheEntry>;
}

declare class ImageCacheAPI implements ImageCache {
    private static _instance?;
    private impl;
    /** Empty private constructor prevents end users from constructing a new instance of the API */
    private constructor();
    static getInstance(): ImageCacheAPI;
    setImageCacheImplementation(impl: ImageCache): void;
    fetch: (url: string) => Promise<ImageCacheEntry>;
}
declare const imageCache: ImageCacheAPI;

type OpenAIChatCompletionRequest = OpenAI.Chat.Completions.ChatCompletionCreateParams;

declare module '@gammatech/aijsx' {
    interface ChatCompletionRequestPayloads {
        openai: OpenAIChatCompletionRequest;
    }
}
type ValidOpenAIStructuredOutputModel = 'gpt-4o' | 'gpt-4o-mini' | 'gpt-4.1' | 'gpt-4.1-mini' | 'gpt-4.1-nano' | 'gpt-5' | 'gpt-5-mini' | 'gpt-5-nano';
type ValidOpenAIVisionModel = 'gpt-4o-mini' | 'gpt-4o' | 'gpt-4o-2024-05-13' | 'gpt-4o-2024-08-06' | 'gpt-4o-2024-11-20' | 'gpt-4-turbo-2024-04-09' | 'gpt-4-turbo' | 'gpt-4-vision-preview' | 'gpt-4.1' | 'gpt-4.1-mini' | 'gpt-4.1-nano' | 'gpt-5' | 'gpt-5-mini' | 'gpt-5-nano';
type ValidOpenAIChatModel = ValidOpenAIVisionModel | 'gpt-4' | 'gpt-4-0314' | 'gpt-4-0613' | 'gpt-4-32k' | 'gpt-4-32k-0314' | 'gpt-4-32k-0613' | 'gpt-4-1106-preview' | 'gpt-4-0125-preview' | 'gpt-3.5-turbo' | 'gpt-3.5-turbo-0301' | 'gpt-3.5-turbo-0613' | 'gpt-3.5-turbo-16k' | 'gpt-3.5-turbo-16k-0613' | 'gpt-3.5-turbo-1106' | 'gpt-3.5-turbo-0125' | 'o1' | 'o1-2024-12-17' | 'o1-preview' | 'o1-preview-2024-09-12' | 'o3-mini' | 'o3-mini-2025-01-31';
declare const OpenAIClientContext: AIContext<GetChatCompletionClientAndProvider<ValidOpenAIChatModel, OpenAI>>;
type OpenAIChatCompletionProps = {
    model: ValidOpenAIChatModel;
    maxTokens?: number;
    temperature?: number;
    stop?: string | string[];
    responseFormat?: 'json_object' | 'text';
    maxRetries?: number;
    timeToFirstTokenTimeout?: number;
    stream?: boolean;
    reasoningEffort?: ReasoningEffort;
    children: AINode;
};
declare function OpenAIChatCompletion(props: OpenAIChatCompletionProps): AINode;

type AnthropicChatCompletionRequest = AnthropicClient.Messages.MessageStreamParams & {
    extraHeaders?: Record<string, string>;
};
declare module '@gammatech/aijsx' {
    interface ChatCompletionRequestPayloads {
        anthropic: AnthropicChatCompletionRequest;
    }
}
/**
 * The set of valid Claude models.
 * @see https://docs.anthropic.com/claude/reference/selecting-a-model
 */
type ValidAnthropicChatModel = 'claude-instant-1.2' | 'claude-2.1' | 'claude-3-opus-20240229' | 'claude-3-sonnet-20240229' | 'claude-3-haiku-20240307' | 'claude-3-5-haiku-20241022' | 'claude-3-5-sonnet-20240620' | 'claude-3-5-sonnet-20241022' | 'claude-3-7-sonnet-20250219' | 'claude-sonnet-4-20250514' | 'claude-sonnet-4-5-20250929' | 'claude-opus-4-20250514' | 'claude-opus-4-5-20251101' | 'claude-opus-4-6' | 'claude-haiku-4-5-20251001';
declare const AnthropicClientContext: AIContext<GetChatCompletionClientAndProvider<ValidAnthropicChatModel, AnthropicClient>>;
type EffortLevel = 'low' | 'medium' | 'high';
type AnthropicChatCompletionProps = {
    model: ValidAnthropicChatModel;
    maxTokens?: number;
    temperature?: number;
    stop?: string | string[];
    maxRetries?: number;
    timeToFirstTokenTimeout?: number;
    extraHeaders?: Record<string, string>;
    stream?: boolean;
    children: AINode;
    thinkingBudget?: number;
    outputThinking?: boolean;
    tools?: Array<{
        name: string;
        type: string;
    }> & Record<string, any>;
    effort?: EffortLevel;
};
declare function AnthropicChatCompletion(props: AnthropicChatCompletionProps): JSX.Element;

/**
 * This component aids in debugging prompt caching breakpoints by showing the content
 * between breakpoints and the hash of the content.
 */
type AnthropicPromptCacheDebuggerProps = {
    children: AINode;
    sliceSize?: number;
    hashContent?: boolean;
};
declare const AnthropicPromptCacheDebugger: (props: AnthropicPromptCacheDebuggerProps) => Promise<string>;

type GoogleChatCompletionRequest = GenerateContentParameters & {
    contents: Content[];
};
declare module '@gammatech/aijsx' {
    interface ChatCompletionRequestPayloads {
        google: GoogleChatCompletionRequest;
    }
    interface ChatCompletionResponseFields {
        google: {
            promptFeedback?: GenerateContentResponsePromptFeedback;
        };
    }
}
type ValidGoogleChatModel = 'gemini-2.0-flash-exp' | 'gemini-2.0-flash-001' | 'gemini-2.0-flash-lite-preview-02-05' | 'gemini-2.0-flash-thinking-exp-1219' | 'gemini-2.0-pro-exp-02-05' | 'gemini-2.0-flash-lite-001' | 'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite-preview-06-17' | 'gemini-2.5-flash-preview-09-2025' | 'gemini-2.5-flash-lite-preview-09-2025' | 'gemini-flash-latest' | 'gemini-flash-lite-latest' | 'gemini-2.5-pro-preview-03-25' | 'gemini-2.5-flash-preview-05-20' | 'gemini-2.5-pro-preview-06-05' | 'gemini-3-pro-preview' | 'gemini-3-flash-preview';
declare const GoogleClientContext: AIContext<GetChatCompletionClientAndProvider<ValidGoogleChatModel, GoogleGenAI>>;
type GoogleChatCompletionProps = {
    model: ValidGoogleChatModel;
    maxTokens?: number;
    temperature?: number;
    stop?: string | string[];
    stream?: boolean;
    maxRetries?: number;
    timeToFirstTokenTimeout?: number;
    children: AINode;
    safetySettings?: {
        category: HarmCategory;
        threshold: HarmBlockThreshold;
    }[];
    outputThinking?: boolean;
    thinkingBudget?: number | 'auto';
    responseModalities?: string[];
};
declare function GoogleChatCompletion(props: GoogleChatCompletionProps): JSX.Element;

export { AIComponent, AIContext, AIContextValues, AINode, AIObjectComponent, AISpanAttributes, AISpanProcessor, Accumulate, AnthropicChatCompletion, type AnthropicChatCompletionRequest, AnthropicClientContext, AssistantMessage, BaseLogImplementation, type ChatCompletionClientAndProvider, ChatCompletionError, type ChatCompletionRequestPayloads, type ChatCompletionUsage, type ChatMessage, type ChatRole, ConsoleLogger, type DebugMessage, DefaultMaxRetriesContext, type EvaluatorFn, type EvaluatorResult, Fallback, type GetChatCompletionClientAndProvider, GoogleChatCompletion, type GoogleChatCompletionRequest, GoogleClientContext, HrTime, type ImageCache, type ImageCacheEntry, ImagePart, type ImagePartProps, type InferPromptOutput, type LogChatCompletionRequest, type LogChatCompletionResponse, type LogImplementation, type LogLevel, type Loggable, type Logger, MaxRetriesError, MaybePromise, NoopLogImplementation, type ObjectPrompt, OpenAIChatCompletion, OpenAIClientContext, type ParentSpanContext, ParseVariablesError, PlainObject, type Prompt, PromptInvalidOutputError, PromptUsageContext, PromptUsageTracker, PropsOfAIComponent, type ReadableSpan, RenderModeContext, type RenderObjectOptions, type RenderPromptOptions, type RenderXmlOptions, Renderable, Retry, RetryCountContext, RetryLastErrorContext, type Span, type SpanAttributes, type SpanContext, type SpanEvent, type SpanExporter, type SpanLink, type SpanOptions, type SpanProcessor, type SpanStatus, type StreamPromptOptions, SystemMessage, type TextPrompt, Trace, type Tracer, UserMessage, type ValidAnthropicChatModel, type ValidGoogleChatModel, type ValidOpenAIChatModel, type ValidOpenAIStructuredOutputModel, type ValidOpenAIVisionModel, createContext, createPrompt, AnthropicPromptCacheDebugger as experimental__AnthropicPromptCacheDebugger, getContext, imageCache, isObjectPrompt, isTextPrompt, logger, renderObject, renderPrompt, renderText, renderXml, runEvaluators, runPromptEvaluators, streamPrompt, streamText, toDebugMessage, tracer, withContinuousOutput };