@poe-platform/safe-bash 0.1.818 → 0.1.819

package/dist/safe-bash/command-chunks/chunk-I7MEH76L.js

@@ -0,0 +1,276 @@
+import {
+  isPythonWhitespace
+} from "./chunk-BZLLQWRK.js";
+
+// packages/safe-bash-command-llm/src/import-json-document.ts
+import { jsonValues } from "../../safe-bash-query-engine/input.js";
+import { Budget, resolveJqLimits } from "../../safe-bash-query-engine/limits.js";
+import { Decimal } from "../../safe-bash-query-engine/numbers.js";
+
+// packages/safe-bash-command-llm/src/json-document-store.ts
+import { IntegerTable, PagedStorage, PagedStorageCache } from "@poe-platform/safe-fs/storage";
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+var nodeTypes = ["object", "array", "string", "number", "boolean", "null"];
+var recordBytes = 56;
+var pageBytes = 16384;
+var JsonStorage = class extends PagedStorage {
+  constructor(fs, directory, signal, limit, cache) {
+    super({ fs, cwd: directory, env: {}, signal }, 4, cache);
+    this.limit = limit;
+  }
+  limit;
+  allocate(length) {
+    const end = super.allocate(0);
+    if (Math.ceil((end + length) / pageBytes) * pageBytes > this.limit) throw new FsError("EFBIG", { message: "JSON staging file byte limit exceeded" });
+    return super.allocate(length);
+  }
+};
+var JsonDocumentStore = class {
+  storage;
+  payload;
+  keys;
+  steps = 0;
+  constructor(options) {
+    if (!Number.isSafeInteger(options.maxFileBytes) || options.maxFileBytes < 1 || !Number.isSafeInteger(options.maxOpenFiles) || options.maxOpenFiles < 1) throw new RangeError("Invalid JSON staging limits");
+    this.signal = options.signal;
+    const cache = new PagedStorageCache(4);
+    this.storage = new JsonStorage(options.fs, options.directory, options.signal, options.maxFileBytes, cache);
+    this.payload = new PagedStorage({ fs: options.fs, cwd: options.directory, env: {}, signal: options.signal }, 4, cache);
+    this.keys = new IntegerTable(this.storage, 64);
+  }
+  signal;
+  async step() {
+    this.signal.throwIfAborted();
+    if (++this.steps % 256 === 0) await yieldTurn(this.signal);
+  }
+  async number(position) {
+    const bytes = await this.storage.read(position, 8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+  }
+  async put(position, value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    await this.storage.write(position, bytes);
+  }
+  async record(values) {
+    const bytes = new Uint8Array(recordBytes), view = new DataView(bytes.buffer);
+    for (let index = 0; index < values.length; index++) view.setFloat64(index * 8, values[index], true);
+    return this.storage.append(bytes);
+  }
+  async appendPoints(points, storage = this.payload) {
+    for (let offset = 0; offset < points.length; offset += pageBytes / 4) {
+      await this.step();
+      const count = Math.min(pageBytes / 4, points.length - offset);
+      const bytes = new Uint8Array(count * 4), view = new DataView(bytes.buffer);
+      for (let index = 0; index < count; index++) view.setUint32(index * 4, points[offset + index], true);
+      await storage.append(bytes);
+    }
+  }
+  async equalKey(entry, points) {
+    const start = await this.number(entry + 16), end = await this.number(entry + 24);
+    if (end - start !== points.length * 4) return false;
+    for (let offset = 0; offset < points.length; offset += pageBytes / 4) {
+      await this.step();
+      const count = Math.min(pageBytes / 4, points.length - offset);
+      const bytes = await this.storage.read(start + offset * 4, count * 4);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      for (let index = 0; index < count; index++) if (view.getUint32(index * 4, true) !== points[offset + index]) return false;
+    }
+    return true;
+  }
+  async insert(type, parent, key, keyPoints, token = "") {
+    await this.step();
+    const id = await this.record([nodeTypes.indexOf(type), parent, 0, 0, 0, 0, 0]);
+    if (token) {
+      const bytes = new TextEncoder().encode(token);
+      const start = await this.storage.append(bytes);
+      await this.put(id + 16, start);
+      await this.put(id + 24, start + bytes.length);
+    }
+    if (parent) {
+      let hash = 0;
+      if (keyPoints) for (const point of keyPoints) hash = Math.imul(hash ^ point, 16777619) >>> 0;
+      hash = (hash ^ parent ^ Math.floor(parent / 4294967296)) >>> 0;
+      const collision = keyPoints ? Number(await this.keys.get(BigInt(hash)) ?? 0n) : 0;
+      let existing = 0;
+      for (let entry = collision; entry; entry = await this.number(entry + 8)) {
+        await this.step();
+        if (await this.number(entry) === parent && await this.equalKey(entry, keyPoints)) {
+          existing = entry;
+          break;
+        }
+      }
+      if (existing) await this.put(existing + 32, id);
+      else {
+        const start = this.storage.allocate(0);
+        if (keyPoints) await this.appendPoints(keyPoints, this.storage);
+        const end = this.storage.allocate(0);
+        const entry = await this.record([parent, collision, start, end, id, 0, keyPoints ? -1 : key]);
+        const tail = await this.number(parent + 40);
+        if (tail) await this.put(tail + 40, entry);
+        else await this.put(parent + 32, entry);
+        await this.put(parent + 40, entry);
+        await this.put(parent + 48, await this.number(parent + 48) + 1);
+        if (keyPoints) await this.keys.set(BigInt(hash), BigInt(entry));
+      }
+    }
+    if (type === "string") await this.put(id + 16, this.payload.allocate(0));
+    return id;
+  }
+  async endString(id) {
+    await this.put(id + 24, this.payload.allocate(0));
+  }
+  async parent(id) {
+    return this.number(id + 8);
+  }
+  async node(id) {
+    await this.step();
+    const type = nodeTypes[await this.number(id)];
+    const start = await this.number(id + 16), end = await this.number(id + 24);
+    let token = "";
+    if (type === "number" || type === "boolean") {
+      const decoder = new TextDecoder();
+      for (let offset = start; offset < end; offset += pageBytes) {
+        await this.step();
+        token += decoder.decode(await this.storage.read(offset, Math.min(pageBytes, end - offset)), { stream: true });
+      }
+      token += decoder.decode();
+    }
+    return { id, type, start, end, token };
+  }
+  async *points(node, storage = this.payload) {
+    if (node.type !== "string") throw new TypeError("JSON node is not a string");
+    for (let offset = node.start; offset < node.end; offset += pageBytes) {
+      await this.step();
+      const bytes = await storage.read(offset, Math.min(pageBytes, node.end - offset));
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length), points = [];
+      for (let index = 0; index < bytes.length; index += 4) points.push(view.getUint32(index, true));
+      yield points;
+    }
+  }
+  async child(parent, after = -1) {
+    await this.step();
+    const entry = after < 0 ? await this.number(parent + 32) : await this.number(after + 40);
+    if (!entry) return void 0;
+    const node = await this.node(await this.number(entry + 32)), key = await this.number(entry + 48);
+    if (key >= 0) return { node, position: entry, key };
+    const keyPoints = [];
+    let text = "";
+    for await (const points of this.points({ id: entry, type: "string", start: await this.number(entry + 16), end: await this.number(entry + 24), token: "" }, this.storage)) {
+      keyPoints.push(...points);
+      text += String.fromCodePoint(...points);
+    }
+    return { node, position: entry, key: text, keyPoints };
+  }
+  async close() {
+    const results = await Promise.allSettled([this.storage.close(), this.payload.close()]);
+    for (const result of results) if (result.status === "rejected") throw result.reason;
+  }
+};
+
+// packages/safe-bash-command-llm/src/import-json-document.ts
+var EmptyJsonDocumentError = class extends Error {
+  constructor() {
+    super("JSON document is empty");
+  }
+};
+async function withEmbeddingJsonDocument(options, input, operation) {
+  const { signal } = options, store = new JsonDocumentStore(options);
+  try {
+    let root = 0, parent = 0, stringNode = 0;
+    const budget = new Budget(resolveJqLimits({ maxInputBytes: Infinity, maxValueBytes: Infinity, maxCollectionSize: Infinity, maxSteps: Infinity }), signal);
+    for await (const event of jsonValues(input, budget, { stream: true, stringChunks: { maxControlBytes: 65536, containers: true, codePoints: true }, profile: "python39" })) {
+      signal.throwIfAborted();
+      if (!Array.isArray(event) || !Array.isArray(event[0])) throw new Error("Invalid JSON parser event");
+      const path = event[0], value = event[1], kind = event[2], metadata = event[3];
+      const insert = async (type, token = "") => {
+        const node = await store.insert(type, parent, Number(path.at(-1)), metadata.key, token);
+        if (!parent) root = node;
+        return node;
+      };
+      if (kind === "open") parent = await insert(value === "{" ? "object" : "array");
+      else if (kind === "close") parent = await store.parent(parent);
+      else if (typeof kind === "boolean") {
+        if (typeof value !== "string") throw new Error("Invalid JSON string event");
+        stringNode ||= await insert("string");
+        if (!metadata.points) throw new Error("Missing JSON code points");
+        await store.appendPoints(metadata.points);
+        if (kind) {
+          await store.endString(stringNode);
+          stringNode = 0;
+        }
+      } else if (kind === null) {
+        if (value instanceof Decimal) await insert("number", value.text);
+        else if (typeof value === "number") await insert("number", String(value));
+        else if (value === null) await insert("null");
+        else if (typeof value === "boolean") await insert("boolean", String(value));
+      }
+    }
+    if (!root) throw new EmptyJsonDocumentError();
+    return await operation({ root: await store.node(root), child: store.child.bind(store), points: store.points.bind(store), async *text(node) {
+      for await (const points of store.points(node)) yield String.fromCodePoint(...points);
+    } });
+  } finally {
+    await store.close();
+  }
+}
+
+// packages/safe-bash-command-llm/src/indent-text.ts
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+async function* decodeLlmText(source, signal) {
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  let steps = 0;
+  for await (const bytes of source) {
+    if (++steps % 256 === 0) await yieldTurn2(signal);
+    signal.throwIfAborted();
+    for (let offset = 0; offset < bytes.length; offset += 2048) {
+      if (++steps % 256 === 0) await yieldTurn2(signal);
+      signal.throwIfAborted();
+      yield decoder.decode(bytes.subarray(offset, offset + 2048), { stream: true });
+    }
+  }
+  yield decoder.decode();
+}
+async function* indentLlmText(source, signal) {
+  const replay = decodeLlmText(source, signal)[Symbol.asyncIterator]();
+  let pending = "", offset = 0;
+  async function* line(length2, nonblank2) {
+    if (nonblank2) yield "  ";
+    while (length2) {
+      if (offset === pending.length) {
+        const next = await replay.next();
+        if (next.done) throw new Error("Stored content changed");
+        pending = next.value;
+        offset = 0;
+        if (!pending.length) continue;
+      }
+      const count = Math.min(length2, pending.length - offset);
+      yield pending.slice(offset, offset + count);
+      offset += count;
+      length2 -= count;
+    }
+  }
+  let length = 0, nonblank = false;
+  try {
+    for await (const chunk of decodeLlmText(source, signal)) for (const char of chunk) {
+      length += char.length;
+      if (!isPythonWhitespace(char)) nonblank = true;
+      if (["\n", "\r", "\v", "\f", "", "", "", "\x85", "\u2028", "\u2029"].includes(char)) {
+        yield* line(length, nonblank);
+        length = 0;
+        nonblank = false;
+      }
+    }
+    if (length) yield* line(length, nonblank);
+  } finally {
+    await replay.return?.();
+  }
+}
+
+export {
+  EmptyJsonDocumentError,
+  withEmbeddingJsonDocument,
+  decodeLlmText,
+  indentLlmText
+};

package/dist/safe-bash/command-chunks/{chunk-E3BL7W5C.js → chunk-IAHYG67O.js}

@@ -1,42 +1,55 @@
 import {
-  tokenInteger
-} from "./chunk-GDH7OVYK.js";
-import {
+  OpenAiToolCalls,
+  jsonString,
   openAiChat,
+  openAiToolCallsJson,
+  openAiTools,
   openAiUsage
-} from "./chunk-WKUV62RJ.js";
+} from "./chunk-CJIFJ45R.js";
+import {
+  openAiBytes,
+  openAiError,
+  openAiJson,
+  openAiRecord,
+  openAiResponse
+} from "./chunk-UN2RIRCD.js";
 import {
   credential,
   jsonBody,
   multipart,
   providerLimits
-} from "./chunk-4SISSPIH.js";
+} from "./chunk-HLRLMFMS.js";
 import {
   attachmentBytesId,
   attachmentDigestHex,
   getLlmAttachmentUrlId
-} from "./chunk-2ZWRW6UQ.js";
+} from "./chunk-B74LVFAN.js";
+import {
+  tokenInteger
+} from "./chunk-GDH7OVYK.js";
+import {
+  base64Stream
+} from "./chunk-GQV5RWMN.js";
 import {
   jsonDictionaryKeys,
   parseLlmNumericOption,
-  requestAttachments,
+  requestAttachments
+} from "./chunk-CKQ5SXOO.js";
+import {
   validateAttachmentUrl
-} from "./chunk-OTEHQQU7.js";
+} from "./chunk-B6NAEWHC.js";
+import {
+  referenceJson
+} from "./chunk-E47FFS5M.js";
 import {
-  base64Stream,
-  jsonValue,
   sourceBytes
-} from "./chunk-UVZJAV2S.js";
+} from "./chunk-QX3WKBLI.js";
+import {
+  jsonValue
+} from "./chunk-GNPPPYDF.js";
 import {
   acceptsMimeType
 } from "./chunk-VMA3NJXU.js";
-import {
-  openAiBytes,
-  openAiError,
-  openAiJson,
-  openAiRecord,
-  openAiResponse
-} from "./chunk-UN2RIRCD.js";
 
 // packages/safe-bash-command-llm/src/openai-attachment.ts
 function openAiAttachmentKind(mimeType) {
@@ -47,26 +60,6 @@ function openAiAttachmentKind(mimeType) {
   throw new TypeError(`Unsupported OpenAI attachment type: ${mimeType}`);
 }
 
-// packages/safe-bash-command-llm/src/json-string.ts
-async function* jsonString(source, signal) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  signal.throwIfAborted();
-  yield encoder.encode('"');
-  for await (const input of sourceBytes(source, signal)) {
-    signal.throwIfAborted();
-    for (let position = 0; position < input.byteLength; position += 2048) {
-      signal.throwIfAborted();
-      const text = decoder.decode(input.subarray(position, position + 2048), { stream: true });
-      if (text) yield encoder.encode(JSON.stringify(text).slice(1, -1));
-    }
-  }
-  signal.throwIfAborted();
-  const final = decoder.decode();
-  if (final) yield encoder.encode(JSON.stringify(final).slice(1, -1));
-  yield encoder.encode('"');
-}
-
 // packages/safe-bash-command-llm/src/embedding-json.ts
 async function* embeddingJson(request, options, limit) {
   const encoder = new TextEncoder();
@@ -99,6 +92,9 @@ async function* embeddingJson(request, options, limit) {
   }
 }
 
+// packages/safe-bash-command-llm/src/chat-json.ts
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+
 // packages/safe-bash-command-llm/src/pdf-json.ts
 import { sha256 } from "../../safe-bash-checksum-engine/sha256.js";
 import { yieldTurn } from "../../safe-bash-contracts/yield.js";
@@ -135,14 +131,14 @@ async function* pdfJson(source, id, signal) {
 function chatJson(request, limit) {
   request.signal.throwIfAborted();
   if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid provider request byte limit");
-  for (const field of ["model", "messages", "stream", "stream_options"]) if (Object.hasOwn(request.options, field)) throw new TypeError(`${field} is controlled by the provider`);
+  for (const field of ["model", "messages", "stream", "stream_options", "tools"]) if (Object.hasOwn(request.options, field)) throw new TypeError(`${field} is controlled by the provider`);
   if (request.schema && Object.hasOwn(request.options, "response_format")) throw new TypeError("schema conflicts with response_format");
   for (const attachment of requestAttachments(request)) {
     const kind = openAiAttachmentKind(attachment.mimeType);
     if (attachment.id !== void 0 && typeof attachment.id !== "string") throw new TypeError("Invalid attachment id");
     if (attachment.url !== void 0 && kind !== "image") throw new TypeError("Non-image URL attachments require an input source");
   }
-  const controls = jsonValue({ ...request.options, ...request.stream !== false ? { stream_options: { include_usage: true } } : {}, ...request.schema ? { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } } : {}, model: request.model }, request.signal);
+  const controls = jsonValue({ ...request.options, ...openAiTools(request.tools), ...request.stream !== false ? { stream_options: { include_usage: true } } : {}, ...request.schema ? { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } } : {}, model: request.model }, request.signal);
   const encoder = new TextEncoder();
   async function* body() {
     const text = (value) => encoder.encode(value);
@@ -153,37 +149,92 @@ function chatJson(request, limit) {
     }
     yield text(',"messages":[');
     let first = true;
-    for (const message of [...request.system === void 0 ? [] : [{ role: "system", content: request.system, attachments: [] }], ...request.messages ?? [], { role: "user", content: request.prompt, attachments: request.attachments }]) {
+    const current = { role: "user", content: request.prompt, attachments: request.attachments };
+    const messages = [...request.system === void 0 ? [] : [{ role: "system", content: request.system, attachments: [] }], ...request.messages ?? [], current];
+    const toolContinuation = request.messages?.some((message) => message.role === "tool");
+    for (const message of messages) {
       request.signal.throwIfAborted();
-      yield text((first ? "" : ",") + '{"role":' + JSON.stringify(message.role) + ',"content":');
-      first = false;
       const attachments = message.attachments ?? [];
-      if (attachments.length) yield text('[{"type":"text","text":');
-      yield* jsonString(message.content.bytes, request.signal);
-      if (attachments.length) {
-        yield text("}");
-        for (const attachment of attachments) {
-          request.signal.throwIfAborted();
-          const kind = openAiAttachmentKind(attachment.mimeType);
-          if (kind === "pdf" && attachment.source !== void 0) {
-            yield text(",");
-            yield* pdfJson(attachment.source, attachment.id, request.signal);
-            continue;
+      const reader = sourceBytes(message.content.bytes, request.signal)[Symbol.asyncIterator]();
+      let ended = false, failed = false;
+      try {
+        let head = await reader.next();
+        let emptyChunks = 0;
+        while (!head.done && !head.value.length) {
+          if (++emptyChunks % 256 === 0) await yieldTurn2(request.signal);
+          head = await reader.next();
+        }
+        ended = head.done === true;
+        if (ended && message === current && toolContinuation && !attachments.length) continue;
+        yield text((first ? "" : ",") + '{"role":' + JSON.stringify(message.role));
+        first = false;
+        const textPart = !ended;
+        const hasContent = !ended || !message.toolCalls?.length || attachments.length;
+        if (hasContent) {
+          yield text(',"content":');
+          if (attachments.length) {
+            yield text("[");
+            if (textPart) yield text('{"type":"text","text":');
           }
-          if (attachment.url !== void 0) {
-            validateAttachmentUrl(attachment.url);
-            yield text(',{"type":"image_url","image_url":{"url":');
-            yield* jsonValue(attachment.url, request.signal);
-            yield text("}}");
-            continue;
+          const content = async function* () {
+            if (!head.done) yield head.value;
+            while (!ended) {
+              const next = await reader.next();
+              if (next.done) {
+                ended = true;
+                break;
+              }
+              yield next.value;
+            }
+          };
+          if (!attachments.length || textPart) yield* jsonString(content(), request.signal);
+        }
+        if (attachments.length) {
+          if (textPart) yield text("}");
+          let firstPart = !textPart;
+          for (const attachment of attachments) {
+            request.signal.throwIfAborted();
+            if (!firstPart) yield text(",");
+            firstPart = false;
+            const kind = openAiAttachmentKind(attachment.mimeType);
+            if (kind === "pdf" && attachment.source !== void 0) {
+              yield* pdfJson(attachment.source, attachment.id, request.signal);
+              continue;
+            }
+            if (attachment.url !== void 0) {
+              validateAttachmentUrl(attachment.url);
+              yield text('{"type":"image_url","image_url":{"url":');
+              yield* jsonValue(attachment.url, request.signal);
+              yield text("}}");
+              continue;
+            }
+            yield text(kind === "image" ? '{"type":"image_url","image_url":{"url":' + JSON.stringify(`data:${attachment.mimeType};base64,`).slice(0, -1) : '{"type":"input_audio","input_audio":{"data":"');
+            for await (const part of base64Stream(attachment.source.bytes, request.signal)) yield text(part);
+            yield text(kind === "image" ? '"}}' : `","format":"${kind}"}}`);
           }
-          yield text(kind === "image" ? ',{"type":"image_url","image_url":{"url":' + JSON.stringify(`data:${attachment.mimeType};base64,`).slice(0, -1) : ',{"type":"input_audio","input_audio":{"data":"');
-          for await (const part of base64Stream(attachment.source.bytes, request.signal)) yield text(part);
-          yield text(kind === "image" ? '"}}' : `","format":"${kind}"}}`);
+          yield text("]");
+        }
+        if (message.toolCallId !== void 0) {
+          yield text(',"tool_call_id":');
+          yield* jsonValue(message.toolCallId, request.signal);
+        }
+        if (message.toolCalls?.length) {
+          yield text(',"tool_calls":');
+          yield* openAiToolCallsJson(message.toolCalls, request.signal);
+        }
+        yield text("}");
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        if (!ended) {
+          const closing = Promise.resolve().then(() => reader.return?.());
+          if (request.signal.aborted) void closing.catch(() => void 0);
+          else await closing.catch((error) => {
+            if (!failed) throw error;
+          });
         }
-        yield text("]");
       }
-      yield text("}");
     }
     request.signal.throwIfAborted();
     yield text(`],"stream":${request.stream !== false}}`);
@@ -337,7 +388,7 @@ function job(value, expectedId) {
   }
   return { id: value.id, status: value.status };
 }
-function openAiChatJsonResult(value, signal) {
+function openAiChatJsonResult(value, signal, toolLimit) {
   signal.throwIfAborted();
   if (value.error != null) throw new Error(`OpenAI: ${openAiError(value.error) ?? "chat completion failed"}`);
   if (!Array.isArray(value.choices) || value.choices.length === 0) throw new Error("OpenAI chat response has no choices");
@@ -349,7 +400,11 @@ function openAiChatJsonResult(value, signal) {
   if (typeof value.id === "string") metadata.id = value.id;
   if (typeof value.model === "string") metadata.model = value.model;
   if (typeof first.finish_reason === "string") metadata.finish_reason = first.finish_reason;
+  const calls = new OpenAiToolCalls(toolLimit);
+  calls.add(first.message.tool_calls, false);
+  const toolCalls = calls.finish();
   const details = {
+    ...toolCalls ? { toolCalls } : {},
     ...openAiRecord(value.usage) ? { usage: openAiUsage(value.usage) } : {},
     ...Object.keys(metadata).length ? { metadata } : {}
   };
@@ -368,6 +423,7 @@ function createOpenAiProvider(options) {
   const baseUrl = base.href.endsWith("/") ? base.href.slice(0, -1) : base.href;
   const configured = options.models.map((model) => Object.freeze({
     ...model,
+    ...model.endpoint === "chat" && model.asyncModel === void 0 ? { asyncModel: {} } : {},
     inputSources: model.endpoint === "chat",
     attachmentUrls: model.endpoint === "chat",
     capabilities: Object.freeze(model.capabilities ?? (model.endpoint === "chat" ? ["messages"] : model.endpoint === "embeddings" ? ["embed"] : [])),
@@ -423,8 +479,10 @@ function createOpenAiProvider(options) {
     embedSources: embed,
     async *completeSources(request) {
       request.signal.throwIfAborted();
-      const model = byId.get(request.model);
+      const registered = byId.get(request.model);
+      const model = registered && request.async && registered.asyncModel ? { ...registered, ...registered.asyncModel } : registered;
       if (!model || model.endpoint !== "chat") throw new Error(`Model ${request.model} does not support streamed inputs`);
+      if ((request.tools?.length || request.messages?.some((message) => message.role === "tool" || message.toolCalls?.length)) && !model.capabilities?.includes("tools")) throw new Error(`Model ${model.id} does not support tools`);
       const body = chatJson({ ...request, options: openAiChatOptions(jsonOptions(request.options, "chat")) }, limits.maxRequestBytes);
       let details;
       for await (const response of openAiResponse(transport, {
@@ -435,18 +493,19 @@ function createOpenAiProvider(options) {
         body
       }, limits.maxResponseBytes)) {
         if (request.stream === false) {
-          const parsed = openAiChatJsonResult(await openAiJson(response, request.signal, limits.maxResponseBytes), request.signal);
+          const parsed = openAiChatJsonResult(await openAiJson(response, request.signal, limits.maxResponseBytes), request.signal, limits.maxToolCallBytes);
           if (parsed.content !== void 0) yield parsed.content;
           details = parsed.details;
         } else {
-          details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes);
+          details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes, limits.maxToolCallBytes);
         }
       }
       return details;
     },
     async *complete(request) {
       request.signal.throwIfAborted();
-      const model = byId.get(request.model);
+      const registered = byId.get(request.model);
+      const model = registered && request.async && registered.asyncModel ? { ...registered, ...registered.asyncModel } : registered;
       if (!model) throw new Error(`Unknown model: ${request.model}`);
       if (model.endpoint === "embeddings") throw new TypeError("Embedding models require embed()");
       if (model.endpoint !== "chat" && (request.messages?.length || request.schema !== void 0)) throw new TypeError("Messages and schemas require a chat model");
@@ -462,10 +521,11 @@ function createOpenAiProvider(options) {
         } else attachmentBytes += attachment.bytes.byteLength;
         if (attachmentBytes > limits.maxRequestBytes) throw new RangeError("Provider request byte limit exceeded");
       }
+      if ((request.tools?.length || request.messages?.some((message) => message.role === "tool" || message.toolCalls?.length)) && (model.endpoint !== "chat" || !model.capabilities?.includes("tools"))) throw new Error(`Model ${model.id} does not support tools`);
       if (model.endpoint === "videos" && request.attachments.length > 1) throw new Error("OpenAI videos accepts only one input_reference image");
       if (model.endpoint !== "chat" && request.system !== void 0) throw new TypeError("System prompts are supported only by chat models");
       if (request.schema !== void 0 && request.options.response_format !== void 0) throw new TypeError("OpenAI option response_format conflicts with request schema");
-      const reserved = model.endpoint === "chat" ? ["model", "messages", "stream", "stream_options"] : model.endpoint === "images" ? ["model", "prompt", "image", "image[]"] : ["model", "prompt", "input_reference"];
+      const reserved = model.endpoint === "chat" ? ["model", "messages", "stream", "stream_options", "tools"] : model.endpoint === "images" ? ["model", "prompt", "image", "image[]"] : ["model", "prompt", "input_reference"];
       for (const key of Object.keys(request.options)) {
         if (reserved.includes(key)) throw new Error(`OpenAI option ${key} is controlled by the provider`);
       }
@@ -479,7 +539,9 @@ function createOpenAiProvider(options) {
       if (model.endpoint === "chat") {
         const messages = [];
         if (request.system !== void 0) messages.push({ role: "system", content: request.system });
-        for (const message of [...request.messages ?? [], { role: "user", content: request.prompt, attachments: request.attachments }]) {
+        const toolContinuation = request.messages?.some((message) => message.role === "tool");
+        const current = { role: "user", content: request.prompt, attachments: request.attachments };
+        for (const message of [...request.messages ?? [], ...toolContinuation && !request.prompt && !request.attachments.length ? [] : [current]]) {
           const attachments = message.attachments ?? [];
           const parts = [];
           for (const attachment of attachments) {
@@ -489,20 +551,31 @@ function createOpenAiProvider(options) {
               parts.push({ type: "file", file: { filename: `${id}.pdf`, file_data: `data:application/pdf;base64,${base64(attachment.bytes)}` } });
             } else parts.push(kind === "image" ? { type: "image_url", image_url: { url: attachment.url ?? `data:${attachment.mimeType};base64,${base64(attachment.bytes)}` } } : { type: "input_audio", input_audio: { data: base64(attachment.bytes), format: kind } });
           }
-          messages.push({ role: message.role, content: attachments.length === 0 ? message.content : [
-            { type: "text", text: message.content },
-            ...parts
-          ] });
+          const toolCalls = [];
+          for (const call of message.toolCalls ?? []) {
+            let argumentsText = "";
+            for await (const bytes of referenceJson(call.arguments, request.signal)) argumentsText += new TextDecoder().decode(bytes);
+            toolCalls.push({ type: "function", id: call.id ?? null, function: { name: call.name, arguments: argumentsText } });
+          }
+          messages.push({
+            role: message.role,
+            ...message.toolCallId === void 0 ? {} : { tool_call_id: message.toolCallId },
+            ...toolCalls.length ? { tool_calls: toolCalls } : {},
+            ...toolCalls.length && !message.content && !attachments.length ? {} : { content: attachments.length === 0 ? message.content : [
+              ...message.content ? [{ type: "text", text: message.content }] : [],
+              ...parts
+            ] }
+          });
         }
         let details;
         const stream = request.stream !== false;
-        for await (const response of send("/chat/completions", "POST", jsonBody({ ...openAiChatOptions(jsonOptions(request.options, "chat")), ...request.schema === void 0 ? {} : { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } }, model: request.model, messages, stream, ...stream ? { stream_options: { include_usage: true } } : {} }, limits.maxRequestBytes))) {
+        for await (const response of send("/chat/completions", "POST", jsonBody({ ...openAiTools(request.tools), ...openAiChatOptions(jsonOptions(request.options, "chat")), ...request.schema === void 0 ? {} : { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } }, model: request.model, messages, stream, ...stream ? { stream_options: { include_usage: true } } : {} }, limits.maxRequestBytes))) {
           if (!stream) {
-            const parsed = openAiChatJsonResult(await openAiJson(response, request.signal, limits.maxResponseBytes), request.signal);
+            const parsed = openAiChatJsonResult(await openAiJson(response, request.signal, limits.maxResponseBytes), request.signal, limits.maxToolCallBytes);
             if (parsed.content !== void 0) yield parsed.content;
             details = parsed.details;
           } else {
-            details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes);
+            details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes, limits.maxToolCallBytes);
           }
         }
         return details;
@@ -568,7 +641,6 @@ function createOpenAiProvider(options) {
 }
 
 export {
-  jsonString,
   chatJson,
   openAiChatOptions,
   createOpenAiProvider