@gammatech/aijsx 0.4.0-beta.8 → 0.4.1-beta.1

package/README.md

@@ -208,6 +208,8 @@ export interface RenderContext {
 
   element: AIElement<any>
 
+  renderId: string
+
   logger: Logger
 
   getContext<T>(context: Context<T>): T

package/dist/{createElement-VpIrgHrz.d.mts → createElement-SrLGhR1z.d.mts}

@@ -1,11 +1,8 @@
 import { ZodTypeAny, ZodObject, ZodRawShape } from 'zod';
 
 type Literal = string | number | null | undefined | boolean;
-interface RenderableStream extends AsyncGenerator<string, void, unknown> {
-    [Symbol.asyncIterator]: () => AsyncGenerator<string, void, unknown>;
-}
-interface RenderResult extends RenderableStream {
-    then: (onResolved: (value: string) => void, onRejected?: (reason?: any) => void) => void;
+interface RenderResult extends AsyncGenerator<string, void> {
+    then(onFulfilled: (value: string) => string | PromiseLike<string>, onRejected?: (reason: any) => string | PromiseLike<string>): PromiseLike<string>;
 }
 interface Context<T> {
     Provider: AIComponent<{
@@ -28,7 +25,7 @@ interface AIElement<P> {
     [attachedContextSymbol]?: Record<symbol, any>;
 }
 type AINode = Literal | AIElement<any> | AINode[];
-type Renderable = AINode | PromiseLike<Renderable> | RenderableStream;
+type Renderable = AINode | PromiseLike<Renderable> | AsyncGenerator<string, void>;
 type PropsOfAIComponent<T extends AIComponent<any>> = T extends AIComponent<infer P> ? P : never;
 
 type EvaluatorPrimitive = string | number | boolean;
@@ -44,9 +41,6 @@ type OutputParser<O> = {
     schema: ZodTypeAny;
     parse: (result: string) => O;
 };
-interface PromptRenderResult<O> extends RenderableStream {
-    then: (onResolved: (value: O) => void, onRejected?: (reason?: any) => void) => void;
-}
 interface Prompt<V extends Record<string, any> = Record<string, any>> {
     key: string;
     component: AIComponent<V>;
@@ -80,7 +74,115 @@ interface StreamChain<V extends Record<string, any> = Record<string, any>, R ext
 type IsAsyncGenerator<T> = T extends AsyncGenerator<any, any, any> ? true : false;
 type NotAsyncGenerator<T> = IsAsyncGenerator<T> extends true ? never : T;
 
-declare const LoggerContext: Context<LogImplementation>;
+type SpanContext = {
+    traceId: string;
+    spanId: string;
+};
+type SpanAttributes = Record<string, any>;
+type SpanStatus = 'unset' | 'ok' | 'error';
+interface ReadableSpan {
+    name: string;
+    status: SpanStatus;
+    spanContext: SpanContext;
+    parentSpanId: string | null;
+    attributes: SpanAttributes;
+    events: SpanEvent[];
+    startTime: string;
+    endTime: string | null;
+    ended: boolean;
+    duration: number;
+}
+interface Span extends ReadableSpan {
+    setAttributes(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 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 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 {
+    /**
+     * 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 {
+    getActiveSpan(): Span | null;
+    trace<F extends (span: Span) => ReturnType<F>>(name: string, attributes: SpanAttributes, fn: F): ReturnType<F>;
+}
+interface SpanExporter {
+    export(spans: ReadableSpan[]): Promise<void>;
+    shutdown?(): Promise<void>;
+}
+
 type ContextValues = Record<symbol, any>;
 type RenderOptions = {
     preserveTags?: boolean;
@@ -90,16 +192,8 @@ type RenderOptions = {
         };
     };
 };
-type RenderTraceInfo = {
-    traceId: string;
-    spanId: string;
-    parentSpanId: string | null;
-    renderType: 'element' | 'chain' | 'prompt' | 'root';
-    key: string;
-    parent: RenderTraceInfo | null;
-};
 interface RenderContext {
-    traceInfo: RenderTraceInfo;
+    tracer: Tracer;
     logger: Logger;
     getContext<T>(context: Context<T>): T;
     render(renderable: Renderable, opts?: RenderOptions): RenderResult;
@@ -107,67 +201,19 @@ interface RenderContext {
     render<V extends Record<string, any>>(prompt: Prompt<V>, variables: V): RenderResult;
     render<V extends Record<string, any>, O extends AsyncGenerator<any>>(chain: StreamChain<V, O>, variables: V): AsyncGenerator<O, void>;
     render<V extends Record<string, any>, O>(chain: FunctionChain<V, O>, variables: V): O;
-    runChain<V extends Record<string, any>, R>(chain: FunctionChain<V, R>, variables: V): R;
-    runChain<V extends Record<string, any>, R extends AsyncGenerator<any>>(chain: StreamChain<V, R>, variables: V): R;
 }
 type RenderPromptOptions = {
     validateOutput?: boolean;
 };
 declare function createContext<T>(defaultValue: T): Context<T>;
 
-interface LogChainStart {
-    startTime: string;
-    chainKey: string;
-    variables: Record<string, any>;
-    chainType: 'function' | 'stream';
-}
-interface LogChainComplete {
-    startTime: string;
-    endTime: string;
-    latency: number;
-    chainKey: string;
-    variables: Record<string, any>;
-    chainType: 'function' | 'stream';
-    output: any;
-}
-interface LogChainError {
-    startTime: string;
-    endTime: string;
-    latency: number;
-    chainKey: string;
-    variables: Record<string, any>;
-    chainType: 'function' | 'stream';
-    error: Error;
-}
-interface LogPromptStart {
-    startTime: string;
-    promptKey: string;
-    variables: Record<string, any>;
-}
-interface LogPromptComplete {
-    startTime: string;
-    endTime: string;
-    latency: number;
-    promptKey: string;
-    variables: Record<string, any>;
-    output: any;
-}
-interface LogPromptError {
-    startTime: string;
-    endTime: string;
-    latency: number;
-    promptKey: string;
-    variables: Record<string, any>;
-    error: Error;
-}
 /**
  * This can be extended using declare module to add additional providers.
  */
 interface ChatCompletionRequestPayloads {
 }
 interface LogChatCompletionRequest<R extends Record<string, any> = ChatCompletionRequestPayloads[keyof ChatCompletionRequestPayloads]> {
-    requestId: string;
-    startTime: string;
+    startTime: number;
     model: string;
     providerRegion?: string;
     provider?: string;
@@ -175,9 +221,6 @@ interface LogChatCompletionRequest<R extends Record<string, any> = ChatCompletio
     request: R;
 }
 interface LogChatCompletionResponse<R extends Record<string, any> = ChatCompletionRequestPayloads[keyof ChatCompletionRequestPayloads]> extends LogChatCompletionRequest<R> {
-    requestId: string;
-    startTime: string;
-    endTime: string;
     latency: number;
     outputMessage: RenderedConversationMessage;
     finishReason: string;
@@ -189,25 +232,12 @@ interface LogChatCompletionResponse<R extends Record<string, any> = ChatCompleti
 }
 type LogLevel = 'error' | 'warn' | 'info' | 'debug';
 type Loggable = string | number | boolean | undefined | null | object;
-type LogContext = {
-    renderType: 'element' | 'chain' | 'prompt';
-    key: string;
-    spanId: string;
-    traceId: string;
-    parentSpanId: string;
-};
 type Logger = {
     error: (...msg: Loggable[]) => void;
     warn: (...msg: Loggable[]) => void;
     info: (...msg: Loggable[]) => void;
     debug: (...msg: Loggable[]) => void;
     logException: (exception: unknown) => void;
-    chainStart(chain: FunctionChain | StreamChain, payload: LogChainStart): void;
-    chainComplete(chain: FunctionChain | StreamChain, payload: LogChainComplete): void;
-    chainError(chain: FunctionChain | StreamChain, payload: LogChainError): void;
-    promptStart(prompt: Prompt, payload: LogPromptStart): void;
-    promptComplete(prompt: Prompt, payload: LogPromptComplete): void;
-    promptError(prompt: Prompt, payload: LogPromptError): 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;
 };
@@ -218,30 +248,18 @@ declare abstract class LogImplementation {
      * @param level The log level, e.g. 'error', 'warn', 'info', 'debug'
      * @param message
      */
-    abstract log(ctx: RenderTraceInfo, level: LogLevel, message: string): void;
+    abstract log(ctx: RenderContext, level: LogLevel, message: string): void;
     /**
      * Logs exceptions thrown during an element's render.
      */
-    logException(ctx: RenderTraceInfo, exception: unknown): void;
-    chainStart(_ctx: RenderTraceInfo, _chain: FunctionChain | StreamChain, _payload: LogChainStart): void;
-    chainComplete(_ctx: RenderTraceInfo, _chain: FunctionChain | StreamChain, _payload: LogChainComplete): void;
-    chainError(_ctx: RenderTraceInfo, _chain: FunctionChain | StreamChain, _payload: LogChainError): void;
-    promptStart(_ctx: RenderTraceInfo, _prompt: Prompt, _payload: LogPromptStart): void;
-    promptComplete(_ctx: RenderTraceInfo, _prompt: Prompt, _payload: LogPromptComplete): void;
-    promptError(_ctx: RenderTraceInfo, _prompt: Prompt, _payload: LogPromptError): void;
-    chatCompletionRequest<K extends keyof ChatCompletionRequestPayloads>(_ctx: RenderTraceInfo, _provider: K, _payload: LogChatCompletionRequest<ChatCompletionRequestPayloads[K]>): void;
-    chatCompletionResponse<K extends keyof ChatCompletionRequestPayloads>(_ctx: RenderTraceInfo, _provider: K, _payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>): void;
+    logException(ctx: RenderContext, exception: unknown): void;
+    chatCompletionRequest<K extends keyof ChatCompletionRequestPayloads>(_ctx: RenderContext, _provider: K, _payload: LogChatCompletionRequest<ChatCompletionRequestPayloads[K]>): void;
+    chatCompletionResponse<K extends keyof ChatCompletionRequestPayloads>(_ctx: RenderContext, _provider: K, _payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>): void;
 }
 declare class BoundLogger implements Logger {
     private readonly impl;
     private readonly ctx;
-    constructor(impl: LogImplementation, ctx: RenderTraceInfo);
-    chainStart(chain: FunctionChain | StreamChain, payload: LogChainStart): void;
-    chainComplete(chain: FunctionChain | StreamChain, payload: LogChainComplete): void;
-    chainError(chain: FunctionChain | StreamChain, payload: LogChainError): void;
-    promptStart(prompt: Prompt, payload: LogPromptStart): void;
-    promptComplete(prompt: Prompt, payload: LogPromptComplete): void;
-    promptError(prompt: Prompt, payload: LogPromptError): void;
+    constructor(impl: LogImplementation, ctx: RenderContext);
     private formatMessage;
     error: (...msgs: Loggable[]) => void;
     warn: (...msgs: Loggable[]) => void;
@@ -252,21 +270,15 @@ declare class BoundLogger implements Logger {
     chatCompletionResponse: <K extends keyof ChatCompletionRequestPayloads>(provider: K, payload: LogChatCompletionResponse<ChatCompletionRequestPayloads[K]>) => void;
 }
 declare class NoopLogImplementation extends LogImplementation {
-    log(_ctx: RenderTraceInfo, _level: LogLevel, _message: string): void;
+    log(_ctx: RenderContext, _level: LogLevel, _message: string): void;
 }
 declare class ConsoleLogger extends LogImplementation {
-    log(ctx: RenderTraceInfo, level: LogLevel, message: string): void;
+    log(ctx: RenderContext, level: LogLevel, message: string): void;
 }
 declare class CombinedLogger extends LogImplementation {
     private readonly loggers;
     constructor(loggers: LogImplementation[]);
     log(...args: Parameters<LogImplementation['log']>): void;
-    chainStart(...args: Parameters<LogImplementation['chainStart']>): void;
-    chainComplete(...args: Parameters<LogImplementation['chainComplete']>): void;
-    chainError(...args: Parameters<LogImplementation['chainError']>): void;
-    promptStart(...args: Parameters<LogImplementation['promptStart']>): void;
-    promptComplete(...args: Parameters<LogImplementation['promptComplete']>): void;
-    promptError(...args: Parameters<LogImplementation['promptError']>): void;
     chatCompletionRequest<_K extends keyof ChatCompletionRequestPayloads>(...args: Parameters<LogImplementation['chatCompletionRequest']>): void;
     chatCompletionResponse<_K extends keyof ChatCompletionRequestPayloads>(...args: Parameters<LogImplementation['chatCompletionResponse']>): void;
 }
@@ -306,4 +318,4 @@ declare function AIFragment({ children }: {
     children: AINode;
 }): Renderable;
 
-export { type AIComponent as A, type Logger as B, type ContextValues as C, BoundLogger as D, type EvaluatorFn as E, type FunctionChain as F, NoopLogImplementation as G, ConsoleLogger as H, CombinedLogger as I, type Literal as J, type RenderableStream as K, LogImplementation as L, type RenderResult as M, type NotAsyncGenerator as N, attachedContextSymbol as O, type PromptParsed as P, type AIElement as Q, type RenderContext as R, type StreamChain as S, type Renderable as T, UserMessage as U, type PropsOfAIComponent as V, type OutputParser as W, type PromptRenderResult as X, type Prompt as a, type EvaluatorResult as b, type Context as c, type AINode as d, createAIElement as e, AIFragment as f, LoggerContext as g, createContext as h, type RenderTraceInfo as i, type ChatCompletionRole as j, SystemMessage as k, AssistantMessage as l, type RenderedConversationMessage as m, computeUsage as n, ChatCompletionError as o, type LogChainStart as p, type LogChainComplete as q, type LogChainError as r, type LogPromptStart as s, type LogPromptComplete as t, type LogPromptError as u, type ChatCompletionRequestPayloads as v, type LogChatCompletionRequest as w, type LogChatCompletionResponse as x, type LogLevel as y, type LogContext as z };
+export { type AIComponent as A, BoundLogger as B, type ContextValues as C, attachedContextSymbol as D, type EvaluatorFn as E, type FunctionChain as F, type AIElement as G, type Renderable as H, type PropsOfAIComponent as I, type SpanContext as J, type SpanAttributes as K, LogImplementation as L, type SpanStatus as M, type NotAsyncGenerator as N, type Span as O, type PromptParsed as P, type SpanEvent as Q, type RenderContext as R, type SpanProcessor as S, type Tracer as T, UserMessage as U, type TracingContextKey as V, type TracingContext as W, type TracingContextManager as X, type OutputParser as Y, type SpanExporter as a, type ReadableSpan as b, type Prompt as c, type StreamChain as d, type EvaluatorResult as e, type Context as f, type AINode as g, createAIElement as h, AIFragment as i, createContext as j, type ChatCompletionRole as k, SystemMessage as l, AssistantMessage as m, type RenderedConversationMessage as n, computeUsage as o, ChatCompletionError as p, type ChatCompletionRequestPayloads as q, type LogChatCompletionRequest as r, type LogChatCompletionResponse as s, type LogLevel as t, type Logger as u, NoopLogImplementation as v, ConsoleLogger as w, CombinedLogger as x, type Literal as y, type RenderResult as z };