tina4-nodejs 3.13.112 → 3.13.113

package/packages/core/dist/index.js

@@ -38784,11 +38784,100 @@ function buildMultipartBody(boundary, fieldName, filename, fileContent, contentT
   parts.push(Buffer.from(delimiter2 + "--" + crlf, "utf-8"));
   return Buffer.concat(parts);
 }
-var RETRY_STATUSES, DOWNLOAD_CHUNK_SIZE, MAX_REDIRECTS, STRIP_ON_CROSS_ORIGIN, MIME_BY_EXT, Api;
+async function* parseLineStream(chunks) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  for await (const chunk of chunks) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf("\n")) >= 0) {
+      let line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (line.endsWith("\r")) {
+        line = line.slice(0, -1);
+      }
+      yield line;
+    }
+  }
+  buffer += decoder.decode();
+  if (buffer.length > 0) {
+    if (buffer.endsWith("\r")) {
+      buffer = buffer.slice(0, -1);
+    }
+    yield buffer;
+  }
+}
+async function* parseSseStream(lines) {
+  let dataParts = [];
+  let event;
+  let id;
+  let retry;
+  let has = false;
+  const emit = () => {
+    if (!has) return null;
+    const ev = { data: dataParts.join("\n") };
+    if (event !== void 0) ev.event = event;
+    if (id !== void 0) ev.id = id;
+    if (retry !== void 0) ev.retry = retry;
+    return ev;
+  };
+  const reset2 = () => {
+    dataParts = [];
+    event = void 0;
+    id = void 0;
+    retry = void 0;
+    has = false;
+  };
+  for await (const line of lines) {
+    if (line === "") {
+      const ev = emit();
+      if (ev) yield ev;
+      reset2();
+      continue;
+    }
+    if (line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "data":
+        dataParts.push(value);
+        has = true;
+        break;
+      case "event":
+        event = value;
+        has = true;
+        break;
+      case "id":
+        id = value;
+        has = true;
+        break;
+      case "retry": {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+          retry = parsed;
+          has = true;
+        }
+        break;
+      }
+    }
+  }
+  const trailing = emit();
+  if (trailing) yield trailing;
+}
+var ApiStreamError, RETRY_STATUSES, DOWNLOAD_CHUNK_SIZE, MAX_REDIRECTS, STRIP_ON_CROSS_ORIGIN, MIME_BY_EXT, Api;
 var init_api = __esm({
   "src/api.ts"() {
     "use strict";
     init_version();
+    ApiStreamError = class extends Error {
+      constructor(message, status2 = null) {
+        super(message);
+        this.status = status2;
+        this.name = "ApiStreamError";
+      }
+    };
     RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
     DOWNLOAD_CHUNK_SIZE = 64 * 1024;
     MAX_REDIRECTS = 10;
@@ -39107,7 +39196,130 @@ var init_api = __esm({
         }
         return { http_code: code, headers: respHeaders, error: null, path: destPath };
       }
+      /**
+       * Stream a response body as raw bytes. Yields the chunks the transport
+       * delivers, in order, never buffered whole. Ends cleanly on EOF and
+       * throws on a transport failure or a non-2xx status (body drained
+       * first). No JSON decoding, no line splitting, no framing —
+       * {@link streamLines} and {@link streamSse} build on this primitive.
+       *
+       * Closing the iterator before EOF (a `break` out of a `for await`)
+       * destroys the underlying socket, so a caller who takes only the
+       * first few chunks never leaks the connection.
+       *
+       * `opts.timeout` bounds the whole stream duration (default
+       * `TINA4_API_TIMEOUT` or the client `timeout`); `opts.connectTimeout`
+       * bounds just the connect + headers phase (default
+       * `TINA4_API_CONNECT_TIMEOUT` or 10s).
+       */
+      async *streamBytes(path8, opts = {}) {
+        const url = this.buildUrl(path8);
+        const method = (opts.method ?? "GET").toUpperCase();
+        const contentType = opts.contentType ?? "application/json";
+        const { headers, data } = this.buildRequest(method, contentType, opts.body, opts.headers);
+        const totalSec = this.streamSeconds(opts.timeout, "TINA4_API_TIMEOUT", this.timeout);
+        const connectSec = this.streamSeconds(opts.connectTimeout, "TINA4_API_CONNECT_TIMEOUT", 10);
+        const opened = await this.openStreamRequest(method, url, headers, data, connectSec);
+        const res = opened.res;
+        const status2 = res.statusCode ?? 0;
+        this.storeCookies(res.headers["set-cookie"]);
+        if (status2 < 200 || status2 >= 300) {
+          res.resume();
+          throw new ApiStreamError(`stream failed with HTTP ${status2}`, status2);
+        }
+        let totalTimer = null;
+        if (totalSec > 0) {
+          totalTimer = setTimeout(() => {
+            res.destroy(new ApiStreamError(`stream total timeout after ${totalSec}s`, null));
+          }, totalSec * 1e3);
+        }
+        try {
+          for await (const chunk of res) {
+            yield chunk;
+          }
+        } finally {
+          if (totalTimer) clearTimeout(totalTimer);
+          if (!res.destroyed) res.destroy();
+        }
+      }
+      /**
+       * Stream the response body as UTF-8 lines. Splits on LF or CRLF;
+       * buffers a multibyte codepoint that lands across a chunk boundary;
+       * yields a trailing line without a terminator on EOF. Built on
+       * {@link streamBytes} plus the shared {@link parseLineStream}.
+       */
+      async *streamLines(path8, opts = {}) {
+        yield* parseLineStream(this.streamBytes(path8, opts));
+      }
+      /**
+       * Stream the response as SSE (Server-Sent Events). Yields one
+       * {@link SseEvent} per event boundary (blank line) or on EOF for a
+       * trailing event. `data:[DONE]` is delivered as an ordinary event
+       * with `data === "[DONE]"` and the iterator ends on the next EOF.
+       * Built on {@link streamLines} plus the shared {@link parseSseStream}.
+       */
+      async *streamSse(path8, opts = {}) {
+        yield* parseSseStream(this.streamLines(path8, opts));
+      }
       // ── Internal helpers ──────────────────────────────────────────────
+      /**
+       * Resolve a stream duration from (in order): explicit `opts` field,
+       * the named env var, then the fallback. Zero disables. A non-numeric
+       * or negative env value warns via a fallback rather than throwing —
+       * a bad env var must not brick every streaming call.
+       */
+      streamSeconds(explicit, envName, fallback) {
+        if (explicit !== void 0) {
+          return Number.isFinite(explicit) && explicit >= 0 ? Number(explicit) : fallback;
+        }
+        const raw = process.env[envName];
+        if (raw === void 0) return fallback;
+        const n = Number(raw);
+        return Number.isFinite(n) && n >= 0 ? n : fallback;
+      }
+      /**
+       * Open a streaming HTTP request. Returns the raw
+       * {@link http.IncomingMessage} once headers arrive. Redirects are NOT
+       * followed on streams (a caller who needs a redirect should do a
+       * regular GET first). Connect phase is bounded by `connectSec`;
+       * body-phase timeout is applied by the caller (streamBytes) via
+       * `res.destroy()`.
+       */
+      openStreamRequest(method, url, headers, data, connectSec) {
+        return new Promise((resolve20, reject) => {
+          let parsed;
+          try {
+            parsed = new URL2(url);
+          } catch (err) {
+            reject(err instanceof Error ? err : new Error(String(err)));
+            return;
+          }
+          const isHttps = parsed.protocol === "https:";
+          const protocolModule = isHttps ? https : http;
+          const options = {
+            hostname: parsed.hostname,
+            port: parsed.port || (isHttps ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method,
+            headers,
+            timeout: connectSec > 0 ? connectSec * 1e3 : void 0
+          };
+          if (isHttps && this.ignoreSsl) {
+            options.rejectUnauthorized = false;
+          }
+          const req2 = protocolModule.request(options, (res) => {
+            resolve20({ res });
+          });
+          req2.on("timeout", () => {
+            req2.destroy(new ApiStreamError(`stream connect timeout after ${connectSec}s`, null));
+          });
+          req2.on("error", (err) => {
+            reject(err);
+          });
+          if (data) req2.write(data);
+          req2.end();
+        });
+      }
       buildUrl(path8) {
         if (path8.startsWith("http://") || path8.startsWith("https://")) {
           return path8;
@@ -41770,10 +41982,11 @@ export default class User {
 // src/aiClient.ts
 import http2 from "node:http";
 import https2 from "node:https";
-var AiError, AiConfigError, AiTimeoutError, AiParseError, AiHTTPError, Ai;
+var AiError, AiConfigError, AiTimeoutError, AiParseError, AiHTTPError, Ai, AggregateState;
 var init_aiClient = __esm({
   "src/aiClient.ts"() {
     "use strict";
+    init_api();
     AiError = class extends Error {
     };
     AiConfigError = class extends AiError {
@@ -41818,10 +42031,51 @@ var init_aiClient = __esm({
           throw new AiParseError("AI provider returned a malformed embedding response");
         }
       }
+      /**
+       * Validate role + content shape. Content may be a string OR a non-empty
+       * list of {type:'text'|'image', ...} parts (ADR-0060). Malformed parts
+       * fail fast with AiConfigError, never reaching the wire.
+       */
       static validateMessages(messages) {
-        if (!Array.isArray(messages) || messages.length === 0 || !messages.every((message) => message && ["system", "user", "assistant"].includes(message.role) && typeof message.content === "string")) {
+        if (!Array.isArray(messages) || messages.length === 0) {
           throw new AiConfigError("AI messages must contain supported roles and string content");
         }
+        for (const message of messages) {
+          if (!message || !["system", "user", "assistant"].includes(message.role)) {
+            throw new AiConfigError("AI messages must contain supported roles and string content");
+          }
+          this.validateContent(message.content);
+        }
+      }
+      static validateContent(content) {
+        if (typeof content === "string") return;
+        if (!Array.isArray(content) || content.length === 0) {
+          throw new AiConfigError("AI message content must be a string or a non-empty list of parts");
+        }
+        for (const part of content) {
+          if (!part || typeof part !== "object" || Array.isArray(part)) {
+            throw new AiConfigError("AI content part must be an object with type and text/source");
+          }
+          const record = part;
+          const partType = record.type;
+          if (partType === "text") {
+            if (typeof record.text !== "string") {
+              throw new AiConfigError("AI text content part requires a string 'text' field");
+            }
+          } else if (partType === "image") {
+            if (typeof record.source !== "string" || record.source.length === 0) {
+              throw new AiConfigError("AI image content part requires a non-empty string 'source' field");
+            }
+            if (!record.source.startsWith("data:") && !record.source.startsWith("https://")) {
+              throw new AiConfigError("AI image source must be a data: URI or an https:// URL");
+            }
+            if (record.source.startsWith("data:") && !/^data:[^;,\s]+;base64,[A-Za-z0-9+/=]+$/.test(record.source)) {
+              throw new AiConfigError("AI image data URI must be data:<media_type>;base64,<payload>");
+            }
+          } else {
+            throw new AiConfigError(`AI content part has unknown type '${String(partType)}'`);
+          }
+        }
       }
       static number(name, fallback, minimum) {
         const value = process.env[name] === void 0 ? fallback : Number(process.env[name]);
@@ -41869,18 +42123,57 @@ var init_aiClient = __esm({
         }
         return headers;
       }
+      /**
+       * Build the provider-specific request body from a Tina4-shaped message
+       * list. Multimodal parts are translated per provider (ADR-0060):
+       *   - OpenAI/local: {type:'image_url', image_url:{url}}
+       *   - Anthropic:    {type:'image', source:{type:'base64'|'url', ...}}
+       * String content is preserved verbatim in the OpenAI/local shape and
+       * likewise for Anthropic (both accept a bare string).
+       */
       static chatBody(config, messages, options) {
-        const body = { model: config.model, messages, stream: options.stream ?? false };
+        const translate = (list) => list.map((message) => ({ role: message.role, content: this.translateContent(message.content, config.provider) }));
+        const body = { model: config.model, messages: translate(messages), stream: options.stream ?? false };
         if (options.temperature !== void 0) body.temperature = options.temperature;
         if (options.maxTokens !== void 0) body.max_tokens = options.maxTokens;
         if (config.provider === "anthropic") {
-          const system = messages.filter((message) => message.role === "system").map((message) => message.content);
-          body.messages = messages.filter((message) => message.role !== "system");
+          const systemParts = messages.filter((message) => message.role === "system").map((message) => typeof message.content === "string" ? message.content : this.contentToPlainText(message.content));
+          body.messages = translate(messages.filter((message) => message.role !== "system"));
           body.max_tokens = options.maxTokens ?? 1024;
-          if (system.length) body.system = system.join("\n\n");
+          if (systemParts.length) body.system = systemParts.join("\n\n");
         }
         return body;
       }
+      /**
+       * Translate one message content value into the provider's on-wire shape.
+       * A plain string is passed through (both providers accept a string
+       * content). A parts array becomes provider-native content blocks.
+       */
+      static translateContent(content, provider) {
+        if (typeof content === "string") return content;
+        if (provider === "anthropic") {
+          return content.map((part) => {
+            if (part.type === "text") return { type: "text", text: part.text };
+            if (part.source.startsWith("data:")) {
+              const parsed = this.parseDataUri(part.source);
+              return { type: "image", source: { type: "base64", media_type: parsed.mediaType, data: parsed.data } };
+            }
+            return { type: "image", source: { type: "url", url: part.source } };
+          });
+        }
+        return content.map((part) => {
+          if (part.type === "text") return { type: "text", text: part.text };
+          return { type: "image_url", image_url: { url: part.source } };
+        });
+      }
+      static parseDataUri(source) {
+        const match = /^data:([^;,\s]+);base64,([A-Za-z0-9+/=]+)$/.exec(source);
+        if (!match) throw new AiConfigError("AI image data URI must be data:<media_type>;base64,<payload>");
+        return { mediaType: match[1], data: match[2] };
+      }
+      static contentToPlainText(parts) {
+        return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
+      }
       static open(config, deadline, headers, body) {
         const remainingMs = deadline - performance.now();
         if (remainingMs <= 0) return Promise.reject(new AiTimeoutError("AI total request timeout expired"));
@@ -41980,35 +42273,12 @@ var init_aiClient = __esm({
       static async chatResponse(config, headers, body) {
         return this.normalizeChat(config.provider, await this.requestJson(config, headers, body));
       }
-      static streamDelta(provider, data) {
-        if (data === "[DONE]") return { completed: true };
-        let event;
-        try {
-          event = JSON.parse(data);
-        } catch {
-          throw new AiParseError("AI provider returned malformed stream data");
-        }
-        const text = provider === "anthropic" ? event.type === "content_block_delta" ? event.delta?.text : void 0 : event.choices?.[0]?.delta?.content;
-        if (text !== void 0 && text !== null && typeof text !== "string") throw new AiParseError("AI provider returned malformed stream data");
-        return { completed: false, text };
-      }
-      static async *streamData(response) {
-        let buffer = "";
-        for await (const chunk of response) {
-          buffer += Buffer.from(chunk).toString("utf8");
-          let newline;
-          while ((newline = buffer.indexOf("\n")) >= 0) {
-            const line = buffer.slice(0, newline).trim();
-            buffer = buffer.slice(newline + 1);
-            if (line.startsWith("data:")) yield line.slice(5).trim();
-          }
-        }
-      }
-      static streamError(error) {
-        if (error instanceof AiError) return error;
-        if (error instanceof Error && error.name === "AbortError") return new AiTimeoutError("AI total request timeout expired");
-        return new AiHTTPError(`AI transport failed (${error instanceof Error ? error.name : "Error"})`);
-      }
+      /**
+       * Stream the response through the shared {@link parseSseStream} framer
+       * (ADR-0060 rule 5). Translates each SSE data payload into 0..N
+       * {@link AiEvent}s: text_delta per chunk, tool_call aggregated per
+       * index / block, exactly one done (or error) at the end.
+       */
       static async *streamRequest(config, headers, body) {
         const deadline = performance.now() + config.totalTimeout * 1e3;
         let yielded = false;
@@ -42027,27 +42297,239 @@ var init_aiClient = __esm({
               }
               throw new AiHTTPError(`AI provider returned HTTP ${status2}`, status2);
             }
-            let completed = false;
-            for await (const data of this.streamData(opened.response)) {
-              const delta = this.streamDelta(config.provider, data);
-              if (delta.completed) {
-                completed = true;
-                break;
+            const response = opened.response;
+            const chunks = this.responseChunks(response);
+            const events = parseSseStream(parseLineStream(chunks));
+            const aggregator = new AggregateState(config.provider);
+            let done = false;
+            try {
+              for await (const sseEvent of events) {
+                for (const emitted of aggregator.consume(sseEvent)) {
+                  yielded = true;
+                  yield emitted;
+                  if (emitted.type === "done" || emitted.type === "error") {
+                    done = true;
+                    break;
+                  }
+                }
+                if (done) break;
+              }
+            } catch (error) {
+              if (yielded) {
+                yielded = true;
+                yield { type: "error", message: error instanceof AiParseError ? "AI provider returned malformed stream data" : `AI transport failed (${error instanceof Error ? error.name : "Error"})` };
+                opened.cleanup();
+                opened = null;
+                return;
               }
-              if (delta.text === void 0) continue;
-              yielded = true;
-              yield delta.text;
+              throw error;
             }
             opened.cleanup();
             opened = null;
-            if (completed) return;
-            throw new AiParseError("AI provider stream ended before [DONE]");
+            if (done) return;
+            if (yielded) {
+              yield { type: "error", message: "AI provider stream ended before completion" };
+              return;
+            }
+            throw new AiParseError("AI provider stream ended before completion");
           } catch (error) {
             opened?.cleanup();
             const failure = this.streamError(error);
-            if (failure instanceof AiParseError || failure instanceof AiHTTPError && failure.status !== null || yielded || attempt >= config.maxRetries) throw failure;
+            if (yielded) {
+              yield { type: "error", message: failure.message };
+              return;
+            }
+            if (failure instanceof AiParseError || failure instanceof AiHTTPError && failure.status !== null || attempt >= config.maxRetries) throw failure;
+          }
+        }
+      }
+      static async *responseChunks(response) {
+        for await (const chunk of response) {
+          yield chunk;
+        }
+      }
+      static streamError(error) {
+        if (error instanceof AiError) return error;
+        if (error instanceof Error && error.name === "AbortError") return new AiTimeoutError("AI total request timeout expired");
+        return new AiHTTPError(`AI transport failed (${error instanceof Error ? error.name : "Error"})`);
+      }
+    };
+    AggregateState = class {
+      constructor(provider) {
+        this.provider = provider;
+      }
+      toolBuffers = /* @__PURE__ */ new Map();
+      lastFinishReason = null;
+      lastUsage = null;
+      doneEmitted = false;
+      *consume(event) {
+        const data = event.data;
+        if (data === "[DONE]") {
+          if (this.doneEmitted) return;
+          yield* this.flushRemainingToolCalls();
+          this.doneEmitted = true;
+          yield {
+            type: "done",
+            finishReason: this.lastFinishReason ?? "stop",
+            ...this.lastUsage ? { usage: this.lastUsage } : {}
+          };
+          return;
+        }
+        let payload;
+        try {
+          payload = JSON.parse(data);
+        } catch {
+          throw new AiParseError("AI provider returned malformed stream data");
+        }
+        if (this.provider === "anthropic") {
+          yield* this.consumeAnthropic(payload);
+        } else {
+          yield* this.consumeOpenAi(payload);
+        }
+      }
+      *consumeOpenAi(payload) {
+        const choices = payload.choices;
+        if (!Array.isArray(choices) || choices.length === 0) return;
+        const choice = choices[0];
+        const delta = choice.delta ?? {};
+        const content = delta.content;
+        if (typeof content === "string" && content.length > 0) {
+          yield { type: "text_delta", text: content };
+        }
+        const toolCalls = delta.tool_calls;
+        if (Array.isArray(toolCalls)) {
+          for (const call of toolCalls) {
+            const index = typeof call.index === "number" ? String(call.index) : String(this.toolBuffers.size);
+            const idFromCall = typeof call.id === "string" ? call.id : "";
+            const fn = call.function ?? {};
+            const nameFromCall = typeof fn.name === "string" ? fn.name : "";
+            const argsFragment = typeof fn.arguments === "string" ? fn.arguments : "";
+            const existing = this.toolBuffers.get(index) ?? { id: "", name: "", args: "" };
+            if (idFromCall) existing.id = idFromCall;
+            if (nameFromCall) existing.name = nameFromCall;
+            existing.args += argsFragment;
+            this.toolBuffers.set(index, existing);
+            if (existing.name && existing.args) {
+              try {
+                const parsed = JSON.parse(existing.args);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                  this.toolBuffers.delete(index);
+                  yield { type: "tool_call", id: existing.id || `call_${index}`, name: existing.name, args: parsed };
+                }
+              } catch {
+              }
+            }
+          }
+        }
+        if (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0) {
+          this.lastFinishReason = choice.finish_reason;
+        }
+        const usage = payload.usage;
+        if (usage && typeof usage === "object") {
+          const promptTokens = Number(usage.prompt_tokens ?? 0);
+          const completionTokens = Number(usage.completion_tokens ?? 0);
+          const totalTokens = Number(usage.total_tokens ?? promptTokens + completionTokens);
+          if (Number.isFinite(promptTokens) && Number.isFinite(completionTokens)) {
+            this.lastUsage = { promptTokens, completionTokens, totalTokens };
+          }
+        }
+      }
+      *consumeAnthropic(payload) {
+        const type2 = payload.type;
+        if (type2 === "content_block_start") {
+          const block = payload.content_block ?? {};
+          if (block.type === "tool_use") {
+            const index = String(payload.index ?? this.toolBuffers.size);
+            const id = typeof block.id === "string" ? block.id : `call_${index}`;
+            const name = typeof block.name === "string" ? block.name : "";
+            this.toolBuffers.set(index, { id, name, args: "" });
+          }
+          return;
+        }
+        if (type2 === "content_block_delta") {
+          const index = String(payload.index ?? 0);
+          const delta = payload.delta ?? {};
+          if (delta.type === "text_delta" && typeof delta.text === "string" && delta.text.length > 0) {
+            yield { type: "text_delta", text: delta.text };
+            return;
+          }
+          if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+            const existing = this.toolBuffers.get(index);
+            if (existing) existing.args += delta.partial_json;
+          }
+          return;
+        }
+        if (type2 === "content_block_stop") {
+          const index = String(payload.index ?? 0);
+          const existing = this.toolBuffers.get(index);
+          if (existing && existing.name) {
+            this.toolBuffers.delete(index);
+            try {
+              const parsed = existing.args ? JSON.parse(existing.args) : {};
+              if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                yield { type: "tool_call", id: existing.id, name: existing.name, args: parsed };
+                return;
+              }
+              throw new Error();
+            } catch {
+              throw new AiParseError("AI provider returned malformed tool-call JSON");
+            }
+          }
+          return;
+        }
+        if (type2 === "message_delta") {
+          const delta = payload.delta ?? {};
+          if (typeof delta.stop_reason === "string" && delta.stop_reason.length > 0) {
+            this.lastFinishReason = delta.stop_reason;
+          }
+          const usage = payload.usage ?? {};
+          if (usage.output_tokens !== void 0 || usage.input_tokens !== void 0) {
+            const promptTokens = Number(usage.input_tokens ?? this.lastUsage?.promptTokens ?? 0);
+            const completionTokens = Number(usage.output_tokens ?? this.lastUsage?.completionTokens ?? 0);
+            this.lastUsage = { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens };
+          }
+          return;
+        }
+        if (type2 === "message_stop") {
+          if (this.doneEmitted) return;
+          this.doneEmitted = true;
+          yield {
+            type: "done",
+            finishReason: this.lastFinishReason ?? "end_turn",
+            ...this.lastUsage ? { usage: this.lastUsage } : {}
+          };
+          return;
+        }
+        if (type2 === "message_start") {
+          const message = payload.message ?? {};
+          const usage = message.usage ?? {};
+          if (usage.input_tokens !== void 0 || usage.output_tokens !== void 0) {
+            const promptTokens = Number(usage.input_tokens ?? 0);
+            const completionTokens = Number(usage.output_tokens ?? 0);
+            this.lastUsage = { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens };
+          }
+          return;
+        }
+        if (type2 === "error") {
+          const err = payload.error ?? {};
+          throw new AiParseError(typeof err.message === "string" ? err.message : "AI provider signalled a stream error");
+        }
+      }
+      *flushRemainingToolCalls() {
+        for (const [index, buffered] of this.toolBuffers) {
+          if (buffered.name && buffered.args) {
+            try {
+              const parsed = JSON.parse(buffered.args);
+              if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                yield { type: "tool_call", id: buffered.id || `call_${index}`, name: buffered.name, args: parsed };
+                continue;
+              }
+            } catch {
+            }
+            throw new AiParseError("AI provider returned malformed tool-call JSON");
           }
         }
+        this.toolBuffers.clear();
       }
     };
   }
@@ -43763,6 +44245,7 @@ __export(index_exports, {
   AiParseError: () => AiParseError,
   AiTimeoutError: () => AiTimeoutError,
   Api: () => Api,
+  ApiStreamError: () => ApiStreamError,
   Auth: () => Auth,
   CANONICAL_SESSION_BACKENDS: () => CANONICAL_SESSION_BACKENDS,
   CLOSE_GOING_AWAY: () => CLOSE_GOING_AWAY,
@@ -43992,7 +44475,9 @@ __export(index_exports, {
   originAllowed: () => originAllowed,
   parseAmqpUrl: () => parseAmqpUrl,
   parseFrame: () => parseFrame,
+  parseLineStream: () => parseLineStream,
   parseMultipart: () => parseMultipart,
+  parseSseStream: () => parseSseStream,
   parseUpgradeHeaders: () => parseUpgradeHeaders,
   patch: () => patch,
   pidfilePath: () => pidfilePath,
@@ -44129,6 +44614,7 @@ export {
   AiParseError,
   AiTimeoutError,
   Api,
+  ApiStreamError,
   Auth,
   CANONICAL_SESSION_BACKENDS,
   CLOSE_GOING_AWAY,
@@ -44358,7 +44844,9 @@ export {
   originAllowed,
   parseAmqpUrl,
   parseFrame,
+  parseLineStream,
   parseMultipart,
+  parseSseStream,
   parseUpgradeHeaders,
   patch,
   pidfilePath,