@gammatech/aijsx 0.5.0-beta.1 → 0.5.0-dev.2024-03-12

package/dist/index.d.ts

@@ -1,402 +1,89 @@
-import { R as RenderContext, C as ContextValues, L as LogImplementation, A as AIComponent, E as EvaluatorFn, P as PromptParsed, a as Prompt, N as NotAsyncGenerator, F as FunctionChain, S as StreamChain, b as EvaluatorResult, c as Context, d as AINode } from './createElement--C_Hwi_c.js';
-export { z as AIElement, f as AIFragment, j as AssistantMessage, B as BoundLogger, m as ChatCompletionError, s as ChatCompletionRequestPayloads, h as ChatCompletionRole, r as CombinedLogger, q as ConsoleLogger, v as Literal, t as LogChatCompletionRequest, u as LogChatCompletionResponse, n as LogLevel, o as Logger, p as NoopLogImplementation, O as OutputParser, H as PromptRenderResult, G as PropsOfAIComponent, x as RenderResult, D as Renderable, w as RenderableStream, k as RenderedConversationMessage, i as SystemMessage, U as UserMessage, y as attachedContextSymbol, l as computeUsage, e as createAIElement, g as createContext } from './createElement--C_Hwi_c.js';
+import { R as RenderContext, L as LogImplementation, S as SpanProcessor, C as ContextValues, T as Tracer, a as ReadableSpan, b as SpanExporter, A as AIComponent, c as AINode, d as SpanAttributes, E as EvaluatorFn, P as PromptParsed, e as Prompt, N as NotAsyncGenerator, F as FunctionChain, f as StreamChain, g as EvaluatorResult, h as Context, i as ChatCompletionClientAndProvider, J as JSX } from './jsx-dev-runtime-LS-DZfkv.js';
+export { I as AIElement, k as AIFragment, o as AssistantMessage, B as BoundLogger, r as ChatCompletionError, s as ChatCompletionRequestPayloads, m as ChatCompletionRole, z as CombinedLogger, y as ConsoleLogger, D as Literal, t as LogChatCompletionRequest, u as LogChatCompletionResponse, v as LogLevel, w as Logger, x as NoopLogImplementation, _ as OutputParser, M as PropsOfAIComponent, G as RenderResult, K as Renderable, p as RenderedConversationMessage, V as Span, O as SpanContext, W as SpanEvent, Q as SpanStatus, n as SystemMessage, Y as TracingContext, X as TracingContextKey, Z as TracingContextManager, U as UserMessage, H as attachedContextSymbol, q as computeUsage, j as createAIElement, l as createContext } from './jsx-dev-runtime-LS-DZfkv.js';
 import { ZodObject, ZodRawShape, ZodTypeAny, ZodString, z } from 'zod';
 import { OpenAI } from 'openai';
 export { OpenAI as OpenAIClient } from 'openai';
 import { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam, ChatCompletionAssistantMessageParam, ChatCompletionCreateParams } from 'openai/resources';
 import AnthropicClient from '@anthropic-ai/sdk';
 export { default as AnthropicClient } from '@anthropic-ai/sdk';
+import { ImageBlockParam } from '@anthropic-ai/sdk/resources';
 export { countTokens as countAnthropicTokens } from '@anthropic-ai/tokenizer';
 
-interface ExceptionWithCode {
-    code: string | number;
-    name?: string;
-    message?: string;
-    stack?: string;
-}
-interface ExceptionWithMessage {
-    code?: string | number;
-    message: string;
-    name?: string;
-    stack?: string;
-}
-interface ExceptionWithName {
-    code?: string | number;
-    message?: string;
-    name: string;
-    stack?: string;
-}
-/**
- * Defines Exception.
- *
- * string or an object with one of (message or name or code) and optional stack
- */
-type Exception = ExceptionWithCode | ExceptionWithMessage | ExceptionWithName | string;
-
-declare class HrTime {
-    readonly time: [number, number];
-    constructor(time: [number, number]);
-    static now(): HrTime;
-    toISOString(): string;
-    minus(other: HrTime): number;
-}
-
-type SpanAttributes = Record<string, any>;
-interface SpanStatus {
-    /** The status code of this message. */
-    code: SpanStatusCode;
-    /** A developer-facing error message. */
-    message?: string;
-}
-interface SpanEvent {
-    timestamp: string;
-    time: [number, number];
-    name: string;
-    attributes: Record<string, any>;
-}
-/**
- * An enumeration of status codes.
- */
-declare enum SpanStatusCode {
-    /**
-     * The default status.
-     */
-    UNSET = 0,
-    /**
-     * The operation has been validated by an Application developer or
-     * Operator to have completed successfully.
-     */
-    OK = 1,
-    /**
-     * The operation contains an error.
-     */
-    ERROR = 2
-}
-/**
- * A SpanContext represents the portion of a {@link Span} which must be
- * serialized and propagated along side of a {@link Baggage}.
- */
-interface SpanContext {
-    /**
-     * The ID of the trace that this span belongs to. It is worldwide unique
-     * with practically sufficient probability by being made as 16 randomly
-     * generated bytes, encoded as a 32 lowercase hex characters corresponding to
-     * 128 bits.
-     */
-    traceId: string;
-    /**
-     * The ID of the Span. It is globally unique with practically sufficient
-     * probability by being made as 8 randomly generated bytes, encoded as a 16
-     * lowercase hex characters corresponding to 64 bits.
-     */
-    spanId: string;
-}
-interface Span {
-    name: string;
-    parentSpanId: string | null;
-    startTime: string;
-    endTime: string | null;
-    duration: number;
-    events: SpanEvent[];
-    /**
-     * Returns the {@link SpanContext} object associated with this Span.
-     *
-     * Get an immutable, serializable identifier for this span that can be used
-     * to create new child spans. Returned SpanContext is usable even after the
-     * span ends.
-     *
-     * @returns the SpanContext object associated with this Span.
-     */
-    spanContext(): SpanContext;
-    attributes: SpanAttributes;
-    /**
-     * Sets an attribute to the span.
-     *
-     * Sets a single Attribute with the key and value passed as arguments.
-     *
-     * @param key the key for this attribute.
-     * @param value the value for this attribute. Setting a value null or
-     *              undefined is invalid and will result in undefined behavior.
-     */
-    setAttribute(key: string, value: any): this;
-    /**
-     * Sets attributes to the span.
-     *
-     * @param attributes the attributes that will be added.
-     *                   null or undefined attribute values
-     *                   are invalid and will result in undefined behavior.
-     */
-    setAttributes(attributes: Record<string, any>): this;
-    /**
-     * Adds an event to the Span.
-     *
-     * @param name the name of the event.
-     * @param [attributesOrStartTime] the attributes that will be added; these are
-     *     associated with this event. Can be also a start time
-     *     if type is {@type TimeInput} and 3rd param is undefined
-     * @param [startTime] start time of the event.
-     */
-    addEvent(name: string, attributes: SpanAttributes, startTime?: HrTime): this;
-    setData(key: string, value: any): this;
-    getData<K = unknown>(key: string): K | undefined;
-    /**
-     * Sets a status to the span. If used, this will override the default Span
-     * status. Default is {@link SpanStatusCode.UNSET}. SetStatus overrides the value
-     * of previous calls to SetStatus on the Span.
-     *
-     * @param status the SpanStatus to set.
-     */
-    setStatus(status: SpanStatus): this;
-    /**
-     * Updates the Span name.
-     *
-     * This will override the name provided via {@link Tracer.startSpan}.
-     *
-     * Upon this update, any sampling behavior based on Span name will depend on
-     * the implementation.
-     *
-     * @param name the Span name.
-     */
-    updateName(name: string): this;
-    /**
-     * Marks the end of Span execution.
-     *
-     * Call to End of a Span MUST not have any effects on child spans. Those may
-     * still be running and can be ended later.
-     *
-     * Do not return `this`. The Span generally should not be used after it
-     * is ended so chaining is not desired in this context.
-     *
-     * @param [endTime] the time to set as Span's end time. If not provided,
-     *     use the current time as the span's end time.
-     */
-    end(endTime?: HrTime): void;
-    /**
-     * Returns the flag whether this span will be recorded.
-     *
-     * @returns true if this Span is active and recording information like events
-     *     with the `AddEvent` operation and attributes using `setAttributes`.
-     */
-    isRecording(): boolean;
-    /**
-     * Sets exception as a span event
-     * @param exception the exception the only accepted values are string or Error
-     * @param [time] the time to set as Span's event time. If not provided,
-     *     use the current time.
-     */
-    recordException(exception: Exception, time?: HrTime): this;
-}
-
-interface TracingContextKey<_T> {
-    key: symbol;
-}
-interface TracingContext {
-    /**
-     * Get a value from the context.
-     *
-     * @param key key which identifies a context value
-     */
-    getValue<T>(key: TracingContextKey<T>): T | undefined;
-    /**
-     * Create a new context which inherits from this context and has
-     * the given key set to the given value.
-     *
-     * @param key context key for which to set the value
-     * @param value value to set for the given key
-     */
-    setValue<T>(key: TracingContextKey<T>, value: T): TracingContext;
-    /**
-     * Return a new context which inherits from this context but does
-     * not contain a value for the given key.
-     *
-     * @param key context key for which to clear a value
-     */
-    deleteValue<T>(key: TracingContextKey<T>): TracingContext;
-}
-
-interface SpanOptions {
-    /** A span's attributes */
-    attributes?: SpanAttributes;
-    /** A manually specified start time for the created `Span` object. */
-    startTime?: number;
-    /** The new span should be a root span. (Ignore parent from context). */
-    root?: boolean;
-}
-interface Tracer {
-    /**
-     * Starts a new {@link Span}. Start the span without setting it on context.
-     *
-     * This method do NOT modify the current Context.
-     *
-     * @param name The name of the span
-     * @param [options] SpanOptions used for span creation
-     * @param [context] Context to use to extract parent
-     * @returns Span The newly created span
-     * @example
-     *     const span = tracer.startSpan('op');
-     *     span.setAttribute('key', 'value');
-     *     span.end();
-     */
-    startSpan(name: string, options?: SpanOptions, context?: TracingContext): Span;
-    /**
-     * Starts a new {@link Span} and calls the given function passing it the
-     * created span as first argument.
-     * Additionally the new span gets set in context and this context is activated
-     * for the duration of the function call.
-     *
-     * @param name The name of the span
-     * @param [options] SpanOptions used for span creation
-     * @param [context] Context to use to extract parent
-     * @param fn function called in the context of the span and receives the newly created span as an argument
-     * @returns return value of fn
-     * @example
-     *     const something = tracer.startActiveSpan('op', span => {
-     *       try {
-     *         do some work
-     *         span.setStatus({code: SpanStatusCode.OK});
-     *         return something;
-     *       } catch (err) {
-     *         span.setStatus({
-     *           code: SpanStatusCode.ERROR,
-     *           message: err.message,
-     *         });
-     *         throw err;
-     *       } finally {
-     *         span.end();
-     *       }
-     *     });
-     *
-     * @example
-     *     const span = tracer.startActiveSpan('op', span => {
-     *       try {
-     *         do some work
-     *         return span;
-     *       } catch (err) {
-     *         span.setStatus({
-     *           code: SpanStatusCode.ERROR,
-     *           message: err.message,
-     *         });
-     *         throw err;
-     *       }
-     *     });
-     *     do some more work
-     *     span.end();
-     */
-    startActiveSpan<F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
-    startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
-    startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, context: TracingContext, fn: F): ReturnType<F>;
-    getActiveSpan(): Span | undefined;
-    setSpanContext(spanContext: SpanContext): TracingContext;
-}
-
 type CreateRenderContextOptions = {
-    parentSpanId?: string | null;
-    traceId?: string | null;
-    contextValues?: ContextValues;
     logger?: LogImplementation;
+    traceId?: string;
+    processor?: SpanProcessor;
+    contextValues?: ContextValues;
 };
-declare function createRenderContext({ parentSpanId, logger, traceId, contextValues, }?: CreateRenderContextOptions): RenderContext;
+declare function createRenderContext({ logger, traceId, processor, contextValues, }?: CreateRenderContextOptions): RenderContext;
 
-interface TracingContextManager {
-    /**
-     * Get the current active context
-     */
-    active(): TracingContext;
-    /**
-     * Run the fn callback with object set as the current active context
-     * @param context Any object to set as the current active context
-     * @param fn A callback to be immediately run within a specific context
-     * @param thisArg optional receiver to be used for calling fn
-     * @param args optional arguments forwarded to fn
-     */
-    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: TracingContext, fn: F, ...args: A): ReturnType<F>;
-    /**
-     * Bind an object as the current context (or a specific one)
-     * @param [context] Optionally specify the context which you want to assign
-     * @param target Any object to which a context need to be set
-     */
-    bind<T>(context: TracingContext, target: T): T;
-    /**
-     * Enable context management
-     */
-    enable(): this;
-    /**
-     * Disable context management
-     */
-    disable(): this;
-}
-
-interface SpanProcessor {
-    /**
-     * Forces to export all finished spans
-     */
-    forceFlush(): Promise<void>;
-    /**
-     * Called when a {@link Span} is started, if the `span.isRecording()`
-     * returns true.
-     * @param span the Span that just started.
-     */
-    onStart(span: Span, parentContext: TracingContext): void;
-    /**
-     * Called when a {@link ReadableSpan} is ended, if the `span.isRecording()`
-     * returns true.
-     * @param span the Span that just ended.
-     */
-    onEnd(span: Span): void;
-    /**
-     * Shuts down the processor. Called when SDK is shut down. This is an
-     * opportunity for processor to do any cleanup required.
-     */
-    shutdown(): Promise<void>;
-}
-
-/**
- * Root public API
- */
-type AITraceInitOptions = {
-    spanProcessors?: SpanProcessor[];
-    contextManager?: TracingContextManager;
-};
 declare class AITraceAPI {
     private static _instance?;
-    private initialized;
+    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;
-    init(options: AITraceInitOptions): Tracer;
-    getTracer(): Tracer;
-    getActiveContext(): TracingContext;
-    reset(): void;
+    createTracer(opts?: {
+        traceId?: string;
+        processor?: SpanProcessor;
+    }): Tracer;
+    enable(): void;
     disable(): void;
-    bind<T>(target: T): T;
 }
+declare const tracing: AITraceAPI;
 
-declare class AsyncLocalStorageContextManager implements TracingContextManager {
-    private asyncLocalStorage;
-    constructor();
-    active(): TracingContext;
-    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: TracingContext, fn: F, ...args: A): ReturnType<F>;
-    enable(): this;
-    disable(): this;
-    /**
-     * Binds a the certain context or the active one to the target function and then returns the target
-     * @param context A context (span) to be bind to target
-     * @param target a function or event emitter. When target or one of its callbacks is called,
-     *  the provided context will be used as the active context for the duration of the call.
-     */
-    bind<T>(context: TracingContext, target: T): T;
-    protected bindFunction<T extends Function>(context: TracingContext, target: T): T;
-    protected bindAsyncGenerator<T = unknown, TReturn = any, TNext = unknown>(generator: AsyncGenerator<T, TReturn, TNext>): AsyncGenerator<T, TReturn, TNext>;
+type CostFn = (tokensUsed: {
+    prompt: number;
+    completion: number;
+    total: number;
+}, opts: {
+    provider?: string;
+    providerRegion?: string;
+    model: string;
+}) => number;
+/**
+ * Handles the following transformation / enrichment
+ * 1. deletes references to prompt (used for evaluation)
+ * 2. evaluatorResults
+ * 3. sum totalCost on the root span
+ * 4. sum totalUsage on the root span
+ */
+declare abstract class EnrichingSpanProcessor implements SpanProcessor {
+    private readonly exporter;
+    protected finalSpans: {
+        status: 'running' | 'processing' | 'done';
+        span: ReadableSpan;
+    }[];
+    protected onAllDonePromise: Promise<void> | null;
+    protected onAllDonePromiseResolve: (() => void) | null;
+    constructor(exporter: SpanExporter);
+    onStart(span: ReadableSpan): Promise<void>;
+    onEnd(span: ReadableSpan): Promise<void>;
+    abstract onTraceComplete(rootSpan: ReadableSpan): Promise<void>;
+    abstract enrichSpan(span: ReadableSpan): Promise<ReadableSpan>;
+    shutdown(): Promise<void> | undefined;
+}
+declare class AISpanProcessor extends EnrichingSpanProcessor {
+    protected totalCost: number;
+    protected totalUsage: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+    onTraceComplete(rootSpan: ReadableSpan): Promise<void>;
+    enrichSpan(span: ReadableSpan): Promise<ReadableSpan>;
+    protected updateCost(span: ReadableSpan): Promise<ReadableSpan>;
+    protected updateUsage(span: ReadableSpan): Promise<ReadableSpan>;
+    protected evaluatePrompt(span: ReadableSpan): Promise<ReadableSpan>;
 }
 
-declare namespace aijsxTracing {
-    const api: AITraceAPI;
-    const AsyncLocalStorageContextManager: typeof AsyncLocalStorageContextManager;
-    type Span = Span;
-    type Tracer = Tracer;
-    type SpanProcessor = SpanProcessor;
-}
+type TraceProps = {
+    children: AINode;
+    name: string;
+    attributes?: SpanAttributes;
+};
+declare const Trace: AIComponent<TraceProps>;
 
 /**
  * This is a helper function to create a JsxPrompt type
@@ -433,10 +120,6 @@ declare function createStreamChain<I extends ZodObject<ZodRawShape>, M extends Z
     messageSchema?: M;
 }): StreamChain<z.infer<I>, R>;
 
-declare class PromptParseVariablesError extends Error {
-}
-declare class ChainParseVariablesError extends Error {
-}
 declare class ParseVariablesError extends Error {
 }
 declare class PromptInvalidOutputError extends Error {
@@ -453,17 +136,15 @@ declare module '@gammatech/aijsx' {
     }
 }
 type ValidOpenAIChatModel = 'gpt-4' | 'gpt-4-0314' | 'gpt-4-0613' | 'gpt-4-32k' | 'gpt-4-32k-0314' | 'gpt-4-32k-0613' | 'gpt-4-1106-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';
-declare const OpenAIClientContext: Context<() => OpenAI>;
+declare const OpenAIClientContext: Context<() => ChatCompletionClientAndProvider<OpenAI>>;
 type OpenAIChatCompletionProps = {
     model: ValidOpenAIChatModel;
     maxTokens?: number;
     temperature?: number;
     responseFormat?: ChatCompletionCreateParams.ResponseFormat['type'];
     children: AINode;
-    provider?: string;
-    providerRegion?: string;
 };
-declare function OpenAIChatCompletion(props: OpenAIChatCompletionProps, { render, logger, getContext }: RenderContext): AsyncGenerator<string, void, unknown>;
+declare function OpenAIChatCompletion(props: OpenAIChatCompletionProps, { logger, render, tracer, getContext }: RenderContext): AsyncGenerator<string, void, unknown>;
 
 type ValidOpenAIVisionModel = 'gpt-4-vision-preview';
 declare const ContentTypeImage: (_props: {
@@ -479,10 +160,8 @@ type OpenAIVisionChatCompletionProps = {
     maxTokens?: number;
     temperature?: number;
     children: AINode;
-    provider?: string;
-    providerRegion?: string;
 };
-declare function OpenAIVisionChatCompletion(props: OpenAIVisionChatCompletionProps, { render, getContext, logger }: RenderContext): AsyncGenerator<string, void, unknown>;
+declare function OpenAIVisionChatCompletion(props: OpenAIVisionChatCompletionProps, { logger, render, tracer, getContext }: RenderContext): AsyncGenerator<string, void, unknown>;
 
 declare const tokenizer: {
     encode: (text: string) => number[];
@@ -492,7 +171,7 @@ declare function tokenLimitForChatModel(model: ValidOpenAIChatModel): number | u
 declare function tokenCountForOpenAIMessage(message: OpenAIChatMessage): number;
 declare function tokenCountForOpenAIVisionMessage(message: OpenAIChatMessage): number;
 
-type AnthropicChatCompletionRequest = AnthropicClient.CompletionCreateParams;
+type AnthropicChatCompletionRequest = AnthropicClient.Messages.MessageStreamParams;
 declare module '@gammatech/aijsx' {
     interface ChatCompletionRequestPayloads {
         anthropic: AnthropicChatCompletionRequest;
@@ -502,19 +181,13 @@ declare module '@gammatech/aijsx' {
  * 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';
-declare const AnthropicClientContext: Context<() => AnthropicClient>;
-/**
- * If you use an Anthropic model without specifying the max tokens for the completion, this value will be used as the default.
- */
-declare const defaultMaxTokens = 4096;
+type ValidAnthropicChatModel = 'claude-instant-1.2' | 'claude-2.1' | 'claude-3-opus-20240229' | 'claude-3-sonnet-20240229';
+declare const AnthropicClientContext: Context<() => ChatCompletionClientAndProvider<AnthropicClient>>;
 type AnthropicChatCompletionProps = {
     model: ValidAnthropicChatModel;
     maxTokens?: number;
     temperature?: number;
     children: AINode;
-    provider?: string;
-    providerRegion?: string;
 };
 /**
  * An AI.JSX component that invokes an Anthropic Large Language Model.
@@ -523,6 +196,16 @@ type AnthropicChatCompletionProps = {
  * @param completionModel The completion model to use.
  * @param client The Anthropic client.
  */
-declare function AnthropicChatCompletion(props: AnthropicChatCompletionProps, { render, getContext, logger }: RenderContext): AsyncGenerator<string, void, unknown>;
+declare function AnthropicChatCompletion(props: AnthropicChatCompletionProps, { render, logger, tracer, getContext }: RenderContext): AsyncGenerator<string, void, unknown>;
+
+type ClaudeImageBlockBase64 = {
+    data: string;
+    mediaType: ImageBlockParam.Source['media_type'];
+};
+type ClaudeImageBlockUrl = {
+    url: string;
+};
+type ClaudeImageBlockProps = ClaudeImageBlockBase64 | ClaudeImageBlockUrl;
+declare const ClaudeImageBlock: (props: ClaudeImageBlockProps) => Promise<JSX.Element>;
 
-export { AIComponent, AINode, AnthropicChatCompletion, type AnthropicChatCompletionRequest, AnthropicClientContext, ChainParseVariablesError, ContentTypeImage, Context, EvaluatorFn, EvaluatorResult, FunctionChain, LogImplementation, NotAsyncGenerator, OpenAIChatCompletion, type OpenAIChatCompletionRequest, type OpenAIChatMessage, OpenAIClientContext, OpenAIVisionChatCompletion, ParseVariablesError, Prompt, PromptInvalidOutputError, PromptParseVariablesError, PromptParsed, RenderContext, StreamChain, type ValidAnthropicChatModel, type ValidOpenAIChatModel, type ValidOpenAIVisionModel, aijsxTracing, createFunctionChain, createPrompt, createRenderContext, createStreamChain, defaultMaxTokens, evaluatePrompt, tokenCountForOpenAIMessage, tokenCountForOpenAIVisionMessage, tokenLimitForChatModel, tokenizer };
+export { AIComponent, AINode, AISpanProcessor, AnthropicChatCompletion, type AnthropicChatCompletionRequest, AnthropicClientContext, ChatCompletionClientAndProvider, ClaudeImageBlock, ContentTypeImage, Context, type CostFn, EnrichingSpanProcessor, EvaluatorFn, EvaluatorResult, FunctionChain, LogImplementation, NotAsyncGenerator, OpenAIChatCompletion, type OpenAIChatCompletionRequest, type OpenAIChatMessage, OpenAIClientContext, OpenAIVisionChatCompletion, ParseVariablesError, Prompt, PromptInvalidOutputError, PromptParsed, ReadableSpan, RenderContext, SpanAttributes, SpanExporter, SpanProcessor, StreamChain, Trace, Tracer, type ValidAnthropicChatModel, type ValidOpenAIChatModel, type ValidOpenAIVisionModel, createFunctionChain, createPrompt, createRenderContext, createStreamChain, evaluatePrompt, tokenCountForOpenAIMessage, tokenCountForOpenAIVisionMessage, tokenLimitForChatModel, tokenizer, tracing };