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

package/dist/jsx-dev-runtime-LS-DZfkv.d.mts

@@ -0,0 +1,356 @@
+import { ZodTypeAny, ZodObject, ZodRawShape } from 'zod';
+
+type Literal = string | number | null | undefined | boolean;
+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<{
+        children: AINode;
+        value: T;
+    }>;
+    defaultValue: T;
+    key: symbol;
+}
+type AIComponent<P> = (props: P, context: RenderContext) => Renderable;
+declare const attachedContextSymbol: unique symbol;
+interface AIElement<P> {
+    /** The tag associated with this {@link AIElement}. */
+    tag: AIComponent<P>;
+    /** The component properties. */
+    props: P;
+    /** A function that renders this {@link AIElement} to a {@link Renderable}. */
+    render: (ctx: RenderContext) => Renderable;
+    /** The {@link RenderContext} associated with this {@link Element}. */
+    [attachedContextSymbol]?: Record<symbol, any>;
+}
+type AINode = Literal | AIElement<any> | AINode[];
+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;
+type EvaluatorResult = {
+    key: string;
+    result: EvaluatorPrimitive | EvaluatorPrimitive[];
+    passes: boolean;
+    description?: string;
+    debug?: string;
+};
+type EvaluatorFn<V extends Record<string, any> = Record<string, any>, O = any> = (variables: V, result: O) => Promise<EvaluatorResult | EvaluatorResult[]>;
+type OutputParser<O> = {
+    schema: ZodTypeAny;
+    parse: (result: string) => O;
+};
+interface Prompt<V extends Record<string, any> = Record<string, any>> {
+    key: string;
+    component: AIComponent<V>;
+    schema: ZodObject<ZodRawShape>;
+    evaluators: EvaluatorFn<V>[];
+    messageSchema: ZodTypeAny | null;
+    outputSchema: ZodTypeAny;
+    metadata: Record<string, any>;
+}
+interface PromptParsed<V extends Record<string, any> = Record<string, any>, O = any> extends Prompt<V> {
+    evaluators: EvaluatorFn<V, O>[];
+    messageSchema: null;
+    parse: (result: string) => O;
+}
+interface FunctionChain<V extends Record<string, any> = Record<string, any>, R extends NotAsyncGenerator<any> = any> {
+    key: string;
+    chainType: 'function';
+    run: (vars: V, context: RenderContext) => R;
+    schema: ZodObject<ZodRawShape>;
+    messageSchema: null;
+    outputSchema: ZodTypeAny;
+}
+interface StreamChain<V extends Record<string, any> = Record<string, any>, R extends AsyncGenerator<any, any, any> = AsyncGenerator<any, any, any>> {
+    key: string;
+    chainType: 'stream';
+    run: (vars: V, context: RenderContext) => R;
+    schema: ZodObject<ZodRawShape>;
+    messageSchema: ZodTypeAny;
+    outputSchema: null;
+}
+type IsAsyncGenerator<T> = T extends AsyncGenerator<any, any, any> ? true : false;
+type NotAsyncGenerator<T> = IsAsyncGenerator<T> extends true ? never : T;
+
+type SpanContext = {
+    traceId: string;
+    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[];
+    startTime: string;
+    endTime: string | null;
+    ended: boolean;
+    duration: number;
+}
+interface Span<Attrs extends SpanAttributes = SpanAttributes> extends ReadableSpan<Attrs> {
+    setAttributes(attributes: Partial<Attrs>): 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;
+    renderedProps?: {
+        [tagName: string]: {
+            [propName: string]: boolean;
+        };
+    };
+};
+interface RenderContext {
+    tracer: Tracer;
+    logger: Logger;
+    getContext<T>(context: Context<T>): T;
+    render(renderable: Renderable, opts?: RenderOptions): RenderResult;
+    render<V extends Record<string, any>, O>(prompt: PromptParsed<V, O>, variables: V, options?: RenderPromptOptions): Promise<O>;
+    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;
+}
+type RenderPromptOptions = {
+    validateOutput?: boolean;
+};
+declare function createContext<T>(defaultValue: T): Context<T>;
+
+/**
+ * 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: RenderedConversationMessage[];
+    request: R;
+}
+interface LogChatCompletionResponse<R extends Record<string, any> = ChatCompletionRequestPayloads[keyof ChatCompletionRequestPayloads]> extends LogChatCompletionRequest<R> {
+    latency: number;
+    outputMessage: RenderedConversationMessage;
+    finishReason: string | null;
+    tokensUsed: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+}
+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;
+};
+declare abstract class 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(ctx: RenderContext, level: LogLevel, message: string): void;
+    /**
+     * Logs exceptions thrown during an element's render.
+     */
+    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: RenderContext);
+    private formatMessage;
+    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;
+}
+declare class NoopLogImplementation extends LogImplementation {
+    log(_ctx: RenderContext, _level: LogLevel, _message: string): void;
+}
+declare class ConsoleLogger extends LogImplementation {
+    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;
+    chatCompletionRequest<_K extends keyof ChatCompletionRequestPayloads>(...args: Parameters<LogImplementation['chatCompletionRequest']>): void;
+    chatCompletionResponse<_K extends keyof ChatCompletionRequestPayloads>(...args: Parameters<LogImplementation['chatCompletionResponse']>): void;
+}
+
+type ChatCompletionClientAndProvider<K> = {
+    client: K;
+    provider?: string;
+    providerRegion?: string;
+    costFn?: (usage: {
+        prompt: number;
+        completion: number;
+    }) => number;
+};
+type ChatCompletionRole = 'user' | 'system' | 'assistant';
+declare const SystemMessage: (props: {
+    children: AINode;
+}) => AINode;
+declare const UserMessage: (props: {
+    children: AINode;
+}) => AINode;
+declare const AssistantMessage: (props: {
+    children: AINode;
+}) => AINode;
+type RenderedConversationMessage = {
+    role: ChatCompletionRole;
+    content: string;
+    tokens: number;
+};
+declare const computeUsage: (messages: RenderedConversationMessage[]) => {
+    prompt: number;
+    completion: number;
+    total: number;
+};
+declare class ChatCompletionError extends Error {
+    readonly chatCompletionRequest: LogChatCompletionRequest;
+    constructor(message: string, chatCompletionRequest: LogChatCompletionRequest);
+}
+
+declare function createAIElement<P extends {
+    children: C;
+}, C>(tag: AIComponent<P>, props: Omit<P, 'children'> | null, ...children: [C]): AIElement<P>;
+declare function createAIElement<P extends {
+    children: C[];
+}, C>(tag: AIComponent<P>, props: Omit<P, 'children'> | null, ...children: C[]): AIElement<P>;
+declare function AIFragment({ children }: {
+    children: AINode;
+}): Renderable;
+
+/**
+ * The is used as an import source for ts/js files as the JSX transpile functinos
+ */
+
+/** @hidden */
+declare namespace JSX {
+    type ElementType = AIComponent<any>;
+    interface Element extends AIElement<any> {
+    }
+    interface IntrinsicElements {
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+}
+/** @hidden */
+declare function jsx(type: any, config: any, maybeKey?: any): AIElement<{
+    children: any[];
+}>;
+/** @hidden */
+declare const jsxDEV: typeof jsx;
+/** @hidden */
+declare const jsxs: typeof jsx;
+/** @hidden */
+declare const Fragment: typeof AIFragment;
+
+export { jsx as $, type AIComponent as A, BoundLogger as B, type ContextValues as C, type Literal as D, type EvaluatorFn as E, type FunctionChain as F, type RenderResult as G, attachedContextSymbol as H, type AIElement as I, JSX as J, type Renderable as K, LogImplementation as L, type PropsOfAIComponent as M, type NotAsyncGenerator as N, type SpanContext as O, type PromptParsed as P, type SpanStatus as Q, type RenderContext as R, type SpanProcessor as S, type Tracer as T, UserMessage as U, type Span as V, type SpanEvent as W, type TracingContextKey as X, type TracingContext as Y, type TracingContextManager as Z, type OutputParser as _, type ReadableSpan as a, jsxDEV as a0, jsxs as a1, Fragment as a2, type SpanExporter as b, type AINode as c, type SpanAttributes as d, type Prompt as e, type StreamChain as f, type EvaluatorResult as g, type Context as h, type ChatCompletionClientAndProvider as i, createAIElement as j, AIFragment as k, createContext as l, type ChatCompletionRole as m, SystemMessage as n, AssistantMessage as o, type RenderedConversationMessage as p, computeUsage as q, ChatCompletionError as r, type ChatCompletionRequestPayloads as s, type LogChatCompletionRequest as t, type LogChatCompletionResponse as u, type LogLevel as v, type Logger as w, NoopLogImplementation as x, ConsoleLogger as y, CombinedLogger as z };