@warmdrift/kgauto-compiler 2.0.0-alpha.32 → 2.0.0-alpha.34

package/dist/index.js

@@ -33,6 +33,7 @@ __export(index_exports, {
   TRANSLATOR_FLOOR: () => TRANSLATOR_FLOOR,
   allProfiles: () => allProfiles,
   applySectionRewrites: () => applySectionRewrites,
+  attachCacheControlToStreamTextInput: () => attachCacheControlToStreamTextInput,
   bucketContext: () => bucketContext,
   bucketHistory: () => bucketHistory,
   bucketToolCount: () => bucketToolCount,
@@ -2771,6 +2772,9 @@ function compile(ir, opts = {}) {
   const handle = makeHandle();
   const finalShape = computeShape(workingIR, inputTokens);
   const _learningKey = learningKey(ir.intent.archetype, profile.id, finalShape);
+  const historyCacheMarkIndex = computeHistoryCacheMarkIndex(workingIR);
+  const systemMessages = buildSystemMessages(workingIR, profile.provider);
+  const systemCacheMarkIndex = lastCacheableSystemIndex(systemMessages);
   const diagnostics = {
     sectionsKept: workingIR.sections.length,
     sectionsDropped: ir.sections.length - workingIR.sections.length,
@@ -2784,7 +2788,10 @@ function compile(ir, opts = {}) {
     historyTokensTotal: compressed.historyTokensTotal,
     // alpha.20 E3: mirror the consumer's declared mode for Glass-Box +
     // brain observability. Undefined when not declared (pre-alpha.20).
-    toolOrchestration: ir.constraints?.toolOrchestration
+    toolOrchestration: ir.constraints?.toolOrchestration,
+    // alpha.33 — see top-of-block comment.
+    historyCacheMarkIndex,
+    systemCacheMarkIndex
   };
   if (ir.intent.archetype === "hunt" && ir.constraints?.toolOrchestration === "sequential") {
     accumulatedMutations.push({
@@ -2834,9 +2841,45 @@ function compile(ir, opts = {}) {
     advisories,
     diagnostics,
     sectionRewritesApplied,
-    wireOverrides
+    wireOverrides,
+    systemMessages
   };
 }
+function computeHistoryCacheMarkIndex(ir) {
+  const policy = ir.historyCachePolicy;
+  if (!policy || policy.strategy === "none") return void 0;
+  const historyLen = ir.history?.length ?? 0;
+  if (historyLen === 0) return void 0;
+  if (policy.strategy === "all-but-latest") {
+    return historyLen - 1;
+  }
+  if (policy.strategy === "fixed-suffix") {
+    const idx = historyLen - 1 - policy.suffix;
+    if (idx < 0) return void 0;
+    return idx;
+  }
+  return void 0;
+}
+function buildSystemMessages(ir, provider) {
+  const sections = ir.sections;
+  if (!sections || sections.length === 0) return [];
+  return sections.map((s) => {
+    const base = { role: "system", content: s.text };
+    if (provider === "anthropic" && s.cacheable) {
+      base.providerOptions = { anthropic: { cacheControl: { type: "ephemeral" } } };
+    }
+    return base;
+  });
+}
+function lastCacheableSystemIndex(systemMessages) {
+  for (let i = systemMessages.length - 1; i >= 0; i--) {
+    const entry = systemMessages[i];
+    if (entry && entry.providerOptions?.anthropic?.cacheControl) {
+      return i;
+    }
+  }
+  return void 0;
+}
 function validateIR(ir) {
   if (!ir.appId) throw new Error("compile(): ir.appId is required");
   if (!ir.intent || !ir.intent.archetype) {
@@ -3318,8 +3361,295 @@ function getReachabilityDiagnostic(opts = {}) {
   return out;
 }
 
-// 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 = {}) {
@@ -3344,12 +3674,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,
@@ -3360,9 +3696,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) {
@@ -3396,9 +3732,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) {
@@ -3425,6 +3761,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;
@@ -3437,9 +3779,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) {
@@ -3447,6 +3789,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;
@@ -3459,9 +3807,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) {
@@ -3471,7 +3819,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 = {
@@ -3488,8 +3836,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 };
   }
@@ -3510,7 +3858,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") {
@@ -3523,10 +3871,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);
@@ -3581,7 +3929,8 @@ var STARTER_CHAINS_GROUNDED = {
     { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reasoning + cost balance \u2014 engineer pick" },
     { id: "claude-opus-4-7", grounding: "judgment", reason: 'Same-provider walk-UP on 429 (rare exception to "always cheaper")' },
     { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
-    { id: "deepseek-v4-pro", grounding: "judgment", reason: "Tier 3 cost floor \u2014 no brain evidence yet" }
+    { id: "deepseek-v4-pro", grounding: "judgment", reason: "Tier 3 cost floor \u2014 no brain evidence yet" },
+    { id: "gpt-5.4", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=7) \u2014 closes openai-in-default-fallback-chains" }
   ],
   // Quality + cost match.
   generate: [
@@ -3612,7 +3961,8 @@ var STARTER_CHAINS_GROUNDED = {
     { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality anchor \u2014 engineer pick" },
     { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
     { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
-    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost floor \u2014 forgiving archetype tolerates Flash" }
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost floor \u2014 forgiving archetype tolerates Flash" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=7) \u2014 closes openai-in-default-fallback-chains" }
   ],
   // Parallel-tool throughput champion — Flash leads on the L-040 cliff
   // (capability-fact: Flash 15-75 parallel calls/step vs DeepSeek 7-8).
@@ -3620,21 +3970,24 @@ var STARTER_CHAINS_GROUNDED = {
     { id: "gemini-2.5-flash", grounding: "capability-fact", reason: "L-040 parallel-tool throughput champion (15-75 calls/step)" },
     { id: "gemini-2.5-pro", grounding: "capability-fact", reason: "Cross-provider tier 1 with strong parallel-tool support" },
     { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality safety net for blocked-Flash case" },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Reduced tool budget \u2014 cliff at 16 fires" }
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Reduced tool budget \u2014 cliff at 16 fires" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.33: third-provider tail \u2014 OpenAI parallel-tool capable archetype" }
   ],
   // Cost-sensitive + tolerant. DeepSeek brain-evidence tier 1.
   summarize: [
     { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
     { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 for cost-sensitive summarize workloads", n: 169 },
     { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
-    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Emergency floor \u2014 onboarded s22, no brain evidence yet" }
+    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Emergency floor \u2014 onboarded s22, no brain evidence yet" },
+    { id: "gpt-5.4-nano", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=6) \u2014 cheapest OpenAI, matches summarize cost-band" }
   ],
   // Brain-validated DeepSeek tier 1 (169 rows, 0% empty rate).
   classify: [
     { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
     { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 (169 rows, 0% empty rate)", n: 169 },
     { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
-    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Cache-discount 10\xD7 floor for repeat-prompt workloads" }
+    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Cache-discount 10\xD7 floor for repeat-prompt workloads" },
+    { id: "gpt-5.4-nano", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=6) \u2014 cheapest OpenAI for classify" }
   ]
 };
 var STARTER_CHAINS = (() => {
@@ -3689,7 +4042,7 @@ function resolveStarterForMode(archetype, toolOrchestration, allChains) {
   return allChains[archetype];
 }
 function getDefaultFallbackChain(opts) {
-  const { archetype, primary, maxDepth = 3, policy, reachability, toolOrchestration } = opts;
+  const { archetype, primary, maxDepth = 4, policy, reachability, toolOrchestration } = opts;
   if (maxDepth < 1) {
     throw new Error(
       `getDefaultFallbackChain: maxDepth must be >= 1, got ${maxDepth}`
@@ -4335,10 +4688,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) {
@@ -4521,6 +4877,34 @@ function safeEmit(fn) {
   }
 }
 
+// src/streamtext-helpers.ts
+function attachCacheControlToStreamTextInput(result, convertedMessages) {
+  const messages = convertedMessages.map((m) => ({ ...m }));
+  const markIdx = result.diagnostics.historyCacheMarkIndex;
+  if (result.provider === "anthropic" && typeof markIdx === "number" && markIdx >= 0 && markIdx < messages.length) {
+    const target = messages[markIdx];
+    if (target) {
+      messages[markIdx] = {
+        role: target.role,
+        content: target.content,
+        providerOptions: {
+          ...target.providerOptions ?? {},
+          anthropic: {
+            ...target.providerOptions?.anthropic ?? {},
+            cacheControl: { type: "ephemeral" }
+          }
+        }
+      };
+    }
+  }
+  const systemMessages = result.systemMessages;
+  const hasStructuredSystemCacheControl = result.provider === "anthropic" && systemMessages.some(
+    (m) => m.providerOptions?.anthropic?.cacheControl !== void 0
+  );
+  const system = hasStructuredSystemCacheControl ? systemMessages : systemMessages.map((m) => m.content).join("\n\n");
+  return { system, messages };
+}
+
 // src/oracle.ts
 var DEFAULT_DIMENSIONS = ["correctness", "completeness", "conciseness", "format"];
 var judgeCallTimes = [];
@@ -5021,6 +5405,7 @@ function compile2(ir, opts) {
   TRANSLATOR_FLOOR,
   allProfiles,
   applySectionRewrites,
+  attachCacheControlToStreamTextInput,
   bucketContext,
   bucketHistory,
   bucketToolCount,