@bastani/pi-ai 0.9.43 → 0.9.44-alpha.2

package/dist/utils/error-body.js.map

@@ -1 +1 @@
-{"version":3,"file":"error-body.js","sourceRoot":"","sources":["../../src/utils/error-body.ts"],"names":[],"mappings":"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","sourcesContent":["// Shared normalization for provider HTTP error objects.\n//\n// Endpoints behind a proxy / gateway may return a non-2xx response whose body\n// the provider SDK cannot fold into `error.message`. The SDK error object still\n// carries the HTTP status and the raw/parsed body, but under SDK-specific field\n// names. Provider catch blocks that read only `error.message` therefore drop\n// the body and surface opaque messages like `\"403 status code (no body)\"` or\n// collapse to `\"Unknown: UnknownError\"`.\n//\n// `normalizeProviderError` probes the known SDK field shapes (Mistral,\n// `openai`, `@google/genai`, AWS Bedrock) and returns a struct each provider\n// composes into its display string. The `messageCarriesBody` flag captures the\n// Anthropic / `@google/genai` happy path where the SDK already folded the body\n// into the message, so providers can preserve it without double-printing.\n\nexport const MAX_PROVIDER_ERROR_BODY_CHARS = 4000;\n\nexport interface NormalizedProviderError {\n\t/** HTTP status code, when one could be extracted from the SDK error object. */\n\tstatus?: number;\n\t/** Raw HTTP body reason, already trimmed and truncated to the cap. */\n\tbody?: string;\n\t/** `error.message`, or `safeJsonStringify(error)` for a non-`Error` throw. */\n\tmessage: string;\n\t/** True when `message` already contains the body (no separate body to add). */\n\tmessageCarriesBody: boolean;\n}\n\ntype SdkErrorShape = Error & {\n\tstatusCode?: unknown;\n\tstatus?: unknown;\n\tbody?: unknown;\n\terror?: unknown;\n\t$metadata?: { httpStatusCode?: unknown };\n\t$response?: { statusCode?: unknown; body?: unknown };\n};\n\nexport function normalizeProviderError(error: unknown): NormalizedProviderError {\n\tif (!(error instanceof Error)) {\n\t\treturn { message: safeJsonStringify(error), messageCarriesBody: false };\n\t}\n\n\tconst sdkError = error as SdkErrorShape;\n\tconst status = extractStatus(sdkError);\n\tconst body = extractBody(sdkError);\n\tconst messageCarriesBody = body === undefined || error.message.includes(body);\n\n\treturn {\n\t\tstatus,\n\t\tbody,\n\t\tmessage: error.message,\n\t\tmessageCarriesBody,\n\t} satisfies NormalizedProviderError;\n}\n\n/**\n * Probe the HTTP status, first numeric hit wins, in SDK-field order:\n * `statusCode` (Mistral) → `status` (`openai`, `@google/genai`) →\n * `$metadata.httpStatusCode` (Bedrock) → `$response.statusCode` (Bedrock).\n */\nfunction extractStatus(error: SdkErrorShape): number | undefined {\n\tif (typeof error.statusCode === \"number\") return error.statusCode;\n\tif (typeof error.status === \"number\") return error.status;\n\tif (typeof error.$metadata?.httpStatusCode === \"number\") return error.$metadata.httpStatusCode;\n\tif (typeof error.$response?.statusCode === \"number\") return error.$response.statusCode;\n\treturn undefined;\n}\n\n/**\n * Probe the raw body reason, first usable hit wins, in SDK-field order:\n * `body` string (Mistral) → `error` parsed JSON body object (`openai` SDK's\n * `this.error`) → `$response.body` (Bedrock). Empty objects and unread response\n * streams are treated as no body so they do not surface as `\"{}\"` or serialized\n * stream internals. The chosen body is truncated to the cap.\n */\nfunction extractBody(error: SdkErrorShape): string | undefined {\n\tconst bodyText = pickBodyText(error);\n\tif (bodyText === undefined) return undefined;\n\tconst trimmed = bodyText.trim();\n\tif (trimmed.length === 0) return undefined;\n\treturn truncateErrorText(trimmed, MAX_PROVIDER_ERROR_BODY_CHARS);\n}\n\nfunction pickBodyText(error: SdkErrorShape): string | undefined {\n\tif (typeof error.body === \"string\") return error.body;\n\tif (isPlainNonEmptyObject(error.error)) return safeJsonStringify(error.error);\n\tconst responseBody = error.$response?.body;\n\tif (typeof responseBody === \"string\") return responseBody;\n\tif (isReadableStreamLike(responseBody)) return undefined;\n\tif (isPlainNonEmptyObject(responseBody)) return safeJsonStringify(responseBody);\n\treturn undefined;\n}\n\nfunction isReadableStreamLike(value: unknown): boolean {\n\treturn typeof value === \"object\" && value !== null && \"pipe\" in value && typeof value.pipe === \"function\";\n}\n\n/**\n * Only a PLAIN object counts as an HTTP body. SDK error fields can hold class\n * instances instead of parsed bodies — AWS SDK v3's `$response.body` is an\n * HTTP stream/response wrapper object, and stringifying one produced garbage\n * like `{\"_events\":...}` as the \"body\", which then REPLACED `error.message`\n * in the composed display string. `error.message` is where the SDK puts the\n * real deserialized exception text (\"Input is too long...\", schema validation\n * details, ...), so the one useful string was discarded for noise. A class\n * instance yields no body, `messageCarriesBody` stays true, and the real\n * message survives. Complements the `pipe` sniffing above: web\n * ReadableStreams (pipeTo/pipeThrough, no `pipe`) and non-stream SDK wrapper\n * classes fail the prototype check, while parsed JSON bodies (plain objects\n * by construction) still pass.\n */\nfunction isPlainNonEmptyObject(value: unknown): boolean {\n\tif (typeof value !== \"object\" || value === null) return false;\n\tconst proto = Object.getPrototypeOf(value);\n\tif (proto !== Object.prototype && proto !== null) return false;\n\treturn Object.keys(value).length > 0;\n}\n\n/**\n * Compose a display string from a normalized error. When the message already\n * carries the body (Anthropic / `@google/genai` happy path) or no body/status\n * was extracted, the message is returned unchanged. Otherwise the status and\n * body are surfaced, with an optional provider prefix.\n *\n * - no prefix: `\"<status>: <body>\"`\n * - prefix:    `\"<prefix> (<status>): <body>\"`\n */\nexport function formatProviderError(norm: NormalizedProviderError, prefix?: string): string {\n\tif (norm.messageCarriesBody || norm.status === undefined || norm.body === undefined) {\n\t\treturn prefix !== undefined && norm.status !== undefined\n\t\t\t? `${prefix} (${norm.status}): ${norm.message}`\n\t\t\t: norm.message;\n\t}\n\treturn prefix !== undefined ? `${prefix} (${norm.status}): ${norm.body}` : `${norm.status}: ${norm.body}`;\n}\n\nexport function truncateErrorText(text: string, maxChars: number): string {\n\tif (text.length <= maxChars) return text;\n\treturn `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;\n}\n\nexport function safeJsonStringify(value: unknown): string {\n\ttry {\n\t\tconst serialized = JSON.stringify(value);\n\t\treturn serialized === undefined ? String(value) : serialized;\n\t} catch {\n\t\treturn String(value);\n\t}\n}\n"]}
+{"version":3,"file":"error-body.js","sourceRoot":"","sources":["../../src/utils/error-body.ts"],"names":[],"mappings":"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","sourcesContent":["// Shared normalization for provider HTTP error objects.\n//\n// Endpoints behind a proxy / gateway may return a non-2xx response whose body\n// the provider SDK cannot fold into `error.message`. The SDK error object still\n// carries the HTTP status and the raw/parsed body, but under SDK-specific field\n// names. Provider catch blocks that read only `error.message` therefore drop\n// the body and surface opaque messages like `\"403 status code (no body)\"` or\n// collapse to `\"Unknown: UnknownError\"`.\n//\n// `normalizeProviderError` probes the known SDK field shapes (Mistral,\n// `openai`, `@google/genai`, AWS Bedrock) and returns a struct each provider\n// composes into its display string. The `messageCarriesBody` flag captures the\n// Anthropic / `@google/genai` happy path where the SDK already folded the body\n// into the message, so providers can preserve it without double-printing.\n\nimport { ownedSlice } from \"./text.ts\";\n\nexport const MAX_PROVIDER_ERROR_BODY_CHARS = 4000;\n\nexport interface NormalizedProviderError {\n\t/** HTTP status code, when one could be extracted from the SDK error object. */\n\tstatus?: number;\n\t/** Raw HTTP body reason, already trimmed and truncated to the cap. */\n\tbody?: string;\n\t/** `error.message`, or `safeJsonStringify(error)` for a non-`Error` throw. */\n\tmessage: string;\n\t/** True when `message` already contains the body (no separate body to add). */\n\tmessageCarriesBody: boolean;\n}\n\ntype SdkErrorShape = Error & {\n\tstatusCode?: unknown;\n\tstatus?: unknown;\n\tbody?: unknown;\n\terror?: unknown;\n\t$metadata?: { httpStatusCode?: unknown };\n\t$response?: { statusCode?: unknown; body?: unknown };\n};\n\nexport function normalizeProviderError(error: unknown): NormalizedProviderError {\n\tif (!(error instanceof Error)) {\n\t\treturn { message: safeJsonStringify(error), messageCarriesBody: false };\n\t}\n\n\tconst sdkError = error as SdkErrorShape;\n\tconst status = extractStatus(sdkError);\n\tconst body = extractBody(sdkError);\n\tconst messageCarriesBody = body === undefined || error.message.includes(body);\n\n\treturn {\n\t\tstatus,\n\t\tbody,\n\t\tmessage: error.message,\n\t\tmessageCarriesBody,\n\t} satisfies NormalizedProviderError;\n}\n\n/**\n * Probe the HTTP status, first numeric hit wins, in SDK-field order:\n * `statusCode` (Mistral) → `status` (`openai`, `@google/genai`) →\n * `$metadata.httpStatusCode` (Bedrock) → `$response.statusCode` (Bedrock).\n */\nfunction extractStatus(error: SdkErrorShape): number | undefined {\n\tif (typeof error.statusCode === \"number\") return error.statusCode;\n\tif (typeof error.status === \"number\") return error.status;\n\tif (typeof error.$metadata?.httpStatusCode === \"number\") return error.$metadata.httpStatusCode;\n\tif (typeof error.$response?.statusCode === \"number\") return error.$response.statusCode;\n\treturn undefined;\n}\n\n/**\n * Probe the raw body reason, first usable hit wins, in SDK-field order:\n * `body` string (Mistral) → `error` parsed JSON body object (`openai` SDK's\n * `this.error`) → `$response.body` (Bedrock). Empty objects and unread response\n * streams are treated as no body so they do not surface as `\"{}\"` or serialized\n * stream internals. The chosen body is truncated to the cap.\n */\nfunction extractBody(error: SdkErrorShape): string | undefined {\n\tconst bodyText = pickBodyText(error);\n\tif (bodyText === undefined) return undefined;\n\tconst trimmed = bodyText.trim();\n\tif (trimmed.length === 0) return undefined;\n\treturn truncateErrorText(trimmed, MAX_PROVIDER_ERROR_BODY_CHARS);\n}\n\nfunction pickBodyText(error: SdkErrorShape): string | undefined {\n\tif (typeof error.body === \"string\") return error.body;\n\tif (isPlainNonEmptyObject(error.error)) return safeJsonStringify(error.error);\n\tconst responseBody = error.$response?.body;\n\tif (typeof responseBody === \"string\") return responseBody;\n\tif (isReadableStreamLike(responseBody)) return undefined;\n\tif (isPlainNonEmptyObject(responseBody)) return safeJsonStringify(responseBody);\n\treturn undefined;\n}\n\nfunction isReadableStreamLike(value: unknown): boolean {\n\treturn typeof value === \"object\" && value !== null && \"pipe\" in value && typeof value.pipe === \"function\";\n}\n\n/**\n * Only a PLAIN object counts as an HTTP body. SDK error fields can hold class\n * instances instead of parsed bodies — AWS SDK v3's `$response.body` is an\n * HTTP stream/response wrapper object, and stringifying one produced garbage\n * like `{\"_events\":...}` as the \"body\", which then REPLACED `error.message`\n * in the composed display string. `error.message` is where the SDK puts the\n * real deserialized exception text (\"Input is too long...\", schema validation\n * details, ...), so the one useful string was discarded for noise. A class\n * instance yields no body, `messageCarriesBody` stays true, and the real\n * message survives. Complements the `pipe` sniffing above: web\n * ReadableStreams (pipeTo/pipeThrough, no `pipe`) and non-stream SDK wrapper\n * classes fail the prototype check, while parsed JSON bodies (plain objects\n * by construction) still pass.\n */\nfunction isPlainNonEmptyObject(value: unknown): boolean {\n\tif (typeof value !== \"object\" || value === null) return false;\n\tconst proto = Object.getPrototypeOf(value);\n\tif (proto !== Object.prototype && proto !== null) return false;\n\treturn Object.keys(value).length > 0;\n}\n\n/**\n * Compose a display string from a normalized error. When the message already\n * carries the body (Anthropic / `@google/genai` happy path) or no body/status\n * was extracted, the message is returned unchanged. Otherwise the status and\n * body are surfaced, with an optional provider prefix.\n *\n * - no prefix: `\"<status>: <body>\"`\n * - prefix:    `\"<prefix> (<status>): <body>\"`\n */\nexport function formatProviderError(norm: NormalizedProviderError, prefix?: string): string {\n\tif (norm.messageCarriesBody || norm.status === undefined || norm.body === undefined) {\n\t\treturn prefix !== undefined && norm.status !== undefined\n\t\t\t? `${prefix} (${norm.status}): ${norm.message}`\n\t\t\t: norm.message;\n\t}\n\treturn prefix !== undefined ? `${prefix} (${norm.status}): ${norm.body}` : `${norm.status}: ${norm.body}`;\n}\n\nexport function truncateErrorText(text: string, maxChars: number): string {\n\tif (text.length <= maxChars) return text;\n\treturn `${ownedSlice(text, 0, maxChars)}... [truncated ${text.length - maxChars} chars]`;\n}\n\nexport function safeJsonStringify(value: unknown): string {\n\ttry {\n\t\tconst serialized = JSON.stringify(value);\n\t\treturn serialized === undefined ? String(value) : serialized;\n\t} catch {\n\t\treturn String(value);\n\t}\n}\n"]}

package/dist/utils/streaming-json.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Incremental, tolerant parsing of JSON text that arrives in pieces, such as streamed tool-call arguments.
+ *
+ * `StreamingJsonParser.append()` reads each piece once, so a stream costs time and memory linear in its length, and
+ * `snapshot()` returns the value of the text read so far. Snapshots are plain JSON values and never change once
+ * returned: the parser copies the containers that are still open (the "open path") into every new snapshot and shares
+ * completed containers and strings. The rules for incomplete text follow `parseStreamingJson()`:
+ *
+ * - An unterminated string shows the characters read so far; an unterminated escape is held back until complete.
+ * - An unterminated container shows the members and elements read so far.
+ * - A member whose key or value has not started is omitted.
+ * - An unterminated literal shows its value once it is a prefix of `true`, `false` or `null`; an unterminated number
+ *   shows its value when the digits read so far form a number (an exponent without digits is ignored).
+ *
+ * Malformed text is read leniently, the way `repairJson()` and `parseStreamingJson()` treat it: raw control characters
+ * in strings are kept, an invalid escape such as `\d` stays literal text, missing commas and colons are tolerated,
+ * values in invalid positions and unknown words are dropped, and text after the root value is ignored. The parser never
+ * throws. Callers that need the exact value of the finished text parse it once, e.g. with `parseToolCallArguments()`.
+ *
+ * Differences from `parseStreamingJson()` on incomplete text: trailing whitespace inside an unterminated string is
+ * kept (it was trimmed), a string that contains a raw control character or an invalid escape stays visible while it
+ * streams (it was dropped until the document was complete), and `NaN` and `Infinity` words are dropped.
+ *
+ * `append()` also returns the changes the piece made, for a writer that keeps its own copy of the value and applies
+ * them instead of re-assigning snapshots: `set` when a key, an array item or a finished value appears (a new string is
+ * set once with its first text, a container empty), `append` when the piece extended an open string. Unterminated
+ * numbers and literals are not reported until they end. A container nested more than 32 levels deep is reported as one
+ * `set` of its whole value when it closes, so paths stay short.
+ *
+ * Cost: copying the open path costs its member and element count. Each `append()` earns copy credit proportional to its
+ * length plus a constant; `snapshot()` spends it and returns the previous snapshot while the open path costs more than
+ * the credit. So a document that keeps a very large container open (thousands of elements) shows a preview that lags
+ * a little behind the text, and no input makes the total work grow faster than the text.
+ */
+import type { JsonValue, ToolCall } from "../types.ts";
+/** A path from the root value: member keys and array indices. */
+export type JsonPath = readonly (string | number)[];
+/** One change a piece of text made to the value; see the module comment. */
+export type JsonChange = {
+    readonly kind: "set";
+    readonly path: JsonPath;
+    readonly value: JsonValue;
+} | {
+    readonly kind: "append";
+    readonly path: JsonPath;
+    readonly text: string;
+};
+/** Incremental, tolerant JSON parser; see the module comment for its rules and costs. */
+export declare class StreamingJsonParser {
+    #private;
+    /**
+     * Read the next piece of text; returns the changes it made, in order. Costs time linear in `text.length`.
+     */
+    append(text: string): readonly JsonChange[];
+    /**
+     * The value of the text read so far: `undefined` before a value starts, otherwise a plain JSON value that never
+     * changes afterwards. Returns the previous snapshot while the text read since did not change the value, or while a
+     * fresh copy of the open path is not yet paid for (see the module comment).
+     */
+    snapshot(): JsonValue | undefined;
+}
+/**
+ * The arguments of one streaming tool call: the raw text, for the one full parse when the call ends, and a
+ * `StreamingJsonParser` for the partial arguments in between. Providers keep one per call in their own stream state,
+ * never on the content block, so the raw text never reaches partial messages or transcripts.
+ */
+export declare class ToolCallArgumentsStream {
+    #private;
+    /** The raw argument text received so far. */
+    get text(): string;
+    /** Append a piece of argument text; returns the partial arguments, a new object whenever they changed. */
+    append(delta: string): ToolCall["arguments"];
+    /**
+     * Take the provider's complete argument text. When it continues the text so far, returns the missing piece as
+     * `delta`; otherwise starts over with `text`. Either way returns the partial arguments of `text`.
+     */
+    replace(text: string): {
+        readonly delta: string | undefined;
+        readonly arguments: ToolCall["arguments"];
+    };
+    /** The final arguments: one full parse of the complete text, which reports malformed arguments. */
+    finish(): Pick<ToolCall, "arguments" | "argumentsError">;
+}
+//# sourceMappingURL=streaming-json.d.ts.map

package/dist/utils/streaming-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-json.d.ts","sourceRoot":"","sources":["../../src/utils/streaming-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAWvD,iEAAiE;AACjE,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;AAEpD,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAuD/E,yFAAyF;AACzF,qBAAa,mBAAmB;;IAe/B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAY1C;IAED;;;;OAIG;IACH,QAAQ,IAAI,SAAS,GAAG,SAAS,CAShC;CAkSD;AAED;;;;GAIG;AACH,qBAAa,uBAAuB;;IAMnC,6CAA6C;IAC7C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,0GAA0G;IAC1G,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,CAI3C;IAED;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAA;KAAE,CAQvG;IAED,mGAAmG;IACnG,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,gBAAgB,CAAC,CAEvD;CAaD"}

package/dist/utils/streaming-json.js

@@ -0,0 +1,513 @@
+/**
+ * Incremental, tolerant parsing of JSON text that arrives in pieces, such as streamed tool-call arguments.
+ *
+ * `StreamingJsonParser.append()` reads each piece once, so a stream costs time and memory linear in its length, and
+ * `snapshot()` returns the value of the text read so far. Snapshots are plain JSON values and never change once
+ * returned: the parser copies the containers that are still open (the "open path") into every new snapshot and shares
+ * completed containers and strings. The rules for incomplete text follow `parseStreamingJson()`:
+ *
+ * - An unterminated string shows the characters read so far; an unterminated escape is held back until complete.
+ * - An unterminated container shows the members and elements read so far.
+ * - A member whose key or value has not started is omitted.
+ * - An unterminated literal shows its value once it is a prefix of `true`, `false` or `null`; an unterminated number
+ *   shows its value when the digits read so far form a number (an exponent without digits is ignored).
+ *
+ * Malformed text is read leniently, the way `repairJson()` and `parseStreamingJson()` treat it: raw control characters
+ * in strings are kept, an invalid escape such as `\d` stays literal text, missing commas and colons are tolerated,
+ * values in invalid positions and unknown words are dropped, and text after the root value is ignored. The parser never
+ * throws. Callers that need the exact value of the finished text parse it once, e.g. with `parseToolCallArguments()`.
+ *
+ * Differences from `parseStreamingJson()` on incomplete text: trailing whitespace inside an unterminated string is
+ * kept (it was trimmed), a string that contains a raw control character or an invalid escape stays visible while it
+ * streams (it was dropped until the document was complete), and `NaN` and `Infinity` words are dropped.
+ *
+ * `append()` also returns the changes the piece made, for a writer that keeps its own copy of the value and applies
+ * them instead of re-assigning snapshots: `set` when a key, an array item or a finished value appears (a new string is
+ * set once with its first text, a container empty), `append` when the piece extended an open string. Unterminated
+ * numbers and literals are not reported until they end. A container nested more than 32 levels deep is reported as one
+ * `set` of its whole value when it closes, so paths stay short.
+ *
+ * Cost: copying the open path costs its member and element count. Each `append()` earns copy credit proportional to its
+ * length plus a constant; `snapshot()` spends it and returns the previous snapshot while the open path costs more than
+ * the credit. So a document that keeps a very large container open (thousands of elements) shows a preview that lags
+ * a little behind the text, and no input makes the total work grow faster than the text.
+ */
+import { parseToolCallArguments } from "./json-parse.js";
+// Changes are reported at most this deep, so a path costs O(1) to build.
+const MAX_REPORTED_DEPTH = 32;
+const ROOT_SLOT = { kind: "root" };
+// Copy credit per append and per appended character. The floor keeps small documents fresh at every snapshot.
+const CREDIT_PER_APPEND = 256;
+const CREDIT_PER_CHARACTER = 8;
+// An unterminated number longer than this is not shown until it ends, so `snapshot()` stays cheap.
+const MAX_PENDING_SCALAR_LENGTH = 64;
+const NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+const NUMBER_WITHOUT_EXPONENT_DIGITS = /^(-?(?:0|[1-9]\d*)(?:\.\d+)?)[eE][+-]?$/;
+const LITERALS = [
+    ["true", true],
+    ["false", false],
+    ["null", null],
+];
+const QUOTE = 0x22;
+const BACKSLASH = 0x5c;
+/** Incremental, tolerant JSON parser; see the module comment for its rules and costs. */
+export class StreamingJsonParser {
+    #root = undefined;
+    #done = false;
+    #stack = [];
+    #string = undefined;
+    #scalar = "";
+    #scalarSlot = undefined;
+    /** Sum of `size + 1` over the open path: what a fresh snapshot copies. */
+    #pathCost = 0;
+    #credit = 0;
+    #dirty = false;
+    #snapshot = undefined;
+    /** Changes of the piece being read. */
+    #changes = [];
+    /**
+     * Read the next piece of text; returns the changes it made, in order. Costs time linear in `text.length`.
+     */
+    append(text) {
+        this.#credit += CREDIT_PER_APPEND + CREDIT_PER_CHARACTER * text.length;
+        this.#changes = [];
+        if (this.#string !== undefined)
+            this.#string.change = undefined;
+        let index = 0;
+        while (index < text.length && !this.#done) {
+            const open = this.#string;
+            if (open !== undefined)
+                index = this.#readString(open, text, index);
+            else if (this.#scalar !== "")
+                index = this.#readScalar(text, index);
+            else
+                this.#structural(text[index++]);
+        }
+        return this.#changes;
+    }
+    /**
+     * The value of the text read so far: `undefined` before a value starts, otherwise a plain JSON value that never
+     * changes afterwards. Returns the previous snapshot while the text read since did not change the value, or while a
+     * fresh copy of the open path is not yet paid for (see the module comment).
+     */
+    snapshot() {
+        if (!this.#dirty)
+            return this.#snapshot;
+        const pending = this.#pendingScalar();
+        const cost = this.#pathCost + (pending === undefined ? 0 : 1);
+        if (cost > this.#credit)
+            return this.#snapshot;
+        this.#credit -= cost;
+        this.#dirty = false;
+        this.#snapshot = this.#copyOpenPath(pending);
+        return this.#snapshot;
+    }
+    /** Read string characters from `start` until the string ends or the text does; returns the next index. */
+    #readString(open, text, start) {
+        let runStart = start;
+        for (let index = start; index < text.length; index++) {
+            const code = text.charCodeAt(index);
+            if (open.escape !== "") {
+                if (this.#continueEscape(open, text[index])) {
+                    runStart = index + 1;
+                    continue;
+                }
+                // Not part of the escape: read it as a normal string character below.
+                runStart = index;
+            }
+            if (code === QUOTE) {
+                if (index > runStart)
+                    this.#appendString(open, text.slice(runStart, index));
+                this.#endString(open);
+                return index + 1;
+            }
+            if (code === BACKSLASH) {
+                if (index > runStart)
+                    this.#appendString(open, text.slice(runStart, index));
+                open.escape = "\\";
+                runStart = index + 1;
+            }
+        }
+        if (text.length > runStart)
+            this.#appendString(open, text.slice(runStart));
+        return text.length;
+    }
+    /** Read number or literal characters from `start` up to the next delimiter; returns the delimiter's index. */
+    #readScalar(text, start) {
+        let end = start;
+        while (end < text.length && !isDelimiter(text[end]))
+            end++;
+        if (end > start) {
+            this.#scalar += text.slice(start, end);
+            if (this.#scalarSlot !== undefined)
+                this.#dirty = true;
+        }
+        if (end < text.length)
+            this.#endScalar();
+        return end;
+    }
+    /** Handle one character outside strings. */
+    #structural(char) {
+        switch (char) {
+            case " ":
+            case "\t":
+            case "\n":
+            case "\r":
+                return;
+            case '"':
+                this.#startString();
+                return;
+            case "{":
+            case "[":
+                this.#openContainer(char === "{" ? {} : []);
+                return;
+            case "}":
+            case "]":
+                this.#closeContainer();
+                return;
+            case ":": {
+                const frame = this.#stack.at(-1);
+                if (frame !== undefined && !Array.isArray(frame.container) && frame.phase === "colon")
+                    frame.phase = "value";
+                return;
+            }
+            case ",": {
+                const frame = this.#stack.at(-1);
+                if (frame !== undefined)
+                    frame.phase = Array.isArray(frame.container) ? "value" : "key";
+                return;
+            }
+            default:
+                this.#scalar = char;
+                this.#scalarSlot = this.#valueSlot();
+                if (this.#scalarSlot !== undefined)
+                    this.#dirty = true;
+        }
+    }
+    /** Where a value starting now goes, or `undefined` when this position takes no value. */
+    #valueSlot() {
+        const frame = this.#stack.at(-1);
+        if (frame === undefined)
+            return this.#root === undefined ? ROOT_SLOT : undefined;
+        if (Array.isArray(frame.container))
+            return { kind: "element", index: frame.container.length };
+        // A missing colon is tolerated: `{"a" 1}` reads as `{"a": 1}`.
+        if ((frame.phase === "value" || frame.phase === "colon") && frame.key !== undefined) {
+            return { kind: "member", key: frame.key };
+        }
+        return undefined;
+    }
+    #startString() {
+        const frame = this.#stack.at(-1);
+        // A missing comma is tolerated: `{"a": 1 "b": 2}` reads the second member.
+        if (frame !== undefined &&
+            !Array.isArray(frame.container) &&
+            (frame.phase === "key" || frame.phase === "comma")) {
+            this.#string = { target: "key", slot: undefined, text: "", escape: "", path: undefined, change: undefined };
+            return;
+        }
+        const slot = this.#valueSlot();
+        const path = this.#reportedPath(slot);
+        this.#string = { target: "value", slot, text: "", escape: "", path, change: undefined };
+        this.#place(slot, "");
+        if (path !== undefined)
+            this.#string.change = this.#report({ kind: "set", path, value: "" });
+    }
+    /** The path of a value at `slot` in the innermost open container, when its changes are reported. */
+    #reportedPath(slot) {
+        if (slot === undefined)
+            return undefined;
+        if (slot.kind === "root")
+            return [];
+        const frame = this.#stack.at(-1);
+        if (!frame.reportsInside)
+            return undefined;
+        return [...frame.path, slot.kind === "member" ? slot.key : slot.index];
+    }
+    #report(change) {
+        this.#changes.push(change);
+        return change;
+    }
+    /** Continue an escape with `char`; returns false when `char` is not part of it and must be read normally. */
+    #continueEscape(open, char) {
+        if (open.escape === "\\") {
+            const decoded = SIMPLE_ESCAPES[char];
+            if (decoded !== undefined) {
+                open.escape = "";
+                this.#appendString(open, decoded);
+                return true;
+            }
+            if (char === "u") {
+                open.escape = "\\u";
+                return true;
+            }
+            // Invalid escape: keep the backslash as text and read the character normally, as repairJson() does.
+            open.escape = "";
+            this.#appendString(open, "\\");
+            return false;
+        }
+        if (isHexDigit(char)) {
+            open.escape += char;
+            if (open.escape.length < 6)
+                return true;
+            const decoded = String.fromCharCode(Number.parseInt(open.escape.slice(2), 16));
+            open.escape = "";
+            this.#appendString(open, decoded);
+            return true;
+        }
+        // `\u` without four hex digits: keep it as text and read the character normally, as repairJson() does.
+        const literal = open.escape;
+        open.escape = "";
+        this.#appendString(open, literal);
+        return false;
+    }
+    #appendString(open, text) {
+        open.text += text;
+        if (open.target !== "value")
+            return;
+        this.#place(open.slot, open.text);
+        if (open.path === undefined)
+            return;
+        // Extend this string's newest change while nothing came after it; otherwise report an append.
+        const change = open.change;
+        if (change !== undefined && this.#changes.at(-1) === change) {
+            if (change.kind === "set")
+                change.value = change.value + text;
+            else
+                change.text += text;
+            return;
+        }
+        open.change = this.#report({ kind: "append", path: open.path, text });
+    }
+    #endString(open) {
+        this.#string = undefined;
+        const frame = this.#stack.at(-1);
+        if (open.target === "key") {
+            if (frame === undefined)
+                return;
+            frame.key = open.text;
+            frame.phase = "colon";
+            return;
+        }
+        this.#valueEnded(frame);
+    }
+    #endScalar() {
+        const token = this.#scalar;
+        const slot = this.#scalarSlot;
+        this.#scalar = "";
+        this.#scalarSlot = undefined;
+        const value = scalarValue(token);
+        if (value !== undefined) {
+            this.#place(slot, value);
+            const path = this.#reportedPath(slot);
+            if (path !== undefined)
+                this.#report({ kind: "set", path, value });
+        }
+        this.#valueEnded(this.#stack.at(-1));
+    }
+    /** The value of the unterminated scalar at the end of the text, if it shows. */
+    #pendingScalar() {
+        const slot = this.#scalarSlot;
+        const token = this.#scalar;
+        if (slot === undefined || token === "" || token.length > MAX_PENDING_SCALAR_LENGTH)
+            return undefined;
+        const value = pendingScalarValue(token);
+        return value === undefined ? undefined : { slot, value };
+    }
+    #openContainer(container) {
+        const slot = this.#valueSlot();
+        const path = this.#reportedPath(slot);
+        this.#place(slot, container);
+        this.#stack.push({
+            container,
+            slot,
+            path,
+            reportsInside: path !== undefined && path.length < MAX_REPORTED_DEPTH,
+            size: 0,
+            key: undefined,
+            phase: Array.isArray(container) ? "value" : "key",
+        });
+        this.#pathCost += 1;
+        this.#dirty = true;
+        // A fresh container: the working one keeps changing, and a change never does.
+        if (path !== undefined)
+            this.#report({ kind: "set", path, value: Array.isArray(container) ? [] : {} });
+    }
+    #closeContainer() {
+        const frame = this.#stack.pop();
+        // A stray closer outside any container is ignored.
+        if (frame === undefined)
+            return;
+        this.#pathCost -= frame.size + 1;
+        this.#dirty = true;
+        // Too deep to report inside: the whole value, final now that it is closed.
+        if (frame.path !== undefined && !frame.reportsInside) {
+            this.#report({ kind: "set", path: frame.path, value: frame.container });
+        }
+        this.#valueEnded(this.#stack.at(-1));
+    }
+    /** A value in `frame`, or the root value when there is no frame, has ended. */
+    #valueEnded(frame) {
+        if (frame === undefined) {
+            // Text after the root value is ignored, but only once a root value exists.
+            if (this.#root !== undefined)
+                this.#done = true;
+            return;
+        }
+        frame.phase = "comma";
+    }
+    /** Set the value at `slot` in the open path; nothing for a value in an invalid position. */
+    #place(slot, value) {
+        if (slot === undefined)
+            return;
+        this.#dirty = true;
+        if (slot.kind === "root") {
+            this.#root = value;
+            return;
+        }
+        const frame = this.#stack.at(-1);
+        if (slot.kind === "element") {
+            const elements = frame.container;
+            if (slot.index === elements.length) {
+                frame.size++;
+                this.#pathCost++;
+            }
+            elements[slot.index] = value;
+            return;
+        }
+        const members = frame.container;
+        if (!Object.hasOwn(members, slot.key)) {
+            frame.size++;
+            this.#pathCost++;
+        }
+        setMember(members, slot.key, value);
+    }
+    /** A fresh snapshot: copies of the open containers, innermost first, each holding the copy of its open child. */
+    #copyOpenPath(pending) {
+        if (this.#stack.length === 0)
+            return pending?.slot.kind === "root" ? pending.value : this.#root;
+        let child;
+        let childSlot;
+        for (let depth = this.#stack.length - 1; depth >= 0; depth--) {
+            const frame = this.#stack[depth];
+            const copy = Array.isArray(frame.container) ? frame.container.slice() : { ...frame.container };
+            if (depth === this.#stack.length - 1 && pending !== undefined)
+                setSlot(copy, pending.slot, pending.value);
+            if (child !== undefined && childSlot !== undefined)
+                setSlot(copy, childSlot, child);
+            child = copy;
+            childSlot = frame.slot;
+        }
+        // The outermost open container is the root unless it sits in an invalid position.
+        return childSlot?.kind === "root" ? child : this.#root;
+    }
+}
+/**
+ * The arguments of one streaming tool call: the raw text, for the one full parse when the call ends, and a
+ * `StreamingJsonParser` for the partial arguments in between. Providers keep one per call in their own stream state,
+ * never on the content block, so the raw text never reaches partial messages or transcripts.
+ */
+export class ToolCallArgumentsStream {
+    #text = "";
+    #parser = new StreamingJsonParser();
+    #snapshot = undefined;
+    #arguments = {};
+    /** The raw argument text received so far. */
+    get text() {
+        return this.#text;
+    }
+    /** Append a piece of argument text; returns the partial arguments, a new object whenever they changed. */
+    append(delta) {
+        this.#text += delta;
+        this.#parser.append(delta);
+        return this.#partial();
+    }
+    /**
+     * Take the provider's complete argument text. When it continues the text so far, returns the missing piece as
+     * `delta`; otherwise starts over with `text`. Either way returns the partial arguments of `text`.
+     */
+    replace(text) {
+        if (text.startsWith(this.#text)) {
+            const delta = text.slice(this.#text.length);
+            return { delta, arguments: delta === "" ? this.#partial() : this.append(delta) };
+        }
+        this.#text = "";
+        this.#parser = new StreamingJsonParser();
+        return { delta: undefined, arguments: this.append(text) };
+    }
+    /** The final arguments: one full parse of the complete text, which reports malformed arguments. */
+    finish() {
+        return parseToolCallArguments(this.#text);
+    }
+    #partial() {
+        const snapshot = this.#parser.snapshot();
+        if (snapshot === this.#snapshot)
+            return this.#arguments;
+        this.#snapshot = snapshot;
+        // Tool arguments are an object; any other partial value shows as no arguments yet.
+        this.#arguments =
+            typeof snapshot === "object" && snapshot !== null && !Array.isArray(snapshot)
+                ? snapshot
+                : {};
+        return this.#arguments;
+    }
+}
+const SIMPLE_ESCAPES = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+};
+function isDelimiter(char) {
+    return (char === " " ||
+        char === "\t" ||
+        char === "\n" ||
+        char === "\r" ||
+        char === "," ||
+        char === ":" ||
+        char === "{" ||
+        char === "}" ||
+        char === "[" ||
+        char === "]" ||
+        char === '"');
+}
+function isHexDigit(char) {
+    return (char >= "0" && char <= "9") || (char >= "a" && char <= "f") || (char >= "A" && char <= "F");
+}
+/** The value of a complete number or literal token; `undefined` for anything else, which is dropped. */
+function scalarValue(token) {
+    for (const [literal, value] of LITERALS)
+        if (token === literal)
+            return value;
+    return NUMBER.test(token) ? Number(token) : undefined;
+}
+/** The value an unterminated number or literal token shows. */
+function pendingScalarValue(token) {
+    for (const [literal, value] of LITERALS)
+        if (literal.startsWith(token))
+            return value;
+    if (NUMBER.test(token))
+        return Number(token);
+    const mantissa = NUMBER_WITHOUT_EXPONENT_DIGITS.exec(token);
+    return mantissa === null ? undefined : Number(mantissa[1]);
+}
+function setSlot(container, slot, value) {
+    if (slot.kind === "element")
+        container[slot.index] = value;
+    else if (slot.kind === "member")
+        setMember(container, slot.key, value);
+}
+function setMember(members, key, value) {
+    // `__proto__` must become an own member, as in JSON.parse(), not the prototype.
+    if (key === "__proto__") {
+        Object.defineProperty(members, key, { value, writable: true, enumerable: true, configurable: true });
+    }
+    else {
+        members[key] = value;
+    }
+}
+//# sourceMappingURL=streaming-json.js.map