@gammatech/aijsx 0.1.1 → 0.1.2

package/dist/chunk-7GA5BUUP.mjs

@@ -0,0 +1,46 @@
+// src/createElement.ts
+function createAIElement(tag, props, ...children) {
+  const propsToPass = {
+    ...props ?? {},
+    ...children.length === 0 ? {} : { children: children.length === 1 ? children[0] : children }
+  };
+  const result = {
+    tag,
+    props: propsToPass,
+    render: (ctx) => {
+      return tag(propsToPass, ctx);
+    }
+  };
+  return result;
+}
+function isAIElement(value) {
+  return value !== null && typeof value === "object" && "tag" in value;
+}
+function isLiteral(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "undefined" || typeof value === "boolean" || // capture null + undefined
+  value == null;
+}
+function AIFragment({ children }) {
+  return children;
+}
+
+// src/jsx-runtime.ts
+function jsx(type, config, maybeKey) {
+  const configWithKey = maybeKey !== void 0 ? { ...config, key: maybeKey } : config;
+  const children = config && Array.isArray(config.children) ? config.children : [];
+  return createAIElement(type, configWithKey, ...children);
+}
+var jsxDEV = jsx;
+var jsxs = jsx;
+var Fragment = AIFragment;
+
+export {
+  createAIElement,
+  isAIElement,
+  isLiteral,
+  AIFragment,
+  jsx,
+  jsxDEV,
+  jsxs,
+  Fragment
+};

package/dist/createElement-Q_LxUYf8.d.mts

@@ -0,0 +1,159 @@
+type Literal = string | number | null | undefined | boolean;
+interface RenderableStream {
+    [Symbol.asyncIterator]: () => AsyncGenerator<string, void, unknown>;
+}
+interface RenderResult extends RenderableStream {
+    then: (onResolved: (value: string) => void, onRejected?: (reason?: any) => void) => void;
+}
+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> | RenderableStream;
+type PropsOfAIComponent<T extends AIComponent<any>> = T extends AIComponent<infer P> ? P : never;
+
+declare const LoggerContext: Context<LogImplementation>;
+interface RenderContext {
+    parentContext: RenderContext | null;
+    element: AIElement<any>;
+    renderId: string;
+    logger: Logger;
+    getContext<T>(context: Context<T>): T;
+    render(renderable: Renderable): RenderResult;
+}
+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;
+    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 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;
+interface ConversationMessageType<T extends ChatCompletionRole, C extends AIComponent<any>> {
+    type: T;
+    element: AIElement<PropsOfAIComponent<C>>;
+}
+type ConversationMessage = ConversationMessageType<'user', typeof UserMessage> | ConversationMessageType<'assistant', typeof AssistantMessage> | ConversationMessageType<'system', typeof SystemMessage>;
+type RenderedConversationMessage = ConversationMessage & {
+    content: string;
+    tokens: number;
+};
+declare const childrenToConversationMessage: (c: AIElement<any> | AIElement<any>[]) => ConversationMessage[];
+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;
+
+export { type AIElement as A, BoundLogger as B, type Context as C, LogImplementation as L, NoopLogImplementation as N, type PropsOfAIComponent as P, type RenderContext as R, SystemMessage as S, UserMessage as U, type RenderedConversationMessage as a, AIFragment as b, createAIElement as c, LoggerContext as d, createContext as e, AssistantMessage as f, type ConversationMessage as g, childrenToConversationMessage as h, computeUsage as i, ChatCompletionError as j, type ChatCompletionRequestPayloads as k, type LogChatCompletionRequest as l, type LogChatCompletionResponse as m, type LogLevel as n, type Logger as o, ConsoleLogger as p, CombinedLogger as q, type Literal as r, type RenderableStream as s, type RenderResult as t, type AIComponent as u, attachedContextSymbol as v, type AINode as w, type Renderable as x };

package/dist/index.d.mts

@@ -0,0 +1,72 @@
+import { L as LogImplementation, R as RenderContext, C as Context, A as AIElement, a as RenderedConversationMessage } from './createElement-Q_LxUYf8.mjs';
+export { u as AIComponent, b as AIFragment, w as AINode, f as AssistantMessage, B as BoundLogger, j as ChatCompletionError, k as ChatCompletionRequestPayloads, q as CombinedLogger, p as ConsoleLogger, g as ConversationMessage, r as Literal, l as LogChatCompletionRequest, m as LogChatCompletionResponse, n as LogLevel, o as Logger, d as LoggerContext, N as NoopLogImplementation, P as PropsOfAIComponent, t as RenderResult, x as Renderable, s as RenderableStream, S as SystemMessage, U as UserMessage, v as attachedContextSymbol, h as childrenToConversationMessage, i as computeUsage, c as createAIElement, e as createContext } from './createElement-Q_LxUYf8.mjs';
+import { OpenAI } from 'openai';
+export { OpenAI as OpenAIClient } from 'openai';
+import AnthropicClient from '@anthropic-ai/sdk';
+export { default as AnthropicClient } from '@anthropic-ai/sdk';
+export { countTokens as countAnthropicTokens } from '@anthropic-ai/tokenizer';
+
+declare function createRenderContext({ logger, rootRenderId, }?: {
+    logger?: LogImplementation;
+    rootRenderId?: string;
+}): RenderContext;
+
+type OpenAIChatCompletionRequest = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming;
+declare module '@gammatech/aijsx' {
+    interface ChatCompletionRequestPayloads {
+        openai: OpenAIChatCompletionRequest;
+    }
+}
+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>;
+type OpenAIChatCompletionProps = {
+    model: ValidOpenAIChatModel;
+    maxTokens?: number;
+    temperature?: number;
+    children: AIElement<any> | AIElement<any>[];
+    provider?: string;
+    providerRegion?: string;
+};
+declare function OpenAIChatCompletion(props: OpenAIChatCompletionProps, { logger, render, getContext }: RenderContext): AsyncGenerator<string, void, unknown>;
+
+declare const tokenizer: {
+    encode: (text: string) => number[];
+    decode: (tokens: number[]) => string;
+};
+declare function tokenLimitForChatModel(model: ValidOpenAIChatModel): number | undefined;
+declare function tokenCountForConversationMessage(message: Pick<RenderedConversationMessage, 'type' | 'content'>): number;
+
+type AnthropicChatCompletionRequest = AnthropicClient.CompletionCreateParams;
+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';
+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 AnthropicChatCompletionProps = {
+    model: ValidAnthropicChatModel;
+    maxTokens?: number;
+    temperature?: number;
+    children: AIElement<any> | AIElement<any>[];
+    provider?: string;
+    providerRegion?: string;
+};
+/**
+ * An AI.JSX component that invokes an Anthropic Large Language Model.
+ * @param children The children to render.
+ * @param chatModel The chat model to use.
+ * @param completionModel The completion model to use.
+ * @param client The Anthropic client.
+ */
+declare function AnthropicChatCompletion(props: AnthropicChatCompletionProps, { render, logger, getContext }: RenderContext): AsyncGenerator<string, void, unknown>;
+
+export { AIElement, AnthropicChatCompletion, type AnthropicChatCompletionRequest, AnthropicClientContext, Context, LogImplementation, OpenAIChatCompletion, type OpenAIChatCompletionRequest, OpenAIClientContext, RenderContext, RenderedConversationMessage, type ValidAnthropicChatModel, type ValidOpenAIChatModel, createRenderContext, defaultMaxTokens, tokenCountForConversationMessage, tokenLimitForChatModel, tokenizer };

package/dist/index.mjs

@@ -0,0 +1,771 @@
+import {
+  AIFragment,
+  createAIElement,
+  isAIElement,
+  isLiteral,
+  jsx,
+  jsxs
+} from "./chunk-7GA5BUUP.mjs";
+
+// src/chat.tsx
+var SystemMessage = (props) => {
+  return props.children;
+};
+var UserMessage = (props) => {
+  return props.children;
+};
+var AssistantMessage = (props) => {
+  return props.children;
+};
+var childrenToConversationMessage = (c) => {
+  const children = Array.isArray(c) ? c : [c];
+  return children.map((child) => {
+    if (child.tag.name === "UserMessage") {
+      return {
+        type: "user",
+        element: child
+      };
+    } else if (child.tag.name === "SystemMessage") {
+      return {
+        type: "system",
+        element: child
+      };
+    } else if (child.tag.name === "AssistantMessage") {
+      return {
+        type: "assistant",
+        element: child
+      };
+    } else {
+      throw new Error("OpenAI: unknown message type");
+    }
+  });
+};
+var computeUsage = (messages) => {
+  const prompt = messages.filter((m) => m.type === "user" || m.type === "system").reduce((acc, m) => acc + m.tokens, 0);
+  const completion = messages.filter((m) => m.type === "assistant").reduce((acc, m) => acc + m.tokens, 0);
+  return {
+    prompt,
+    completion,
+    total: prompt + completion
+  };
+};
+var ChatCompletionError = class extends Error {
+  constructor(message, chatCompletionRequest) {
+    super(message);
+    this.chatCompletionRequest = chatCompletionRequest;
+  }
+};
+
+// src/EventEmitter.ts
+var EventEmitter = class {
+  listeners = {};
+  piped = [];
+  on(key, handler) {
+    this.listeners[key] = this.listeners[key] || [];
+    this.listeners[key].push(handler);
+    return () => {
+      const ind = this.listeners[key].indexOf(handler);
+      if (ind > -1) {
+        this.listeners[key].splice(ind, 1);
+      }
+    };
+  }
+  off(key, handler) {
+    if (typeof handler === "function") {
+      const ind = this.listeners[key].indexOf(handler);
+      if (ind > -1) {
+        this.listeners[key].splice(ind, 1);
+      }
+    } else {
+      this.listeners[key] = [];
+    }
+  }
+  emit(key, payload) {
+    const fns = this.listeners[key] || [];
+    fns.forEach((fn) => fn(payload));
+    this.piped.forEach((emitter) => {
+      emitter.emit(key, payload);
+    });
+  }
+  pipe(emitter) {
+    this.piped.push(emitter);
+    return () => {
+      const ind = this.piped.indexOf(emitter);
+      if (ind > -1) {
+        this.piped.splice(ind, 1);
+      }
+    };
+  }
+};
+
+// src/log.ts
+var LogImplementation = class {
+  loggedExceptions = /* @__PURE__ */ new WeakMap();
+  /**
+   * Logs exceptions thrown during an element's render.
+   */
+  logException(ctx, exception) {
+    if (typeof exception === "object" && exception !== null) {
+      if (this.loggedExceptions.has(exception)) {
+        return;
+      }
+      this.loggedExceptions.set(exception, true);
+    }
+    const elementTag = `<${ctx.element.tag.name}>`;
+    this.log(
+      ctx,
+      "error",
+      `Rendering element ${elementTag} failed with exception: ${exception}`
+    );
+  }
+  chatCompletionRequest(_ctx, _provider, _payload) {
+  }
+  chatCompletionResponse(_ctx, _provider, _payload) {
+  }
+};
+var BoundLogger = class {
+  constructor(impl, ctx) {
+    this.impl = impl;
+    this.ctx = ctx;
+  }
+  formatMessage = (...msgs) => msgs.map((m) => {
+    if (typeof m === "string") {
+      return m;
+    } else if (typeof m === "number") {
+      return m.toString();
+    } else if (typeof m === "boolean") {
+      return m ? "true" : "false";
+    } else if (m === void 0) {
+      return "undefined";
+    } else if (m === null) {
+      return "null";
+    } else {
+      return JSON.stringify(m);
+    }
+  }).join(" ");
+  error = (...msgs) => this.impl.log(this.ctx, "error", this.formatMessage(...msgs));
+  warn = (...msgs) => this.impl.log(this.ctx, "warn", this.formatMessage(...msgs));
+  info = (...msgs) => this.impl.log(this.ctx, "info", this.formatMessage(...msgs));
+  debug = (...msgs) => this.impl.log(this.ctx, "debug", this.formatMessage(...msgs));
+  logException = (exception) => this.impl.logException(this.ctx, exception);
+  chatCompletionRequest = (provider, payload) => {
+    return this.impl.chatCompletionRequest(this.ctx, provider, payload);
+  };
+  chatCompletionResponse = (provider, payload) => {
+    return this.impl.chatCompletionResponse(this.ctx, provider, payload);
+  };
+};
+var NoopLogImplementation = class extends LogImplementation {
+  log(_ctx, _level, _message) {
+  }
+};
+var ConsoleLogger = class extends LogImplementation {
+  log(ctx, level, message) {
+    console.log(
+      `[${level}] <${ctx.element.tag.name}> id=${ctx.renderId} ${message}`
+    );
+  }
+};
+var CombinedLogger = class extends LogImplementation {
+  constructor(loggers) {
+    super();
+    this.loggers = loggers;
+  }
+  log(...args) {
+    this.loggers.forEach((l) => l.log(...args));
+  }
+  chatCompletionRequest(...args) {
+    this.loggers.forEach((l) => l.chatCompletionRequest(...args));
+  }
+  chatCompletionResponse(...args) {
+    this.loggers.forEach((l) => l.chatCompletionResponse(...args));
+  }
+};
+
+// src/utils.ts
+import { nanoid } from "nanoid";
+function uuidv4() {
+  return nanoid();
+}
+function getEnvVar(name, shouldThrow = true) {
+  let env = globalThis.process?.env ?? void 0;
+  if (env === void 0) {
+    try {
+      env = process.env;
+    } catch {
+    }
+  }
+  const result = env?.[name];
+  if (result === void 0 && shouldThrow) {
+    throw new Error(`Please specify env var '${name}'`);
+  }
+  return result;
+}
+
+// src/render.ts
+function renderLiteral(renderable) {
+  if (typeof renderable === "string") {
+    return renderable;
+  }
+  if (typeof renderable === "number") {
+    return renderable.toString();
+  }
+  if (typeof renderable === "undefined" || typeof renderable === "boolean" || renderable === null) {
+    return "";
+  }
+  return "";
+}
+function Root() {
+  return null;
+}
+function createRenderContext({
+  logger = new NoopLogImplementation(),
+  rootRenderId = uuidv4()
+} = {}) {
+  return new StreamRenderContext(
+    null,
+    createAIElement(Root, {}),
+    rootRenderId,
+    {
+      [LoggerContext.key]: logger || LoggerContext.defaultValue
+    }
+  );
+}
+
+// src/types.ts
+var attachedContextSymbol = Symbol("AI.attachedContext");
+
+// src/context.ts
+var LoggerContext = createContext(
+  new NoopLogImplementation()
+);
+var accumResults = async (result) => {
+  let accum = "";
+  const iterator = result[Symbol.asyncIterator]();
+  for await (const value of iterator) {
+    accum += value;
+  }
+  return accum;
+};
+var ParallelStreamIterator = class extends EventEmitter {
+  values = [];
+  completedStreams = [];
+  cursor = [0, 0];
+  constructor(size) {
+    super();
+    for (let i = 0; i < size; i++) {
+      this.values[i] = [];
+      this.completedStreams[i] = false;
+    }
+  }
+  push(streamInd, value) {
+    const valInd = this.values[streamInd].length;
+    this.values[streamInd].push(value);
+    this.emit("data", {
+      streamInd,
+      valInd,
+      value
+    });
+  }
+  complete(streamInd) {
+    this.completedStreams[streamInd] = true;
+    this.emit("complete", {
+      streamInd
+    });
+  }
+  nextCursor(complete) {
+    const [streamInd, valInd] = this.cursor;
+    if (!complete) {
+      this.cursor = [streamInd, valInd + 1];
+    } else {
+      this.cursor = [streamInd + 1, 0];
+    }
+  }
+  // returns a promise that resolves when this.values[streamInd][valInd] is available
+  resolveAt(streamInd, valInd) {
+    return new Promise((resolve, reject) => {
+      const value = this.values[streamInd][valInd];
+      if (value !== void 0) {
+        resolve({ done: false, value });
+        return;
+      }
+      if (this.completedStreams[streamInd]) {
+        if (streamInd === this.completedStreams.length - 1) {
+          resolve({ done: true, value: void 0 });
+        }
+        reject("next");
+        return;
+      }
+      const unsub = this.on("data", (data) => {
+        if (streamInd === data.streamInd && data.valInd === valInd) {
+          resolve({ done: false, value: data.value });
+          unsub();
+          onCompleteUnsub();
+        }
+      });
+      const onCompleteUnsub = this.on("complete", (data) => {
+        if (streamInd !== data.streamInd) {
+          return;
+        }
+        if (streamInd === this.completedStreams.length - 1) {
+          resolve({ done: true, value: void 0 });
+        }
+        if (this.values[streamInd].length === valInd) {
+          reject("next");
+        }
+        unsub();
+        onCompleteUnsub();
+      });
+    });
+  }
+  async next() {
+    try {
+      const val = await this.resolveAt(...this.cursor);
+      this.nextCursor(false);
+      return val;
+    } catch (e) {
+      if (e !== "next") {
+        throw e;
+      }
+      this.nextCursor(true);
+      const nextStreamVal = await this.resolveAt(...this.cursor);
+      this.nextCursor(false);
+      return nextStreamVal;
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+function coalesceParallelStreams(streams) {
+  const iter = new ParallelStreamIterator(streams.length);
+  streams.forEach(async (s, streamInd) => {
+    for await (const value of s) {
+      iter.push(streamInd, value);
+    }
+    iter.complete(streamInd);
+  });
+  return iter;
+}
+var StreamRenderContext = class _StreamRenderContext {
+  constructor(parentContext, element, renderId, contextValues) {
+    this.parentContext = parentContext;
+    this.element = element;
+    this.renderId = renderId;
+    this.contextValues = contextValues;
+    const logImpl = this.getContext(LoggerContext);
+    this.logger = new BoundLogger(logImpl, this);
+    this.render = (renderable) => {
+      const generator = this.renderStream(renderable);
+      const result = {
+        then: (onFulfilled, onRejected) => accumResults(generator).then(onFulfilled, onRejected),
+        [Symbol.asyncIterator]: () => generator
+      };
+      return result;
+    };
+    const self = this;
+    this.renderStream = async function* (renderable) {
+      if (isLiteral(renderable)) {
+        yield renderLiteral(renderable);
+        return;
+      }
+      if (isAIElement(renderable)) {
+        const ctxValues = attachedContextValues(renderable) || {};
+        const childRenderId = uuidv4();
+        const newCtx = self.enter(renderable, childRenderId, ctxValues);
+        const logger = newCtx.logger;
+        try {
+          return yield* newCtx.render(renderable.render(newCtx));
+        } catch (ex) {
+          logger.logException(ex);
+          throw ex;
+        }
+      }
+      if (Array.isArray(renderable)) {
+        if (renderable.every((r) => isLiteral(r))) {
+          yield renderable.map((r) => renderLiteral(r)).join("");
+          return;
+        }
+        const streams = renderable.filter((a) => !!a).map((r) => self.renderStream(r));
+        const result = coalesceParallelStreams(streams);
+        while (true) {
+          const { value, done } = await result.next();
+          if (done) {
+            return;
+          }
+          yield value;
+        }
+      }
+      if (Symbol.asyncIterator in renderable) {
+        return yield* renderable[Symbol.asyncIterator]();
+      }
+      if (!("then" in renderable)) {
+        throw new Error(
+          `Unexpected renderable type: ${JSON.stringify(renderable)}`
+        );
+      }
+      const next = await renderable.then(
+        (r) => r
+      );
+      return yield* self.render(next);
+    };
+  }
+  render;
+  renderStream;
+  logger;
+  getContext = (context) => {
+    return this.contextValues[context.key] ?? context.defaultValue;
+  };
+  // @internal
+  enter(element, renderId, newCtx) {
+    return new _StreamRenderContext(this, element, renderId, {
+      ...this.contextValues,
+      ...newCtx
+    });
+  }
+};
+function ContextValueProvider({ children }) {
+  return children;
+}
+function createContext(defaultValue) {
+  const key = Symbol();
+  return {
+    Provider: function ContextProvider(props, _compContext) {
+      const additionalContext = {
+        [key]: props.value
+      };
+      return withContextValues(
+        createAIElement(ContextValueProvider, null, props.children),
+        additionalContext
+      );
+    },
+    defaultValue,
+    key
+  };
+}
+function BoundContextValues({ children }) {
+  return children;
+}
+function withContextValues(renderable, additionalContext) {
+  if (isLiteral(renderable)) {
+    return renderable;
+  }
+  if (Array.isArray(renderable)) {
+    return renderable.map((node) => withContextValues(node, additionalContext));
+  }
+  if (isAIElement(renderable)) {
+    if (renderable[attachedContextSymbol]) {
+      return renderable;
+    }
+    const elementWithContext = {
+      ...renderable,
+      [attachedContextSymbol]: additionalContext
+    };
+    return elementWithContext;
+  }
+  return withContextValues(
+    createAIElement(BoundContextValues, null, renderable),
+    additionalContext
+  );
+}
+function attachedContextValues(element) {
+  return element[attachedContextSymbol];
+}
+
+// src/lib/openai/OpenAI.tsx
+import { OpenAI as OpenAIClient } from "openai";
+
+// src/lib/openai/tokenizer.ts
+import { getEncoding } from "js-tiktoken";
+var cl100kTokenizer = getEncoding("cl100k_base");
+var tokenizer = {
+  encode: (text) => cl100kTokenizer.encode(text),
+  decode: (tokens) => cl100kTokenizer.decode(tokens)
+};
+function tokenLimitForChatModel(model) {
+  const TOKENS_CONSUMED_BY_REPLY_PREFIX = 3;
+  switch (model) {
+    case "gpt-4":
+    case "gpt-4-0314":
+    case "gpt-4-0613":
+      return 8192 - TOKENS_CONSUMED_BY_REPLY_PREFIX;
+    case "gpt-4-32k":
+    case "gpt-4-32k-0314":
+    case "gpt-4-32k-0613":
+      return 32768 - TOKENS_CONSUMED_BY_REPLY_PREFIX;
+    case "gpt-4-1106-preview":
+      return 128e3 - TOKENS_CONSUMED_BY_REPLY_PREFIX;
+    case "gpt-3.5-turbo":
+    case "gpt-3.5-turbo-0301":
+    case "gpt-3.5-turbo-0613":
+      return 4096 - TOKENS_CONSUMED_BY_REPLY_PREFIX;
+    case "gpt-3.5-turbo-16k":
+    case "gpt-3.5-turbo-16k-0613":
+    case "gpt-3.5-turbo-1106":
+      return 16384 - TOKENS_CONSUMED_BY_REPLY_PREFIX;
+    default: {
+      const _ = model;
+      return void 0;
+    }
+  }
+}
+function tokenCountForConversationMessage(message) {
+  const TOKENS_PER_MESSAGE = 3;
+  switch (message.type) {
+    case "assistant":
+    case "system":
+    case "user":
+      return TOKENS_PER_MESSAGE + tokenizer.encode(message.content).length;
+  }
+}
+
+// src/lib/openai/OpenAI.tsx
+var defaultClient = null;
+var OpenAIClientContext = createContext(() => {
+  if (defaultClient) {
+    return defaultClient;
+  }
+  const apiKey = getEnvVar("OPENAI_API_KEY", true);
+  defaultClient = new OpenAIClient({ apiKey });
+  return defaultClient;
+});
+async function* OpenAIChatCompletion(props, { logger, render, getContext }) {
+  const startTime = performance.now();
+  const client = getContext(OpenAIClientContext)();
+  if (!client) {
+    throw new Error("[OpenAI] must supply OpenAI model via context");
+  }
+  const renderedMessages = await Promise.all(
+    childrenToConversationMessage(props.children).map(async (message) => {
+      const partiallyRendered = {
+        ...message,
+        content: await render(message.element)
+      };
+      return {
+        ...partiallyRendered,
+        tokens: tokenCountForConversationMessage(partiallyRendered)
+      };
+    })
+  );
+  const chatMessages = renderedMessages.map((m) => {
+    return {
+      content: m.content,
+      role: m.type
+    };
+  });
+  const chatCompletionRequest = {
+    model: props.model,
+    max_tokens: props.maxTokens,
+    temperature: props.temperature,
+    messages: chatMessages,
+    stream: true
+  };
+  const logRequestData = {
+    startTime,
+    model: props.model,
+    provider: props.provider,
+    providerRegion: props.providerRegion,
+    inputMessages: renderedMessages,
+    request: chatCompletionRequest
+  };
+  logger.chatCompletionRequest("openai", logRequestData);
+  let chatResponse;
+  try {
+    chatResponse = await client.chat.completions.create(chatCompletionRequest);
+  } catch (ex) {
+    if (ex instanceof OpenAIClient.APIError) {
+      throw new ChatCompletionError(
+        `OpenAIClient.APIError: ${ex.message}`,
+        logRequestData
+      );
+    } else if (ex instanceof Error) {
+      throw new ChatCompletionError(ex.message, logRequestData);
+    }
+    throw ex;
+  }
+  let finishReason = void 0;
+  let content = "";
+  for await (const message of chatResponse) {
+    if (!message.choices || !message.choices[0]) {
+      continue;
+    }
+    const delta = message.choices[0].delta;
+    if (message.choices[0].finish_reason) {
+      finishReason = message.choices[0].finish_reason;
+    }
+    if (delta.content) {
+      content += delta.content;
+      yield delta.content;
+    }
+  }
+  const outputMessage = {
+    type: "assistant",
+    element: /* @__PURE__ */ jsx(AssistantMessage, { children: content }),
+    content,
+    tokens: tokenCountForConversationMessage({
+      type: "assistant",
+      content
+    })
+  };
+  const responseData = {
+    ...logRequestData,
+    finishReason,
+    latency: performance.now() - startTime,
+    outputMessage,
+    tokensUsed: computeUsage([...renderedMessages, outputMessage])
+  };
+  logger.chatCompletionResponse("openai", responseData);
+}
+
+// src/lib/openai/index.ts
+import { OpenAI as OpenAIClient2 } from "openai";
+
+// src/lib/anthropic/Anthropic.tsx
+import AnthropicClient from "@anthropic-ai/sdk";
+import { countTokens } from "@anthropic-ai/tokenizer";
+var defaultClient2 = null;
+var AnthropicClientContext = createContext(
+  () => {
+    if (defaultClient2) {
+      return defaultClient2;
+    }
+    defaultClient2 = new AnthropicClient({
+      apiKey: getEnvVar("ANTHROPIC_API_KEY", false)
+    });
+    return defaultClient2;
+  }
+);
+var defaultMaxTokens = 4096;
+async function* AnthropicChatCompletion(props, { render, logger, getContext }) {
+  const startTime = performance.now();
+  const client = getContext(AnthropicClientContext)();
+  if (!client) {
+    throw new Error(
+      "[AnthropicChatCompletion] must supply AnthropicClient via context"
+    );
+  }
+  const renderedMessages = await Promise.all(
+    childrenToConversationMessage(props.children).flatMap((message) => {
+      if (message.type === "system") {
+        return [
+          {
+            type: "user",
+            element: /* @__PURE__ */ jsxs(UserMessage, { children: [
+              "For subsequent replies you will adhere to the following instructions: ",
+              message.element
+            ] })
+          },
+          {
+            type: "assistant",
+            element: /* @__PURE__ */ jsx(AssistantMessage, { children: "Okay, I will do that." })
+          }
+        ];
+      }
+      return [message];
+    }).map(async (message) => {
+      const prefix = message.type === "user" ? AnthropicClient.HUMAN_PROMPT : AnthropicClient.AI_PROMPT;
+      const rendered = await render(message.element);
+      const content2 = `${prefix} ${rendered.trim()}`;
+      return {
+        ...message,
+        content: content2,
+        tokens: countTokens(content2)
+      };
+    })
+  );
+  const chatMessages = renderedMessages.map((m) => {
+    return m.content;
+  });
+  chatMessages.push(AnthropicClient.AI_PROMPT);
+  const anthropicCompletionRequest = {
+    prompt: chatMessages.join("\n\n"),
+    max_tokens_to_sample: props.maxTokens ?? defaultMaxTokens,
+    temperature: props.temperature,
+    model: props.model,
+    stream: true
+  };
+  const logRequestData = {
+    startTime,
+    model: props.model,
+    provider: props.provider,
+    providerRegion: props.providerRegion,
+    inputMessages: renderedMessages,
+    request: anthropicCompletionRequest
+  };
+  logger.chatCompletionRequest("anthropic", logRequestData);
+  let response;
+  try {
+    response = await client.completions.create(anthropicCompletionRequest);
+  } catch (err) {
+    if (err instanceof AnthropicClient.APIError) {
+      throw new ChatCompletionError(
+        `AnthropicClient.APIError: ${err.message}`,
+        logRequestData
+      );
+    } else if (err instanceof Error) {
+      throw new ChatCompletionError(err.message, logRequestData);
+    }
+    throw err;
+  }
+  let content = "";
+  let isFirstResponse = true;
+  for await (const completion of response) {
+    let text = completion.completion;
+    if (isFirstResponse && text.length > 0) {
+      isFirstResponse = false;
+      if (text.startsWith(" ")) {
+        text = text.slice(1);
+      }
+    }
+    content += text;
+    yield text;
+  }
+  const outputMessage = {
+    type: "assistant",
+    element: /* @__PURE__ */ jsx(AssistantMessage, { children: content }),
+    content,
+    tokens: countTokens(content)
+  };
+  const responseData = {
+    ...logRequestData,
+    finishReason: "stop",
+    latency: performance.now() - startTime,
+    outputMessage,
+    tokensUsed: computeUsage([...renderedMessages, outputMessage])
+  };
+  logger.chatCompletionResponse("anthropic", responseData);
+}
+
+// src/lib/anthropic/index.ts
+import AnthropicClient2 from "@anthropic-ai/sdk";
+import { countTokens as countAnthropicTokens } from "@anthropic-ai/tokenizer";
+export {
+  AIFragment,
+  AnthropicChatCompletion,
+  AnthropicClient2 as AnthropicClient,
+  AnthropicClientContext,
+  AssistantMessage,
+  BoundLogger,
+  ChatCompletionError,
+  CombinedLogger,
+  ConsoleLogger,
+  LogImplementation,
+  LoggerContext,
+  NoopLogImplementation,
+  OpenAIChatCompletion,
+  OpenAIClient2 as OpenAIClient,
+  OpenAIClientContext,
+  SystemMessage,
+  UserMessage,
+  attachedContextSymbol,
+  childrenToConversationMessage,
+  computeUsage,
+  countAnthropicTokens,
+  createAIElement,
+  createContext,
+  createRenderContext,
+  defaultMaxTokens,
+  tokenCountForConversationMessage,
+  tokenLimitForChatModel,
+  tokenizer
+};

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

@@ -0,0 +1,2 @@
+export { Fragment, JSX, jsx, jsxDEV, jsxs } from './jsx-runtime.mjs';
+import './createElement-Q_LxUYf8.mjs';

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export { Fragment, JSX, jsx, jsxDEV, jsxs } from './jsx-runtime.js';
+import './createElement-Q_LxUYf8.js';

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/jsx-dev-runtime.ts
+var jsx_dev_runtime_exports = {};
+__export(jsx_dev_runtime_exports, {
+  Fragment: () => Fragment,
+  jsx: () => jsx,
+  jsxDEV: () => jsxDEV,
+  jsxs: () => jsxs
+});
+module.exports = __toCommonJS(jsx_dev_runtime_exports);
+
+// src/createElement.ts
+function createAIElement(tag, props, ...children) {
+  const propsToPass = {
+    ...props ?? {},
+    ...children.length === 0 ? {} : { children: children.length === 1 ? children[0] : children }
+  };
+  const result = {
+    tag,
+    props: propsToPass,
+    render: (ctx) => {
+      return tag(propsToPass, ctx);
+    }
+  };
+  return result;
+}
+function AIFragment({ children }) {
+  return children;
+}
+
+// src/jsx-runtime.ts
+function jsx(type, config, maybeKey) {
+  const configWithKey = maybeKey !== void 0 ? { ...config, key: maybeKey } : config;
+  const children = config && Array.isArray(config.children) ? config.children : [];
+  return createAIElement(type, configWithKey, ...children);
+}
+var jsxDEV = jsx;
+var jsxs = jsx;
+var Fragment = AIFragment;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+});

package/dist/jsx-dev-runtime.mjs

@@ -0,0 +1,12 @@
+import {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+} from "./chunk-7GA5BUUP.mjs";
+export {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+};

package/dist/jsx-runtime.d.mts

@@ -0,0 +1,29 @@
+import { u as AIComponent, A as AIElement, b as AIFragment } from './createElement-Q_LxUYf8.mjs';
+
+/**
+ * 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 { Fragment, JSX, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.mjs

@@ -0,0 +1,12 @@
+import {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+} from "./chunk-7GA5BUUP.mjs";
+export {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+};

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@gammatech/aijsx",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Rewrite of aijsx",
   "author": "Jordan Garcia",
   "license": "MIT",
   "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "scripts": {
     "dev": "ts-node ./src/test.tsx",
     "test": "jest --verbose",
     "test:watch": "jest --watch --verbose",
-    "build": "yarn check-types && yarn clean-symlinks && tsup && yarn symlink",
+    "build": "yarn check-types && yarn clean-symlinks && tsup",
     "clean-symlinks": "rm ./jsx-* || true",
     "symlink": "ln -s ./dist/jsx-runtime.js . && ln -s ./dist/jsx-runtime.d.ts && ln -s ./dist/jsx-runtime.js ./jsx-dev-runtime.js && ln -s ./dist/jsx-runtime.d.ts ./jsx-dev-runtime.d.ts",
     "prepublishOnly": "yarn build",
@@ -50,10 +51,7 @@
   "files": [
     "dist",
     "README.md",
-    "jsx-runtime.d.ts",
-    "jsx-runtime.ts",
-    "jsx-dev-runtime.d.ts",
-    "jsx-dev-runtime.ts"
+    "LICENSE"
   ],
   "jest": {
     "moduleFileExtensions": [