@gammatech/aijsx 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,859 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AIFragment: () => AIFragment,
+  AnthropicChatCompletion: () => AnthropicChatCompletion,
+  AnthropicClient: () => import_sdk2.default,
+  AnthropicClientContext: () => AnthropicClientContext,
+  AssistantMessage: () => AssistantMessage,
+  BoundLogger: () => BoundLogger,
+  ChatCompletionError: () => ChatCompletionError,
+  CombinedLogger: () => CombinedLogger,
+  ConsoleLogger: () => ConsoleLogger,
+  LogImplementation: () => LogImplementation,
+  LoggerContext: () => LoggerContext,
+  NoopLogImplementation: () => NoopLogImplementation,
+  OpenAIChatCompletion: () => OpenAIChatCompletion,
+  OpenAIClient: () => import_openai2.OpenAI,
+  OpenAIClientContext: () => OpenAIClientContext,
+  SystemMessage: () => SystemMessage,
+  UserMessage: () => UserMessage,
+  attachedContextSymbol: () => attachedContextSymbol,
+  childrenToConversationMessage: () => childrenToConversationMessage,
+  computeUsage: () => computeUsage,
+  countAnthropicTokens: () => import_tokenizer3.countTokens,
+  createAIElement: () => createAIElement,
+  createContext: () => createContext,
+  createRenderContext: () => createRenderContext,
+  defaultMaxTokens: () => defaultMaxTokens,
+  tokenCountForConversationMessage: () => tokenCountForConversationMessage,
+  tokenLimitForChatModel: () => tokenLimitForChatModel,
+  tokenizer: () => tokenizer
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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/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/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
+var import_nanoid = require("nanoid");
+function uuidv4() {
+  return (0, import_nanoid.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
+var import_openai = require("openai");
+
+// src/lib/openai/tokenizer.ts
+var import_js_tiktoken = require("js-tiktoken");
+var cl100kTokenizer = (0, import_js_tiktoken.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/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 jsxs = jsx;
+
+// src/lib/openai/OpenAI.tsx
+var defaultClient = null;
+var OpenAIClientContext = createContext(() => {
+  if (defaultClient) {
+    return defaultClient;
+  }
+  const apiKey = getEnvVar("OPENAI_API_KEY", true);
+  defaultClient = new import_openai.OpenAI({ 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 import_openai.OpenAI.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
+var import_openai2 = require("openai");
+
+// src/lib/anthropic/Anthropic.tsx
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var import_tokenizer2 = require("@anthropic-ai/tokenizer");
+var defaultClient2 = null;
+var AnthropicClientContext = createContext(
+  () => {
+    if (defaultClient2) {
+      return defaultClient2;
+    }
+    defaultClient2 = new import_sdk.default({
+      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" ? import_sdk.default.HUMAN_PROMPT : import_sdk.default.AI_PROMPT;
+      const rendered = await render(message.element);
+      const content2 = `${prefix} ${rendered.trim()}`;
+      return {
+        ...message,
+        content: content2,
+        tokens: (0, import_tokenizer2.countTokens)(content2)
+      };
+    })
+  );
+  const chatMessages = renderedMessages.map((m) => {
+    return m.content;
+  });
+  chatMessages.push(import_sdk.default.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 import_sdk.default.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: (0, import_tokenizer2.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
+var import_sdk2 = __toESM(require("@anthropic-ai/sdk"));
+var import_tokenizer3 = require("@anthropic-ai/tokenizer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIFragment,
+  AnthropicChatCompletion,
+  AnthropicClient,
+  AnthropicClientContext,
+  AssistantMessage,
+  BoundLogger,
+  ChatCompletionError,
+  CombinedLogger,
+  ConsoleLogger,
+  LogImplementation,
+  LoggerContext,
+  NoopLogImplementation,
+  OpenAIChatCompletion,
+  OpenAIClient,
+  OpenAIClientContext,
+  SystemMessage,
+  UserMessage,
+  attachedContextSymbol,
+  childrenToConversationMessage,
+  computeUsage,
+  countAnthropicTokens,
+  createAIElement,
+  createContext,
+  createRenderContext,
+  defaultMaxTokens,
+  tokenCountForConversationMessage,
+  tokenLimitForChatModel,
+  tokenizer
+});