@warmdrift/kgauto-compiler 2.0.0-alpha.33 → 2.0.0-alpha.35

package/dist/index.mjs

@@ -1725,8 +1725,295 @@ var CallError = class extends Error {
   }
 };
 
-// src/execute.ts
+// src/streaming.ts
 var ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
+async function streamAnthropic(request, apiKey, opts) {
+  const { provider: _provider, ...body } = request;
+  const fetchFn = opts.fetchImpl ?? fetch;
+  let res;
+  try {
+    res = await fetchFn(ANTHROPIC_URL, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ ...body, stream: true })
+    });
+  } catch (err) {
+    return retryableError(0, "network_error", String(err), null);
+  }
+  if (!res.ok) {
+    const errBody = await res.json().catch(() => ({}));
+    return classifyHttpError(res.status, errBody);
+  }
+  let text = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens;
+  let cacheCreatedTokens;
+  let stopReason;
+  const toolBlocks = /* @__PURE__ */ new Map();
+  try {
+    await parseSSEStream(res, (event) => {
+      if (!event.data) return;
+      let payload;
+      try {
+        payload = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      const type = payload.type;
+      if (type === "message_start") {
+        const msg = payload.message;
+        const usage = msg?.usage;
+        if (usage) {
+          inputTokens = usage.input_tokens ?? 0;
+          outputTokens = usage.output_tokens ?? 0;
+          if (typeof usage.cache_read_input_tokens === "number")
+            cacheReadTokens = usage.cache_read_input_tokens;
+          if (typeof usage.cache_creation_input_tokens === "number")
+            cacheCreatedTokens = usage.cache_creation_input_tokens;
+        }
+        return;
+      }
+      if (type === "content_block_start") {
+        const p = payload;
+        const idx = p.index ?? 0;
+        const block = p.content_block;
+        if (block?.type === "tool_use" && block.id && block.name) {
+          toolBlocks.set(idx, { id: block.id, name: block.name, argsJson: "" });
+        }
+        return;
+      }
+      if (type === "content_block_delta") {
+        const p = payload;
+        const delta = p.delta;
+        if (!delta) return;
+        if (delta.type === "text_delta" && typeof delta.text === "string") {
+          text += delta.text;
+          opts.onChunk(delta.text);
+        } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+          const idx = p.index ?? 0;
+          const tool = toolBlocks.get(idx);
+          if (tool) tool.argsJson += delta.partial_json;
+        }
+        return;
+      }
+      if (type === "message_delta") {
+        const p = payload;
+        if (p.delta?.stop_reason) stopReason = p.delta.stop_reason;
+        if (typeof p.usage?.output_tokens === "number") outputTokens = p.usage.output_tokens;
+        return;
+      }
+    });
+  } catch (err) {
+    return retryableError(0, "stream_interrupted", String(err), null);
+  }
+  const toolCalls = Array.from(toolBlocks.values()).map((b) => ({
+    id: b.id,
+    name: b.name,
+    args: tryParseJson(b.argsJson) ?? {}
+  }));
+  const tokens = {
+    input: inputTokens,
+    output: outputTokens,
+    total: inputTokens + outputTokens,
+    cached: cacheReadTokens,
+    cacheCreated: cacheCreatedTokens
+  };
+  const response = {
+    text,
+    structuredOutput: null,
+    toolCalls,
+    tokens,
+    finishReason: stopReason,
+    raw: { streamed: true, provider: "anthropic" }
+  };
+  return { ok: true, status: res.status, response };
+}
+async function streamOpenAILike(url, request, apiKey, providerLabel, opts) {
+  const { provider: _provider, ...body } = request;
+  const fetchFn = opts.fetchImpl ?? fetch;
+  const reqBody = {
+    ...body,
+    stream: true,
+    stream_options: {
+      ...body.stream_options ?? {},
+      include_usage: true
+    }
+  };
+  let res;
+  try {
+    res = await fetchFn(url, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(reqBody)
+    });
+  } catch (err) {
+    return retryableError(0, "network_error", String(err), null);
+  }
+  if (!res.ok) {
+    const errBody = await res.json().catch(() => ({}));
+    return classifyHttpError(res.status, errBody);
+  }
+  let text = "";
+  let finishReason;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let totalTokens;
+  let cachedTokens;
+  const toolBuffers = /* @__PURE__ */ new Map();
+  try {
+    await parseSSEStream(res, (event) => {
+      if (!event.data) return;
+      if (event.data === "[DONE]") return;
+      let payload;
+      try {
+        payload = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      const choices = payload.choices;
+      if (choices && choices.length > 0) {
+        const choice = choices[0];
+        const deltaContent = choice.delta?.content;
+        if (typeof deltaContent === "string" && deltaContent.length > 0) {
+          text += deltaContent;
+          opts.onChunk(deltaContent);
+        }
+        const toolDeltas = choice.delta?.tool_calls;
+        if (toolDeltas) {
+          for (const tcDelta of toolDeltas) {
+            const idx = tcDelta.index ?? 0;
+            let buf = toolBuffers.get(idx);
+            if (!buf) {
+              buf = { id: tcDelta.id ?? `tc-${idx}`, name: "", argsJson: "" };
+              toolBuffers.set(idx, buf);
+            }
+            if (tcDelta.id) buf.id = tcDelta.id;
+            if (tcDelta.function?.name) buf.name += tcDelta.function.name;
+            if (tcDelta.function?.arguments) buf.argsJson += tcDelta.function.arguments;
+          }
+        }
+        if (choice.finish_reason) finishReason = choice.finish_reason;
+      }
+      const usage = payload.usage;
+      if (usage) {
+        if (typeof usage.prompt_tokens === "number") inputTokens = usage.prompt_tokens;
+        if (typeof usage.completion_tokens === "number") outputTokens = usage.completion_tokens;
+        if (typeof usage.total_tokens === "number") totalTokens = usage.total_tokens;
+        const details = usage.prompt_tokens_details;
+        if (typeof details?.cached_tokens === "number") cachedTokens = details.cached_tokens;
+      }
+    });
+  } catch (err) {
+    return retryableError(0, "stream_interrupted", String(err), null);
+  }
+  const toolCalls = Array.from(toolBuffers.values()).filter((b) => b.name.length > 0).map((b) => ({
+    id: b.id,
+    name: b.name,
+    args: tryParseJson(b.argsJson) ?? {}
+  }));
+  const tokens = {
+    input: inputTokens,
+    output: outputTokens,
+    total: totalTokens ?? inputTokens + outputTokens,
+    cached: cachedTokens
+  };
+  const response = {
+    text,
+    structuredOutput: null,
+    toolCalls,
+    tokens,
+    finishReason,
+    raw: { streamed: true, provider: providerLabel }
+  };
+  return { ok: true, status: res.status, response };
+}
+async function parseSSEStream(response, handler) {
+  const body = response.body;
+  if (!body) throw new Error("Response has no body for SSE parse");
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let sep;
+    while (sep = buffer.indexOf("\n\n"), sep !== -1) {
+      const block = buffer.slice(0, sep);
+      buffer = buffer.slice(sep + 2);
+      const event = parseSSEBlock(block);
+      if (event) handler(event);
+    }
+  }
+  if (buffer.length > 0) {
+    const event = parseSSEBlock(buffer);
+    if (event) handler(event);
+  }
+}
+function parseSSEBlock(block) {
+  const lines = block.split(/\r?\n/);
+  let eventName;
+  const dataLines = [];
+  for (const line of lines) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trim());
+    }
+  }
+  if (dataLines.length === 0) return void 0;
+  return { event: eventName, data: dataLines.join("\n") };
+}
+function tryParseJson(s) {
+  if (typeof s !== "string" || s.length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(s);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function classifyHttpError(status, body) {
+  const message = extractErrorMessage(body) ?? `HTTP ${status}`;
+  if (status === 429)
+    return { ok: false, status, errorType: "retryable", errorCode: "rate_limit", message, raw: body };
+  if (status === 408)
+    return { ok: false, status, errorType: "retryable", errorCode: "timeout", message, raw: body };
+  if (status >= 500)
+    return { ok: false, status, errorType: "retryable", errorCode: "server_error", message, raw: body };
+  if (status === 404)
+    return { ok: false, status, errorType: "retryable", errorCode: "model_not_found", message, raw: body };
+  if (status === 401 || status === 403)
+    return { ok: false, status, errorType: "terminal", errorCode: "auth", message, raw: body };
+  if (status === 400)
+    return { ok: false, status, errorType: "terminal", errorCode: "invalid_request", message, raw: body };
+  return { ok: false, status, errorType: "terminal", errorCode: "unknown", message, raw: body };
+}
+function extractErrorMessage(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (b.error && typeof b.error === "object") {
+    const e = b.error;
+    if (typeof e.message === "string") return e.message;
+  }
+  if (typeof b.message === "string") return b.message;
+  return void 0;
+}
+function retryableError(status, code, message, raw) {
+  return { ok: false, status, errorType: "retryable", errorCode: code, message, raw };
+}
+
+// src/execute.ts
+var ANTHROPIC_URL2 = "https://api.anthropic.com/v1/messages";
 var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
 var DEEPSEEK_URL = "https://api.deepseek.com/chat/completions";
 async function execute(request, opts = {}) {
@@ -1751,12 +2038,18 @@ async function executeAnthropic(request, opts) {
   if (!apiKey) {
     return terminalError(401, "auth", "ANTHROPIC_API_KEY missing");
   }
+  if (opts.onChunk) {
+    return streamAnthropic(request, apiKey, {
+      onChunk: opts.onChunk,
+      fetchImpl: opts.fetchImpl
+    });
+  }
   const { provider: _provider, ...body } = request;
   const fetchFn = opts.fetchImpl ?? fetch;
   let res;
   let json;
   try {
-    res = await fetchFn(ANTHROPIC_URL, {
+    res = await fetchFn(ANTHROPIC_URL2, {
       method: "POST",
       headers: {
         "x-api-key": apiKey,
@@ -1767,9 +2060,9 @@ async function executeAnthropic(request, opts) {
     });
     json = await res.json().catch(() => ({}));
   } catch (err) {
-    return retryableError(0, "network_error", String(err), null);
+    return retryableError2(0, "network_error", String(err), null);
   }
-  if (!res.ok) return classifyHttpError(res.status, json);
+  if (!res.ok) return classifyHttpError2(res.status, json);
   return { ok: true, status: res.status, response: normalizeAnthropic(json) };
 }
 function normalizeAnthropic(raw) {
@@ -1803,9 +2096,9 @@ async function executeGoogle(request, opts) {
     });
     json = await res.json().catch(() => ({}));
   } catch (err) {
-    return retryableError(0, "network_error", String(err), null);
+    return retryableError2(0, "network_error", String(err), null);
   }
-  if (!res.ok) return classifyHttpError(res.status, json);
+  if (!res.ok) return classifyHttpError2(res.status, json);
   return { ok: true, status: res.status, response: normalizeGoogle(json) };
 }
 function normalizeGoogle(raw) {
@@ -1832,6 +2125,12 @@ async function executeOpenAI(request, opts) {
   if (!apiKey) {
     return terminalError(401, "auth", "OPENAI_API_KEY missing");
   }
+  if (opts.onChunk) {
+    return streamOpenAILike(OPENAI_URL, request, apiKey, "openai", {
+      onChunk: opts.onChunk,
+      fetchImpl: opts.fetchImpl
+    });
+  }
   const { provider: _provider, ...body } = request;
   const fetchFn = opts.fetchImpl ?? fetch;
   let res;
@@ -1844,9 +2143,9 @@ async function executeOpenAI(request, opts) {
     });
     json = await res.json().catch(() => ({}));
   } catch (err) {
-    return retryableError(0, "network_error", String(err), null);
+    return retryableError2(0, "network_error", String(err), null);
   }
-  if (!res.ok) return classifyHttpError(res.status, json);
+  if (!res.ok) return classifyHttpError2(res.status, json);
   return { ok: true, status: res.status, response: normalizeOpenAILike(json) };
 }
 async function executeDeepSeek(request, opts) {
@@ -1854,6 +2153,12 @@ async function executeDeepSeek(request, opts) {
   if (!apiKey) {
     return terminalError(401, "auth", "DEEPSEEK_API_KEY missing");
   }
+  if (opts.onChunk) {
+    return streamOpenAILike(DEEPSEEK_URL, request, apiKey, "deepseek", {
+      onChunk: opts.onChunk,
+      fetchImpl: opts.fetchImpl
+    });
+  }
   const { provider: _provider, ...body } = request;
   const fetchFn = opts.fetchImpl ?? fetch;
   let res;
@@ -1866,9 +2171,9 @@ async function executeDeepSeek(request, opts) {
     });
     json = await res.json().catch(() => ({}));
   } catch (err) {
-    return retryableError(0, "network_error", String(err), null);
+    return retryableError2(0, "network_error", String(err), null);
   }
-  if (!res.ok) return classifyHttpError(res.status, json);
+  if (!res.ok) return classifyHttpError2(res.status, json);
   return { ok: true, status: res.status, response: normalizeOpenAILike(json) };
 }
 function normalizeOpenAILike(raw) {
@@ -1878,7 +2183,7 @@ function normalizeOpenAILike(raw) {
   const toolCalls = (choice?.message?.tool_calls ?? []).filter((tc) => tc.function?.name).map((tc, i) => ({
     id: tc.id ?? `tc-${i}`,
     name: tc.function.name,
-    args: tryParseJson(tc.function?.arguments) ?? {}
+    args: tryParseJson2(tc.function?.arguments) ?? {}
   }));
   const u = r.usage ?? {};
   const tokens = {
@@ -1895,8 +2200,8 @@ function applyOverrides(request, overrides) {
   if (!layer) return request;
   return { ...request, ...layer };
 }
-function classifyHttpError(status, body) {
-  const message = extractErrorMessage(body) ?? `HTTP ${status}`;
+function classifyHttpError2(status, body) {
+  const message = extractErrorMessage2(body) ?? `HTTP ${status}`;
   if (status === 429) {
     return { ok: false, status, errorType: "retryable", errorCode: "rate_limit", message, raw: body };
   }
@@ -1917,7 +2222,7 @@ function classifyHttpError(status, body) {
   }
   return { ok: false, status, errorType: "terminal", errorCode: "unknown", message, raw: body };
 }
-function extractErrorMessage(body) {
+function extractErrorMessage2(body) {
   if (!body || typeof body !== "object") return void 0;
   const b = body;
   if (b.error && typeof b.error === "object") {
@@ -1930,10 +2235,10 @@ function extractErrorMessage(body) {
 function terminalError(status, code, message) {
   return { ok: false, status, errorType: "terminal", errorCode: code, message, raw: null };
 }
-function retryableError(status, code, message, raw) {
+function retryableError2(status, code, message, raw) {
   return { ok: false, status, errorType: "retryable", errorCode: code, message, raw };
 }
-function tryParseJson(s) {
+function tryParseJson2(s) {
   if (typeof s !== "string" || s.length === 0) return void 0;
   try {
     const parsed = JSON.parse(s);
@@ -2103,10 +2408,13 @@ async function call(ir, opts = {}) {
     safeEmit(
       () => emitExecuteAttempt(traceId, ir.appId, { model: targetModel, attemptIndex: i })
     );
+    const targetSupportsStreaming = targetProfile?.streaming === true;
+    const streamingOnChunk = opts.onChunk && !opts.noStream && targetSupportsStreaming ? opts.onChunk : void 0;
     const exec = await execute(activeCompile.request, {
       apiKeys: opts.apiKeys,
       fetchImpl: opts.fetchImpl,
-      providerOverrides: opts.providerOverrides
+      providerOverrides: opts.providerOverrides,
+      onChunk: streamingOnChunk
     });
     const validated = exec.ok ? validateStructuredContract(exec, ir) : exec;
     if (validated.ok) {

package/dist/{ir-DubC20e3.d.mts → ir-BAAHLfFL.d.mts}

@@ -733,6 +733,43 @@ interface CallOptions {
      * for hermetic test runs.
      */
     noAutoFilter?: boolean;
+    /**
+     * alpha.34. When provided AND the chosen provider supports streaming
+     * (`profile.streaming === true`) AND `noStream` is not set, kgauto
+     * enables provider-native SSE streaming at the wire layer and invokes
+     * `onChunk(delta)` once per provider stream event. `delta` is the text
+     * since the previous `onChunk` call (NOT cumulative) — provider
+     * stream-shape headache normalized in kgauto's lowering layer.
+     *
+     * `CallResult.response.text` is still populated with the full assembled
+     * response — kgauto buffers internally regardless of the callback.
+     * Consumers can use either the streaming side-effect OR the final
+     * `response.text`, doesn't matter.
+     *
+     * Tool calls + finish reason + usage are collected from stream events
+     * and returned in the final `CallResult` exactly as the non-streaming
+     * path would shape them. Brain telemetry latency = time-to-stream-end.
+     *
+     * Chain-walk semantics: if the streaming target fails mid-stream
+     * (network error, retryable provider error), kgauto walks to the next
+     * fallback target and restarts streaming from its first chunk —
+     * `onChunk` fires fresh from the new target. Consumer detects via the
+     * post-call `CallResult.fellOverFrom`. To opt out of fallback for
+     * streaming, set `noFallback: true` alongside `onChunk`.
+     *
+     * Filed by playbacksam s42 (2026-05-22) as `streaming-output-callback-
+     * on-callresult` for ComposeDrawer SSE; perceived-latency UX win
+     * during 10-30s draft assembly.
+     */
+    onChunk?: (chunk: string) => void;
+    /**
+     * alpha.34. Explicit opt-out of streaming even when `onChunk` is
+     * provided. Default: false (streaming enabled when `onChunk` is set).
+     * Use when the consumer wants to pass `onChunk` conditionally without
+     * branching the call site (e.g., capture chunks for instrumentation
+     * without engaging streaming wire format).
+     */
+    noStream?: boolean;
 }
 interface CallAttempt {
     model: string;

package/dist/{ir-GnYPkpGo.d.ts → ir-B_ygNURd.d.ts}

@@ -733,6 +733,43 @@ interface CallOptions {
      * for hermetic test runs.
      */
     noAutoFilter?: boolean;
+    /**
+     * alpha.34. When provided AND the chosen provider supports streaming
+     * (`profile.streaming === true`) AND `noStream` is not set, kgauto
+     * enables provider-native SSE streaming at the wire layer and invokes
+     * `onChunk(delta)` once per provider stream event. `delta` is the text
+     * since the previous `onChunk` call (NOT cumulative) — provider
+     * stream-shape headache normalized in kgauto's lowering layer.
+     *
+     * `CallResult.response.text` is still populated with the full assembled
+     * response — kgauto buffers internally regardless of the callback.
+     * Consumers can use either the streaming side-effect OR the final
+     * `response.text`, doesn't matter.
+     *
+     * Tool calls + finish reason + usage are collected from stream events
+     * and returned in the final `CallResult` exactly as the non-streaming
+     * path would shape them. Brain telemetry latency = time-to-stream-end.
+     *
+     * Chain-walk semantics: if the streaming target fails mid-stream
+     * (network error, retryable provider error), kgauto walks to the next
+     * fallback target and restarts streaming from its first chunk —
+     * `onChunk` fires fresh from the new target. Consumer detects via the
+     * post-call `CallResult.fellOverFrom`. To opt out of fallback for
+     * streaming, set `noFallback: true` alongside `onChunk`.
+     *
+     * Filed by playbacksam s42 (2026-05-22) as `streaming-output-callback-
+     * on-callresult` for ComposeDrawer SSE; perceived-latency UX win
+     * during 10-30s draft assembly.
+     */
+    onChunk?: (chunk: string) => void;
+    /**
+     * alpha.34. Explicit opt-out of streaming even when `onChunk` is
+     * provided. Default: false (streaming enabled when `onChunk` is set).
+     * Use when the consumer wants to pass `onChunk` conditionally without
+     * branching the call site (e.g., capture chunks for instrumentation
+     * without engaging streaming wire format).
+     */
+    noStream?: boolean;
 }
 interface CallAttempt {
     model: string;

package/dist/profiles.d.mts

@@ -1,4 +1,4 @@
-import { k as Provider } from './ir-DubC20e3.mjs';
+import { k as Provider } from './ir-BAAHLfFL.mjs';
 import { IntentArchetypeName } from './dialect.mjs';
 
 /**

package/dist/profiles.d.ts

@@ -1,4 +1,4 @@
-import { k as Provider } from './ir-GnYPkpGo.js';
+import { k as Provider } from './ir-B_ygNURd.js';
 import { IntentArchetypeName } from './dialect.js';
 
 /**

package/dist/{types-2QzI0Ep1.d.mts → types-BoqPXoUb.d.mts}

@@ -1,4 +1,4 @@
-import { q as MutationApplied, B as BestPracticeAdvisory, F as FallbackReason, m as CallAttempt } from './ir-DubC20e3.mjs';
+import { q as MutationApplied, B as BestPracticeAdvisory, F as FallbackReason, m as CallAttempt } from './ir-BAAHLfFL.mjs';
 
 /**
  * Glass-Box observability types (alpha.17).