@tangle-network/agent-app 0.6.0 → 0.7.1

package/dist/{chunk-EO4IGDQD.js → chunk-4YTWB5MG.js}

@@ -2,7 +2,7 @@ import {
   buildAppToolOpenAITools,
   createAppToolRuntimeExecutor,
   isAppToolName
-} from "./chunk-JANT2G2E.js";
+} from "./chunk-QAQBR6KQ.js";
 
 // src/runtime/model-catalog.ts
 var PROVIDER_TIER = [
@@ -326,13 +326,20 @@ function assistantToolCallMessage(turnText, pending) {
 function toolResultMessage(call, content) {
   return { role: "tool", tool_call_id: toolCallId(call), content };
 }
-var DEFAULT_MAX_TOOL_TURNS = 8;
+var RUNAWAY_BACKSTOP_TURNS = 200;
+var STUCK_LOOP_THRESHOLD = 3;
+function canonicalCallHash(call) {
+  const sortedArgs = Object.fromEntries(
+    Object.entries(call.args).sort(([a], [b]) => a.localeCompare(b))
+  );
+  return `${call.toolName}:${JSON.stringify(sortedArgs)}`;
+}
 function defaultRender(label, outcome) {
   if (outcome.ok) return `${label} \u2192 ok: ${JSON.stringify(outcome.result)}`;
   return `${label} \u2192 failed (${outcome.code}): ${outcome.message}`;
 }
 async function runAppToolLoop(opts) {
-  const maxTurns = opts.maxToolTurns ?? DEFAULT_MAX_TOOL_TURNS;
+  const backstop = opts.maxToolTurns ?? RUNAWAY_BACKSTOP_TURNS;
   const render = opts.renderResult ?? defaultRender;
   const labelFor = opts.labelFor ?? ((c) => c.toolName);
   const messages = [
@@ -343,8 +350,14 @@ async function runAppToolLoop(opts) {
   const toolResults = [];
   let finalText = "";
   let turns = 0;
+  let accumulatedCostUsd = 0;
+  let lastCallHash = null;
+  let consecutiveCount = 0;
   for (let toolTurn = 0; ; toolTurn++) {
     turns++;
+    if (opts.deadlineMs !== void 0 && Date.now() >= opts.deadlineMs) {
+      return { finalText, toolResults, turns, stopReason: "deadline", cappedOut: true };
+    }
     let turnText = "";
     const pending = [];
     for await (const ev of opts.streamTurn([...messages])) {
@@ -356,26 +369,45 @@ async function runAppToolLoop(opts) {
       }
     }
     if (pending.length === 0) break;
-    if (toolTurn >= maxTurns) {
-      return { finalText, toolResults, turns, cappedOut: true };
+    if (toolTurn >= backstop) {
+      return { finalText, toolResults, turns, stopReason: "backstop", cappedOut: true };
     }
     messages.push(assistantToolCallMessage(turnText, pending));
     for (const call of pending) {
+      const callHash = canonicalCallHash(call);
+      if (callHash === lastCallHash) {
+        consecutiveCount++;
+      } else {
+        lastCallHash = callHash;
+        consecutiveCount = 1;
+      }
+      if (consecutiveCount >= STUCK_LOOP_THRESHOLD) {
+        return { finalText, toolResults, turns, stopReason: "stuck-loop", cappedOut: true };
+      }
       let outcome;
       try {
         outcome = await opts.executeToolCall(call);
       } catch (err) {
         outcome = { ok: false, code: "executor_error", message: err instanceof Error ? err.message : String(err) };
       }
+      if (opts.maxCostUsd !== void 0 && opts.costOf !== void 0) {
+        accumulatedCostUsd += opts.costOf(call, outcome);
+        if (accumulatedCostUsd >= opts.maxCostUsd) {
+          const label2 = labelFor(call);
+          toolResults.push({ call, label: label2, outcome });
+          messages.push(toolResultMessage(call, render(label2, outcome)));
+          return { finalText, toolResults, turns, stopReason: "budget", cappedOut: true };
+        }
+      }
       const label = labelFor(call);
       toolResults.push({ call, label, outcome });
       messages.push(toolResultMessage(call, render(label, outcome)));
     }
   }
-  return { finalText, toolResults, turns, cappedOut: false };
+  return { finalText, toolResults, turns, stopReason: "completed", cappedOut: false };
 }
 async function* streamAppToolLoop(opts) {
-  const maxTurns = opts.maxToolTurns ?? DEFAULT_MAX_TOOL_TURNS;
+  const backstop = opts.maxToolTurns ?? RUNAWAY_BACKSTOP_TURNS;
   const render = opts.renderResult ?? defaultRender;
   const labelFor = opts.labelFor ?? ((c) => c.toolName);
   const messages = [
@@ -383,7 +415,14 @@ async function* streamAppToolLoop(opts) {
     ...opts.priorMessages ?? [],
     { role: "user", content: opts.userMessage }
   ];
+  let accumulatedCostUsd = 0;
+  let lastCallHash = null;
+  let consecutiveCount = 0;
   for (let toolTurn = 0; ; toolTurn++) {
+    if (opts.deadlineMs !== void 0 && Date.now() >= opts.deadlineMs) {
+      yield { kind: "capped", pending: 0, stopReason: "deadline" };
+      return;
+    }
     let turnText = "";
     const pending = [];
     for await (const event of opts.streamTurn([...messages])) {
@@ -393,18 +432,39 @@ async function* streamAppToolLoop(opts) {
       if (call && opts.isExecutableTool(call.toolName)) pending.push(call);
     }
     if (pending.length === 0) return;
-    if (toolTurn >= maxTurns) {
-      yield { kind: "capped", pending: pending.length };
+    if (toolTurn >= backstop) {
+      yield { kind: "capped", pending: pending.length, stopReason: "backstop" };
       return;
     }
     messages.push(assistantToolCallMessage(turnText, pending));
     for (const call of pending) {
+      const callHash = canonicalCallHash(call);
+      if (callHash === lastCallHash) {
+        consecutiveCount++;
+      } else {
+        lastCallHash = callHash;
+        consecutiveCount = 1;
+      }
+      if (consecutiveCount >= STUCK_LOOP_THRESHOLD) {
+        yield { kind: "capped", pending: pending.length, stopReason: "stuck-loop" };
+        return;
+      }
       let outcome;
       try {
         outcome = await opts.executeToolCall(call);
       } catch (err) {
         outcome = { ok: false, code: "executor_error", message: err instanceof Error ? err.message : String(err) };
       }
+      if (opts.maxCostUsd !== void 0 && opts.costOf !== void 0) {
+        accumulatedCostUsd += opts.costOf(call, outcome);
+        if (accumulatedCostUsd >= opts.maxCostUsd) {
+          const label2 = labelFor(call);
+          yield { kind: "tool_result", toolName: call.toolName, toolCallId: call.toolCallId, label: label2, outcome };
+          messages.push(toolResultMessage(call, render(label2, outcome)));
+          yield { kind: "capped", pending: pending.length, stopReason: "budget" };
+          return;
+        }
+      }
       const label = labelFor(call);
       yield { kind: "tool_result", toolName: call.toolName, toolCallId: call.toolCallId, label, outcome };
       messages.push(toolResultMessage(call, render(label, outcome)));
@@ -423,4 +483,4 @@ export {
   runAppToolLoop,
   streamAppToolLoop
 };
-//# sourceMappingURL=chunk-EO4IGDQD.js.map
+//# sourceMappingURL=chunk-4YTWB5MG.js.map

package/dist/chunk-4YTWB5MG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime/model-catalog.ts","../src/runtime/openai-stream.ts","../src/runtime/agent.ts","../src/runtime/index.ts"],"sourcesContent":["/**\n * Model catalogue — computed live from the Tangle Router, never hand-curated.\n * Lifted from tuner-agent so every agent app's model picker shares one\n * filter/dedupe/rank/feature pipeline instead of re-deriving it.\n *\n * The router's /models endpoint returns every routeable model (~200), which is\n * unusable as a picker list: it mixes chat models with TTS/embedding/realtime\n * endpoints, dated snapshots alias their parents, and provider-prefixed ids\n * duplicate canonical ones. This module turns that into a product catalogue:\n *\n *   filter (chat-capable, routeable) → dedupe (snapshot/prefix/:free aliases)\n *   → rank (provider tier, family, version) → feature (best model per family)\n *   → default (env override or first featured)\n *\n * Freshness is automatic: everything is derived from the live router response,\n * so new models surface as soon as the router lists them. The only static\n * knowledge here is slow-moving: provider display order and family name\n * patterns (e.g. \"claude-sonnet-*\", \"gpt-N\"). A new Sonnet or GPT release\n * outranks its predecessor by version comparison with zero code change; only\n * a brand-new *family name* (rare) needs a one-line rule addition.\n */\n\nexport interface RouterModel {\n  id: string\n  name?: string\n  description?: string\n  _provider?: string\n  pricing?: { prompt?: string | null; completion?: string | null }\n  context_length?: number\n  architecture?: {\n    modality?: string\n    input_modalities?: string[]\n    output_modalities?: string[]\n  }\n  supported_parameters?: string[]\n  routeability?: {\n    status?: string\n    routeable?: boolean\n    provider?: string\n  }\n}\n\nexport interface CatalogModel {\n  id: string\n  name: string\n  provider: string\n  description?: string\n  contextLength?: number\n  pricing?: { prompt?: string; completion?: string }\n  supportsTools: boolean\n  supportsReasoning: boolean\n  featured: boolean\n}\n\nexport interface ModelCatalog {\n  defaultModelId: string | null\n  fetchedAt: string\n  models: CatalogModel[]\n}\n\n/** Display order. Unlisted providers sort after these, alphabetically. */\nconst PROVIDER_TIER: string[] = [\n  'anthropic',\n  'openai',\n  'google',\n  'xai',\n  'deepseek',\n  'moonshotai',\n  'moonshot',\n  'zai',\n  'z-ai',\n  'mistral',\n  'groq',\n  'nvidia',\n  'cohere',\n  'cerebras',\n]\n\n/** Non-chat endpoints that pollute the router list (matched on normalized id). */\nconst EXCLUDED_ID = /(embedding|tts|transcribe|whisper|audio|realtime|image|lyria|sora|dall-e|moderation|content-safety|search-preview|search-api|deep-research)/\n\n/**\n * Featured families, in display order. Each rule surfaces the highest-version\n * routeable model whose normalized id matches. Patterns anchor on the family\n * name and stop before specialty suffixes (codex, nano, lite, …) so the\n * mainline model wins.\n */\nconst FEATURED_RULES: Array<{ providers: string[]; match: RegExp }> = [\n  { providers: ['anthropic'], match: /^claude-sonnet-[\\d-]+$/ },\n  { providers: ['anthropic'], match: /^claude-opus-[\\d-]+$/ },\n  { providers: ['anthropic'], match: /^claude-haiku-[\\d-]+$/ },\n  { providers: ['openai'], match: /^gpt-\\d+(\\.\\d+)?$/ },\n  { providers: ['openai'], match: /^gpt-\\d+(\\.\\d+)?-mini$/ },\n  { providers: ['google'], match: /^gemini-[\\d.]+-pro(-preview)?$/ },\n  { providers: ['google'], match: /^gemini-[\\d.]+-flash(-preview)?$/ },\n  { providers: ['xai'], match: /^grok-[\\d.]+$/ },\n  { providers: ['deepseek'], match: /^deepseek-(chat|v[\\d.]+(-\\w+)?)$/ },\n  { providers: ['moonshotai', 'moonshot'], match: /^kimi-k[\\d.]+$/ },\n  { providers: ['zai', 'z-ai'], match: /^glm-[\\d.]+$/ },\n  { providers: ['mistral'], match: /^mistral-(large|medium)-?[\\d.-]*$/ },\n]\n\n/** Families known to support tool calls even when router metadata omits it\n *  (dated snapshots often lack the supported_parameters of their parent). */\nconst TOOL_CAPABLE_FAMILY = /^(claude|gpt-[45]|gpt-oss|o[134]|gemini|grok|deepseek|glm|kimi|mistral|ministral|magistral|command|nemotron|llama)/\n\n/** Strip provider prefix, :free suffix, and trailing date stamps. */\nexport function normalizeModelId(id: string): string {\n  let tail = id.split('/').pop() ?? id\n  tail = tail.replace(/:free$/, '')\n  tail = tail.replace(/-\\d{8}$/, '')\n  tail = tail.replace(/-\\d{4}-\\d{2}-\\d{2}$/, '')\n  return tail\n}\n\n/** All numeric groups in a normalized id, for version comparison. */\nfunction versionOf(normId: string): number[] {\n  return (normId.match(/\\d+/g) ?? []).map(Number)\n}\n\nfunction compareVersions(a: number[], b: number[]): number {\n  const len = Math.max(a.length, b.length)\n  for (let i = 0; i < len; i++) {\n    const d = (a[i] ?? -1) - (b[i] ?? -1)\n    if (d !== 0) return d\n  }\n  return 0\n}\n\n/** Lower = preferred representative for an alias group. */\nfunction aliasPenalty(id: string): number {\n  let p = 0\n  if (id.includes('/')) p += 4\n  if (/-\\d{8}$|-\\d{4}-\\d{2}-\\d{2}$/.test(id.replace(/:free$/, ''))) p += 2\n  if (id.endsWith(':free')) p += 1\n  return p\n}\n\nfunction providerRank(provider: string): number {\n  const i = PROVIDER_TIER.indexOf(provider)\n  return i === -1 ? PROVIDER_TIER.length : i\n}\n\nfunction isChatModel(m: RouterModel): boolean {\n  const arch = m.architecture\n  if (!arch?.input_modalities || !arch?.output_modalities) return true\n  return arch.input_modalities.includes('text') && arch.output_modalities.includes('text')\n}\n\nfunction isRouteable(m: RouterModel): boolean {\n  return m.routeability?.routeable !== false && m.routeability?.status !== 'unavailable'\n}\n\nfunction familyOf(normId: string): string {\n  return normId.replace(/[\\d.]+/g, '').replace(/-+/g, '-').replace(/-$/, '')\n}\n\n/**\n * Pure catalogue pipeline. `preferredDefault` (typically the MODEL_NAME env\n * var) wins when it survives filtering; otherwise the first featured model.\n */\nexport function buildCatalog(raw: RouterModel[], opts?: { preferredDefault?: string }): ModelCatalog {\n  // Filter to chat-capable, routeable, non-specialty models\n  const candidates = raw.filter(\n    (m) => m.id && isRouteable(m) && isChatModel(m) && !EXCLUDED_ID.test(normalizeModelId(m.id)),\n  )\n\n  // Dedupe alias groups (dated snapshots, provider prefixes, :free variants).\n  // Within a group, merge metadata so the representative keeps the richest\n  // supported_parameters claim (snapshots often omit what the parent lists).\n  const groups = new Map<string, RouterModel[]>()\n  for (const m of candidates) {\n    const key = `${m._provider ?? ''}::${normalizeModelId(m.id)}`\n    const g = groups.get(key)\n    if (g) g.push(m)\n    else groups.set(key, [m])\n  }\n\n  const reps: Array<{ model: RouterModel; normId: string; mergedParams: Set<string> }> = []\n  for (const group of groups.values()) {\n    group.sort((a, b) => aliasPenalty(a.id) - aliasPenalty(b.id) || a.id.length - b.id.length)\n    const rep = group[0]!\n    const mergedParams = new Set<string>(group.flatMap((m) => m.supported_parameters ?? []))\n    reps.push({ model: rep, normId: normalizeModelId(rep.id), mergedParams })\n  }\n\n  // Featured: best version per family rule, in rule order\n  const featuredIds: string[] = []\n  for (const rule of FEATURED_RULES) {\n    const matches = reps.filter(\n      (r) =>\n        rule.providers.includes(r.model._provider ?? '') &&\n        rule.match.test(r.normId) &&\n        !featuredIds.includes(r.model.id),\n    )\n    if (!matches.length) continue\n    matches.sort(\n      (a, b) =>\n        compareVersions(versionOf(b.normId), versionOf(a.normId)) ||\n        Number(a.normId.includes('preview')) - Number(b.normId.includes('preview')) ||\n        a.model.id.length - b.model.id.length,\n    )\n    featuredIds.push(matches[0]!.model.id)\n  }\n\n  const toCatalogModel = (r: (typeof reps)[number]): CatalogModel => {\n    const m = r.model\n    const provider = m._provider ?? 'unknown'\n    return {\n      id: m.id,\n      name: m.name ?? m.id,\n      provider,\n      description: m.description ? m.description.slice(0, 160) : undefined,\n      contextLength: m.context_length,\n      pricing:\n        m.pricing?.prompt || m.pricing?.completion\n          ? { prompt: m.pricing.prompt ?? undefined, completion: m.pricing.completion ?? undefined }\n          : undefined,\n      supportsTools: r.mergedParams.has('tools') || TOOL_CAPABLE_FAMILY.test(r.normId),\n      supportsReasoning: r.mergedParams.has('reasoning') || r.mergedParams.has('include_reasoning'),\n      featured: featuredIds.includes(m.id),\n    }\n  }\n\n  // Sort: featured first (rule order), then provider tier → family → version desc\n  const featured = featuredIds\n    .map((id) => reps.find((r) => r.model.id === id)!)\n    .map(toCatalogModel)\n  const rest = reps\n    .filter((r) => !featuredIds.includes(r.model.id))\n    .sort((a, b) => {\n      const pa = providerRank(a.model._provider ?? '')\n      const pb = providerRank(b.model._provider ?? '')\n      if (pa !== pb) return pa - pb\n      const fa = familyOf(a.normId)\n      const fb = familyOf(b.normId)\n      if (fa !== fb) return fa.localeCompare(fb)\n      return compareVersions(versionOf(b.normId), versionOf(a.normId)) || a.model.id.localeCompare(b.model.id)\n    })\n    .map(toCatalogModel)\n\n  const models = [...featured, ...rest]\n\n  const preferred = opts?.preferredDefault\n  const defaultModelId =\n    (preferred && models.find((m) => m.id === preferred || normalizeModelId(m.id) === normalizeModelId(preferred))?.id) ||\n    featured.find((m) => m.supportsTools)?.id ||\n    models[0]?.id ||\n    null\n\n  return { defaultModelId, fetchedAt: new Date().toISOString(), models }\n}\n\n// ── Cached fetch ─────────────────────────────────────────────────────────\n\nconst CATALOG_TTL_MS = 5 * 60 * 1000\n\nlet _cache: { catalog: ModelCatalog; at: number } | null = null\n\n/**\n * Fetch the router model list and build the catalogue, with an in-isolate\n * cache (TTL 5 min). On router failure a stale catalogue is served rather\n * than erroring the picker.\n */\nexport async function fetchModelCatalog(cfg: {\n  baseUrl: string\n  apiKey: string\n  preferredDefault?: string\n}): Promise<ModelCatalog> {\n  if (_cache && Date.now() - _cache.at < CATALOG_TTL_MS) {\n    return _cache.catalog\n  }\n  try {\n    const res = await fetch(`${cfg.baseUrl}/models`, {\n      headers: { Authorization: `Bearer ${cfg.apiKey}` },\n    })\n    if (!res.ok) throw new Error(`Router /models returned ${res.status}`)\n    const data = (await res.json()) as { data?: RouterModel[] }\n    const catalog = buildCatalog(data.data ?? [], { preferredDefault: cfg.preferredDefault })\n    _cache = { catalog, at: Date.now() }\n    return catalog\n  } catch (err) {\n    if (_cache) return _cache.catalog\n    throw err\n  }\n}\n\n/** Test-only: clear the catalogue cache. */\nexport function __resetCatalogCache(): void {\n  _cache = null\n}\n","/**\n * OpenAI-compatible stream → `LoopEvent` adapter, for NON-sandbox copilots.\n *\n * `streamAppToolLoop` takes a `streamTurn` seam that yields `LoopEvent`s. A\n * sandboxed agent produces those from its container; a browser/edge copilot\n * instead calls a model directly. The Tangle Router, the tcloud SDK, and most\n * providers all speak the OpenAI Chat Completions streaming shape — so the ONE\n * reusable piece is assembling that stream (content deltas + FRAGMENTED\n * tool-call deltas) into `LoopEvent`s. That assembly is the boilerplate every\n * copilot would re-write (and get wrong — OpenAI streams tool-call arguments in\n * pieces across chunks).\n *\n * This does NOT implement an HTTP client beyond a minimal `fetch` + SSE reader\n * (browser/edge/Node-safe, zero deps). For richer transport use the tcloud SDK\n * or the Vercel AI SDK and pipe their stream through {@link toLoopEvents}.\n */\nimport type { LoopEvent, LoopMessage, LoopToolCall } from './index'\n\n/** Minimal OpenAI Chat Completions streaming chunk (structural — no `openai` dep). */\nexport interface OpenAIStreamChunk {\n  choices?: Array<{\n    delta?: {\n      content?: string | null\n      /** Reasoning deltas — DeepSeek/router use `reasoning_content`; some proxies use `thinking`. */\n      reasoning_content?: string | null\n      thinking?: string | null\n      tool_calls?: Array<{\n        index: number\n        id?: string\n        function?: { name?: string; arguments?: string }\n      }>\n    }\n    finish_reason?: string | null\n  }>\n  /** Final-chunk token accounting (requires `stream_options.include_usage`). */\n  usage?: {\n    prompt_tokens?: number\n    completion_tokens?: number\n  } | null\n}\n\ninterface PartialToolCall {\n  id?: string\n  name: string\n  args: string\n}\n\n/**\n * Map an OpenAI-compat streaming chunk iterator to `LoopEvent`s: each content\n * delta → a `text` event; tool-call deltas are accumulated by index across\n * chunks and emitted as one complete `tool_call` event when the stream finishes\n * (arguments JSON-parsed; an empty/garbled args string yields `{}` rather than\n * throwing). Works for the Tangle Router, tcloud, or any OpenAI-compat source.\n */\nexport async function* toLoopEvents(chunks: AsyncIterable<OpenAIStreamChunk>): AsyncIterable<LoopEvent> {\n  const calls = new Map<number, PartialToolCall>()\n  for await (const chunk of chunks) {\n    // Usage rides the final chunk, which has an empty choices array — handle\n    // it before the choice guard.\n    if (chunk.usage?.prompt_tokens != null || chunk.usage?.completion_tokens != null) {\n      yield {\n        type: 'usage',\n        usage: {\n          promptTokens: chunk.usage.prompt_tokens ?? 0,\n          completionTokens: chunk.usage.completion_tokens ?? 0,\n        },\n      }\n    }\n    const choice = chunk.choices?.[0]\n    if (!choice) continue\n    const content = choice.delta?.content\n    if (content) yield { type: 'text', text: content }\n    const reasoning = choice.delta?.reasoning_content ?? choice.delta?.thinking\n    if (reasoning) yield { type: 'reasoning', text: reasoning }\n    for (const tc of choice.delta?.tool_calls ?? []) {\n      const cur = calls.get(tc.index) ?? { name: '', args: '' }\n      if (tc.id) cur.id = tc.id\n      if (tc.function?.name) cur.name += tc.function.name\n      if (tc.function?.arguments) cur.args += tc.function.arguments\n      calls.set(tc.index, cur)\n    }\n  }\n  for (const [, c] of [...calls.entries()].sort((a, b) => a[0] - b[0])) {\n    if (!c.name) continue\n    yield { type: 'tool_call', call: { toolCallId: c.id, toolName: c.name, args: safeParse(c.args) } satisfies LoopToolCall }\n  }\n}\n\nfunction safeParse(s: string): Record<string, unknown> {\n  if (!s.trim()) return {}\n  try {\n    const v = JSON.parse(s)\n    return v && typeof v === 'object' && !Array.isArray(v) ? (v as Record<string, unknown>) : {}\n  } catch {\n    return {}\n  }\n}\n\nexport interface OpenAICompatStreamTurnOptions {\n  /** OpenAI-compat base URL (e.g. the Tangle Router `https://router.tangle.tools/v1`). */\n  baseUrl: string\n  apiKey: string\n  model: string\n  /** OpenAI tool definitions — pass `buildAppToolOpenAITools(taxonomy)` so the\n   *  model can call the app tools. Omit for a tool-free copilot. */\n  tools?: unknown[]\n  temperature?: number\n  fetchImpl?: typeof fetch\n  /** Extra body fields (e.g. `max_tokens`). */\n  extraBody?: Record<string, unknown>\n}\n\n/**\n * Build a `streamTurn` that calls an OpenAI-compatible `/chat/completions`\n * endpoint (Tangle Router / tcloud / any compat provider) with `stream: true`\n * and yields `LoopEvent`s via {@link toLoopEvents}. Browser/edge/Node-safe —\n * just `fetch` + an SSE reader. Drop straight into `streamAppToolLoop`:\n *\n *   const cfg = resolveTangleModelConfig()                 // or { baseUrl, apiKey, model }\n *   streamAppToolLoop({ streamTurn: createOpenAICompatStreamTurn({ ...cfg, tools }), executeToolCall, ... })\n */\nexport function createOpenAICompatStreamTurn(\n  opts: OpenAICompatStreamTurnOptions,\n): (messages: LoopMessage[]) => AsyncIterable<LoopEvent> {\n  const base = opts.baseUrl.replace(/\\/+$/, '')\n  const doFetch = opts.fetchImpl ?? fetch\n  return (messages) =>\n    toLoopEvents(\n      streamChatCompletions(doFetch, `${base}/chat/completions`, opts.apiKey, {\n        model: opts.model,\n        messages,\n        stream: true,\n        stream_options: { include_usage: true },\n        ...(opts.tools && opts.tools.length > 0 ? { tools: opts.tools } : {}),\n        ...(opts.temperature != null ? { temperature: opts.temperature } : {}),\n        ...opts.extraBody,\n      }),\n    )\n}\n\n/** Stream + parse an OpenAI-compat SSE response into chunks. Tolerates `data:`\n *  framing, multi-line buffers, and the terminal `[DONE]`. */\nasync function* streamChatCompletions(\n  doFetch: typeof fetch,\n  url: string,\n  apiKey: string,\n  body: Record<string, unknown>,\n): AsyncIterable<OpenAIStreamChunk> {\n  const res = await doFetch(url, {\n    method: 'POST',\n    headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json', Accept: 'text/event-stream' },\n    body: JSON.stringify(body),\n  })\n  if (!res.ok || !res.body) {\n    const text = res.body ? await res.text().catch(() => '') : ''\n    throw new Error(`OpenAI-compat stream failed (HTTP ${res.status})${text ? `: ${text.slice(0, 200)}` : ''}`)\n  }\n  const reader = res.body.getReader()\n  const decoder = new TextDecoder()\n  let buffer = ''\n  for (;;) {\n    const { done, value } = await reader.read()\n    if (done) break\n    buffer += decoder.decode(value, { stream: true })\n    const lines = buffer.split('\\n')\n    buffer = lines.pop() ?? ''\n    for (const line of lines) {\n      const trimmed = line.trim()\n      if (!trimmed.startsWith('data:')) continue\n      const data = trimmed.slice(5).trim()\n      if (data === '[DONE]') return\n      try {\n        yield JSON.parse(data) as OpenAIStreamChunk\n      } catch {\n        /* skip a partial/garbled SSE frame */\n      }\n    }\n  }\n}\n","/**\n * `createAgentRuntime` — the in-process agent core, assembled.\n *\n * The bricks to run an agent turn WITHOUT a sandbox already exist in this\n * package, but a consumer must hand-wire five of them every time: resolve the\n * model config, build the OpenAI tool schemas from the taxonomy, build a\n * `streamTurn` over the model endpoint, build an `executeToolCall` over the\n * product's handlers, and drive `runAppToolLoop` / `streamAppToolLoop` with an\n * `isExecutableTool` predicate. That boilerplate is identical across every\n * sandbox-free surface (an edge/browser copilot, an eval harness, a Node CLI),\n * and getting it subtly wrong — e.g. NOT advertising the tools, so the model\n * never emits a `tool_call` and no side effect ever fires — is exactly the\n * failure that makes a tool-driven agent score zero off-sandbox.\n *\n * This factory bundles those five into one object configured for ONE agent:\n *\n *   const runtime = createAgentRuntime({ model, taxonomy, handlers, systemPrompt })\n *   const result = await runtime.run(userMessage, { ctx })            // awaitable\n *   for await (const y of runtime.stream(userMessage, { ctx })) {…}   // streaming\n *\n * The model is advertised the app tools (so it CAN call them); each call is\n * dispatched against the product's `handlers` (so the side effect is real); the\n * `onProduced` hook fires at the real side-effect site (so an eval/UI credits a\n * persisted proposal or artifact). Substrate-free: no `@tangle-network/sandbox`,\n * no Durable Object, no `@tangle-network/agent-runtime` import. The SAME core\n * the Cloudflare Worker runs, runnable anywhere a `fetch` to an OpenAI-compatible\n * endpoint works.\n *\n * Domain stays out: the proposal taxonomy, the handlers, and the system prompt\n * are all injected — the factory knows nothing about insurance, law, tax, etc.\n */\nimport {\n  type AppToolHandlers,\n  type AppToolContext,\n  type AppToolOutcome,\n  type AppToolProducedEvent,\n  type AppToolTaxonomy,\n} from '../tools/types'\nimport { buildAppToolOpenAITools, isAppToolName } from '../tools/openai'\nimport { createAppToolRuntimeExecutor } from '../tools/runtime'\nimport {\n  runAppToolLoop,\n  streamAppToolLoop,\n  type LoopEvent,\n  type LoopToolCall,\n  type StreamLoopYield,\n  type ToolLoopResult,\n} from './index'\nimport { createOpenAICompatStreamTurn } from './openai-stream'\n\n/** OpenAI-compatible model endpoint (Tangle Router / tcloud / any compat\n *  provider). Build from {@link resolveTangleModelConfig} or pass literals. */\nexport interface AgentRuntimeModelConfig {\n  baseUrl: string\n  apiKey: string\n  model: string\n  temperature?: number\n  fetchImpl?: typeof fetch\n  /** Extra request-body fields (e.g. `max_tokens`, a `reasoning` block). */\n  extraBody?: Record<string, unknown>\n}\n\nexport interface CreateAgentRuntimeOptions {\n  /** The model endpoint the turns stream from. */\n  model: AgentRuntimeModelConfig\n  /** The product's proposal taxonomy — advertises `submit_proposal`'s `type`\n   *  enum to the model and labels the regulated subset on the result. */\n  taxonomy: AppToolTaxonomy\n  /** Domain handlers persisting each tool to the product's store/vault. */\n  handlers: AppToolHandlers\n  /** Default agent identity / system prompt. A turn may override it. */\n  systemPrompt: string\n  /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow.\n   *  For per-workflow limits use `deadlineMs` or `maxCostUsd` on the loop options. */\n  maxToolTurns?: number\n  /** Extra OpenAI tool definitions advertised ALONGSIDE the four app tools\n   *  (e.g. `integration_invoke`). Pair with {@link executeOtherTool}. */\n  extraTools?: unknown[]\n  /** Execute a tool that is NOT one of the four app tools (e.g. an integration\n   *  action). Only consulted for names {@link isOtherExecutableTool} accepts. */\n  executeOtherTool?: (call: LoopToolCall, ctx: AppToolContext) => Promise<AppToolOutcome>\n  /** Which non-app tool names are executable here. Required if {@link executeOtherTool} is set. */\n  isOtherExecutableTool?: (toolName: string) => boolean\n}\n\nexport interface AgentTurnOptions {\n  /** The trusted per-turn context (who/where the turn runs as). */\n  ctx: AppToolContext\n  /** Prior conversation turns, in order. */\n  priorMessages?: Array<{ role: string; content: string }>\n  /** Override the factory's default system prompt for this turn. */\n  systemPrompt?: string\n  /** Fires at the real side-effect site for each produced proposal/artifact. */\n  onProduced?: (event: AppToolProducedEvent) => void\n}\n\nexport interface AgentRuntime {\n  /** Run the bounded tool loop to completion; resolve with final text + every\n   *  executed tool outcome. */\n  run(userMessage: string, turn: AgentTurnOptions): Promise<ToolLoopResult>\n  /** Stream the bounded tool loop: yields each raw model event and each executed\n   *  tool result as it happens (for SSE re-emission + telemetry). */\n  stream(userMessage: string, turn: AgentTurnOptions): AsyncGenerator<StreamLoopYield<LoopEvent>, void, unknown>\n}\n\n/**\n * Create an in-process agent runtime for one agent. See the module doc for the\n * full rationale; the short version: it advertises the app tools to the model,\n * dispatches each emitted call against `handlers`, and drives the bounded loop —\n * the whole agent core, sandbox-free.\n */\nexport function createAgentRuntime(opts: CreateAgentRuntimeOptions): AgentRuntime {\n  if (opts.executeOtherTool && !opts.isOtherExecutableTool) {\n    throw new Error('createAgentRuntime: isOtherExecutableTool is required when executeOtherTool is set')\n  }\n\n  // Tool schemas + the streamTurn are stable across turns — build once. The\n  // model MUST be advertised the tools or it never emits a tool_call (the exact\n  // failure that scores a tool-driven agent zero off-sandbox).\n  const tools = [...buildAppToolOpenAITools(opts.taxonomy), ...(opts.extraTools ?? [])]\n  const m = opts.model\n  const streamTurn = createOpenAICompatStreamTurn({\n    baseUrl: m.baseUrl,\n    apiKey: m.apiKey,\n    model: m.model,\n    tools,\n    temperature: m.temperature,\n    fetchImpl: m.fetchImpl,\n    extraBody: m.extraBody,\n  })\n\n  const isExecutableTool = (name: string): boolean =>\n    isAppToolName(name) || (opts.isOtherExecutableTool?.(name) ?? false)\n\n  const buildExecutor = (turn: AgentTurnOptions) => {\n    const appExecutor = createAppToolRuntimeExecutor({\n      handlers: opts.handlers,\n      taxonomy: opts.taxonomy,\n      ctx: turn.ctx,\n      onProduced: turn.onProduced,\n    })\n    return async (call: LoopToolCall): Promise<AppToolOutcome> => {\n      if (isAppToolName(call.toolName)) return appExecutor({ toolName: call.toolName, args: call.args })\n      if (opts.executeOtherTool && opts.isOtherExecutableTool?.(call.toolName)) {\n        return opts.executeOtherTool(call, turn.ctx)\n      }\n      return { ok: false, code: 'unknown_tool', message: `No executor for tool: ${call.toolName}` }\n    }\n  }\n\n  return {\n    run(userMessage, turn) {\n      return runAppToolLoop({\n        systemPrompt: turn.systemPrompt ?? opts.systemPrompt,\n        userMessage,\n        priorMessages: turn.priorMessages,\n        streamTurn,\n        executeToolCall: buildExecutor(turn),\n        isExecutableTool,\n        maxToolTurns: opts.maxToolTurns,\n      })\n    },\n    stream(userMessage, turn) {\n      return streamAppToolLoop<LoopEvent>({\n        systemPrompt: turn.systemPrompt ?? opts.systemPrompt,\n        userMessage,\n        priorMessages: turn.priorMessages,\n        streamTurn,\n        extractText: (ev) => (ev.type === 'text' ? ev.text : ''),\n        extractToolCall: (ev) => (ev.type === 'tool_call' ? ev.call : null),\n        isExecutableTool,\n        executeToolCall: buildExecutor(turn),\n        maxToolTurns: opts.maxToolTurns,\n      })\n    },\n  }\n}\n","export * from './model-catalog'\nexport * from './model'\nexport * from './openai-stream'\nexport * from './agent'\n/**\n * The bounded agent tool-loop — the mechanism every app's chat runtime\n * hand-rolls on top of `@tangle-network/agent-runtime`.\n *\n * A model turn may emit tool calls (integration-hub actions, the app tools from\n * `../tools`, delegation). The loop: stream a turn, collect the executable tool\n * calls, stop if there are none / no executor / the turn cap is hit, otherwise\n * execute each, append the results to history in OpenAI function-calling shape,\n * and re-run so the model reads them. Bounded by `maxToolTurns` so a model\n * looping on a failing action can't run forever.\n *\n * The history shape is the OpenAI function-calling contract: the assistant turn\n * that emitted tool calls is preserved as an `assistant` message carrying its\n * `tool_calls` array, and each result is its own `{ role: 'tool', tool_call_id,\n * content }` message keyed to the call. A strict model (Claude, and any model\n * that validates tool history) needs this to read its own tool use back; folding\n * results into a `user` message instead makes such models re-issue the same call\n * in a loop.\n *\n * Substrate-free by design: the app supplies `streamTurn` (wrapping whatever\n * backend / `runAgentTaskStream` it uses) and `executeToolCall` (routing to its\n * integration + app-tool executors). This package owns the LOOP; the app owns\n * the model and the executors.\n *\n * LAYERING NOTE: this turn-level tool-dispatch loop is a generic RUNTIME\n * capability. It has been CONTRIBUTED DOWN and MERGED into\n * `@tangle-network/agent-runtime` as `runToolLoop` / `streamToolLoop` (PR #137),\n * but is not yet PUBLISHED (agent-runtime main is ahead of its last npm release;\n * cutting that release is the agent-runtime maintainer's call). TERMINAL STATE:\n * the moment agent-runtime publishes a version carrying #137, bump the\n * `@tangle-network/agent-runtime` peer-dep here and replace the bodies below with\n * a thin re-export — `streamAppToolLoop = streamToolLoop`, `runAppToolLoop =\n * runToolLoop` (types alias 1:1; `AppToolOutcome` ≡ `ToolCallOutcome`). Kept\n * substrate-free + shipping until then so consumers aren't blocked on the release.\n */\nimport type { AppToolOutcome } from '../tools/types'\n\nexport interface LoopToolCall {\n  toolCallId?: string\n  toolName: string\n  args: Record<string, unknown>\n}\n\n/** One OpenAI-shaped tool-call entry on an assistant message. */\nexport interface LoopAssistantToolCall {\n  id: string\n  type: 'function'\n  function: { name: string; arguments: string }\n}\n\n/**\n * A message in the running conversation the loop sends to `streamTurn`.\n *\n * The base `{ role, content }` covers `system` / `user` / plain `assistant`\n * turns. Two optional fields carry the OpenAI function-calling contract so the\n * model reads its own tool use back correctly instead of re-issuing it:\n *\n *   - an assistant turn that emitted tool calls carries `tool_calls`, and its\n *     `content` is `null` when the turn was tool-only;\n *   - each tool result is its own `{ role: 'tool', tool_call_id, content }`\n *     message keyed to the call that produced it.\n *\n * Widening is additive: a `streamTurn` that reads only `role` + `content` still\n * works; one that forwards the whole message to an OpenAI-compatible endpoint\n * now gets correct tool history. */\nexport interface LoopMessage {\n  role: string\n  content: string | null\n  tool_calls?: LoopAssistantToolCall[]\n  tool_call_id?: string\n}\n\n/** A tool-call id is required to key a `role: 'tool'` result back to its call.\n *  When the model omitted one, derive a stable id from the tool name so the\n *  assistant `tool_calls` entry and its `tool` result still match. */\nfunction toolCallId(call: LoopToolCall): string {\n  return call.toolCallId ?? `call_${call.toolName}`\n}\n\n/** The assistant turn that emitted `pending`, in OpenAI shape: text content\n *  (null when the turn was tool-only) plus its `tool_calls` array. */\nfunction assistantToolCallMessage(turnText: string, pending: LoopToolCall[]): LoopMessage {\n  return {\n    role: 'assistant',\n    content: turnText.trim() || null,\n    tool_calls: pending.map((call) => ({\n      id: toolCallId(call),\n      type: 'function',\n      function: { name: call.toolName, arguments: JSON.stringify(call.args) },\n    })),\n  }\n}\n\n/** One `role: 'tool'` result message keyed to its call by `tool_call_id`. */\nfunction toolResultMessage(call: LoopToolCall, content: string): LoopMessage {\n  return { role: 'tool', tool_call_id: toolCallId(call), content }\n}\n\n/** Events a turn stream yields. `text` accumulates into the final answer;\n *  `tool_call` is collected for dispatch; `reasoning` and `usage` pass through\n *  for UIs that render thinking sections and per-message token/cost metrics.\n *  Extra event types pass through untouched (the caller re-emits them to its\n *  own UI stream). */\nexport type LoopEvent =\n  | { type: 'text'; text: string }\n  | { type: 'reasoning'; text: string }\n  | { type: 'tool_call'; call: LoopToolCall }\n  | { type: 'usage'; usage: { promptTokens: number; completionTokens: number } }\n  | { type: 'other'; event: unknown }\n\n/** Why the loop stopped. `completed` = model finished naturally; `stuck-loop` =\n *  ≥3 consecutive identical tool calls (same tool + args); `backstop` = hit the\n *  runaway-backstop cap (200 by default); `deadline` = wall-clock deadlineMs\n *  exceeded; `budget` = maxCostUsd exhausted. Non-`completed` stops are infra /\n *  resource outcomes — eval scoring must distinguish them from capability failure. */\nexport type ToolLoopStopReason = 'completed' | 'stuck-loop' | 'backstop' | 'deadline' | 'budget'\n\nexport interface ToolLoopResult {\n  /** The model's final text across the loop. */\n  finalText: string\n  /** Every tool call executed, with its outcome, in order. */\n  toolResults: Array<{ call: LoopToolCall; label: string; outcome: AppToolOutcome }>\n  /** Number of model turns run (1 + tool-driven re-runs). */\n  turns: number\n  /** Why the loop stopped. */\n  stopReason: ToolLoopStopReason\n  /** @deprecated Use `stopReason !== 'completed'` instead. */\n  cappedOut: boolean\n}\n\nexport interface AppToolLoopOptions {\n  systemPrompt: string\n  userMessage: string\n  priorMessages?: Array<{ role: string; content: string }>\n  /** Stream one model turn over the running message list. The app wraps its\n   *  backend here. Messages follow {@link LoopMessage}: a tool-calling assistant\n   *  turn carries `tool_calls`, and each tool result is a `role: 'tool'` message.\n   *  A backend that reads only `role` + `content` is unaffected. */\n  streamTurn: (messages: LoopMessage[]) => AsyncIterable<LoopEvent>\n  /** Execute one tool call. The app routes to its integration executor / app-tool\n   *  executor and returns the outcome. */\n  executeToolCall: (call: LoopToolCall) => Promise<AppToolOutcome>\n  /** Which emitted tool names are executable (others are ignored — e.g. a UI-only\n   *  tool the app renders but doesn't run here). */\n  isExecutableTool: (toolName: string) => boolean\n  /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow.\n   *  For per-workflow limits use `maxCostUsd` or `deadlineMs` instead. */\n  maxToolTurns?: number\n  /** Wall-clock deadline in ms since epoch (Date.now()-based). When exceeded the\n   *  loop stops with stopReason `deadline`. */\n  deadlineMs?: number\n  /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */\n  maxCostUsd?: number\n  /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */\n  costOf?: (call: LoopToolCall, outcome: AppToolOutcome) => number\n  /** Render one tool outcome as the `content` of its `role: 'tool'` message.\n   *  Default is a compact `<label> → ok/failed: …`. */\n  renderResult?: (label: string, outcome: AppToolOutcome) => string\n  /** Map a tool call to the label its result is keyed under (default: toolName). */\n  labelFor?: (call: LoopToolCall) => string\n}\n\n/** Runaway-backstop: stops an infinite tool loop where cost is unmetered. Set\n *  far above any legitimate workflow — this is a watchdog, not a policy cap. */\nconst RUNAWAY_BACKSTOP_TURNS = 200\n/** Consecutive identical calls (same tool + canonical-JSON args) that trigger\n *  stuck-loop detection. The window resets on any different call. */\nconst STUCK_LOOP_THRESHOLD = 3\n\n/** Canonical identifier for a tool call used by stuck-loop detection.\n *  Keys are sorted so {b:1,a:2} and {a:2,b:1} produce the same hash. */\nfunction canonicalCallHash(call: LoopToolCall): string {\n  const sortedArgs = Object.fromEntries(\n    Object.entries(call.args).sort(([a], [b]) => a.localeCompare(b)),\n  )\n  return `${call.toolName}:${JSON.stringify(sortedArgs)}`\n}\n\nfunction defaultRender(label: string, outcome: AppToolOutcome): string {\n  if (outcome.ok) return `${label} → ok: ${JSON.stringify(outcome.result)}`\n  return `${label} → failed (${outcome.code}): ${outcome.message}`\n}\n\n/**\n * Run the bounded tool loop and return the final text + every executed tool\n * outcome. Yields nothing — it's an awaitable driver; callers that need to\n * re-emit events to a UI stream should do so inside `streamTurn`. (A streaming\n * variant can wrap this later; keeping the core awaitable makes it trivially\n * testable.)\n */\nexport async function runAppToolLoop(opts: AppToolLoopOptions): Promise<ToolLoopResult> {\n  const backstop = opts.maxToolTurns ?? RUNAWAY_BACKSTOP_TURNS\n  const render = opts.renderResult ?? defaultRender\n  const labelFor = opts.labelFor ?? ((c: LoopToolCall) => c.toolName)\n\n  const messages: LoopMessage[] = [\n    { role: 'system', content: opts.systemPrompt },\n    ...(opts.priorMessages ?? []),\n    { role: 'user', content: opts.userMessage },\n  ]\n\n  const toolResults: ToolLoopResult['toolResults'] = []\n  let finalText = ''\n  let turns = 0\n  let accumulatedCostUsd = 0\n  let lastCallHash: string | null = null\n  let consecutiveCount = 0\n\n  for (let toolTurn = 0; ; toolTurn++) {\n    turns++\n\n    // Wall-clock deadline check before every new turn.\n    if (opts.deadlineMs !== undefined && Date.now() >= opts.deadlineMs) {\n      return { finalText, toolResults, turns, stopReason: 'deadline', cappedOut: true }\n    }\n\n    let turnText = ''\n    const pending: LoopToolCall[] = []\n\n    for await (const ev of opts.streamTurn([...messages])) {\n      if (ev.type === 'text') {\n        turnText += ev.text\n        finalText += ev.text\n      } else if (ev.type === 'tool_call' && opts.isExecutableTool(ev.call.toolName)) {\n        pending.push(ev.call)\n      }\n    }\n\n    if (pending.length === 0) break\n\n    // Runaway backstop — the model keeps emitting calls past the safety ceiling.\n    if (toolTurn >= backstop) {\n      return { finalText, toolResults, turns, stopReason: 'backstop', cappedOut: true }\n    }\n\n    // The assistant turn that emitted the calls — with its tool_calls array —\n    // so the model sees its own tool use in history.\n    messages.push(assistantToolCallMessage(turnText, pending))\n\n    for (const call of pending) {\n      // Stuck-loop detection.\n      const callHash = canonicalCallHash(call)\n      if (callHash === lastCallHash) {\n        consecutiveCount++\n      } else {\n        lastCallHash = callHash\n        consecutiveCount = 1\n      }\n      if (consecutiveCount >= STUCK_LOOP_THRESHOLD) {\n        return { finalText, toolResults, turns, stopReason: 'stuck-loop', cappedOut: true }\n      }\n\n      let outcome: AppToolOutcome\n      try {\n        outcome = await opts.executeToolCall(call)\n      } catch (err) {\n        outcome = { ok: false, code: 'executor_error', message: err instanceof Error ? err.message : String(err) }\n      }\n\n      // Budget check after each tool call.\n      if (opts.maxCostUsd !== undefined && opts.costOf !== undefined) {\n        accumulatedCostUsd += opts.costOf(call, outcome)\n        if (accumulatedCostUsd >= opts.maxCostUsd) {\n          const label = labelFor(call)\n          toolResults.push({ call, label, outcome })\n          messages.push(toolResultMessage(call, render(label, outcome)))\n          return { finalText, toolResults, turns, stopReason: 'budget', cappedOut: true }\n        }\n      }\n\n      const label = labelFor(call)\n      toolResults.push({ call, label, outcome })\n      // One role:'tool' message per result, keyed to its call by tool_call_id.\n      messages.push(toolResultMessage(call, render(label, outcome)))\n    }\n  }\n\n  return { finalText, toolResults, turns, stopReason: 'completed', cappedOut: false }\n}\n\n// ── Streaming variant ──────────────────────────────────────────────────────\n//\n// `runAppToolLoop` is awaitable — perfect for tests and drain-only callers. A\n// real chat runtime instead needs to STREAM each model event to the client (SSE)\n// AND record telemetry per event as it happens. `streamAppToolLoop` is the same\n// bounded loop as an async generator: it yields every raw turn event (the app\n// maps + telemetries + re-emits it) and every executed tool result (same), while\n// owning the loop control flow (collect → stop/dispatch → append → re-run, capped).\n// `Raw` is the app's own runtime-event type — this package stays substrate-free.\n\nexport type StreamLoopYield<Raw> =\n  | { kind: 'event'; event: Raw }\n  | { kind: 'tool_result'; toolName: string; toolCallId?: string; label: string; outcome: AppToolOutcome }\n  | { kind: 'capped'; pending: number; stopReason: Exclude<ToolLoopStopReason, 'completed'> }\n\nexport interface StreamAppToolLoopOptions<Raw> {\n  systemPrompt: string\n  userMessage: string\n  priorMessages?: Array<{ role: string; content: string }>\n  /** Stream one model turn (the app wraps its backend / runAgentTaskStream).\n   *  Messages follow {@link LoopMessage}: a tool-calling assistant turn carries\n   *  `tool_calls`, and each tool result is a `role: 'tool'` message. */\n  streamTurn: (messages: LoopMessage[]) => AsyncIterable<Raw>\n  /** Text contribution of a raw event, '' if none — used to record the\n   *  assistant's turn so the next turn has its context. */\n  extractText: (event: Raw) => string\n  /** The tool call a raw event represents, or null. */\n  extractToolCall: (event: Raw) => LoopToolCall | null\n  /** Which tool names are executable here (others pass through, unexecuted). */\n  isExecutableTool: (toolName: string) => boolean\n  /** Execute one call — the app routes to its integration / app-tool executor. */\n  executeToolCall: (call: LoopToolCall) => Promise<AppToolOutcome>\n  /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow. */\n  maxToolTurns?: number\n  /** Wall-clock deadline in ms since epoch (Date.now()-based). */\n  deadlineMs?: number\n  /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */\n  maxCostUsd?: number\n  /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */\n  costOf?: (call: LoopToolCall, outcome: AppToolOutcome) => number\n  renderResult?: (label: string, outcome: AppToolOutcome) => string\n  labelFor?: (call: LoopToolCall) => string\n}\n\n/**\n * The streaming bounded tool loop. Yields `event` for each raw turn event and\n * `tool_result` for each executed tool; emits a single `capped` (with stopReason)\n * when it stops for any non-completed reason. The app drives telemetry + UI\n * emission off the yielded items.\n */\nexport async function* streamAppToolLoop<Raw>(opts: StreamAppToolLoopOptions<Raw>): AsyncGenerator<StreamLoopYield<Raw>, void, unknown> {\n  const backstop = opts.maxToolTurns ?? RUNAWAY_BACKSTOP_TURNS\n  const render = opts.renderResult ?? defaultRender\n  const labelFor = opts.labelFor ?? ((c: LoopToolCall) => c.toolName)\n\n  const messages: LoopMessage[] = [\n    { role: 'system', content: opts.systemPrompt },\n    ...(opts.priorMessages ?? []),\n    { role: 'user', content: opts.userMessage },\n  ]\n\n  let accumulatedCostUsd = 0\n  let lastCallHash: string | null = null\n  let consecutiveCount = 0\n\n  for (let toolTurn = 0; ; toolTurn++) {\n    // Wall-clock deadline check before every new turn.\n    if (opts.deadlineMs !== undefined && Date.now() >= opts.deadlineMs) {\n      yield { kind: 'capped', pending: 0, stopReason: 'deadline' }\n      return\n    }\n\n    let turnText = ''\n    const pending: LoopToolCall[] = []\n\n    for await (const event of opts.streamTurn([...messages])) {\n      yield { kind: 'event', event }\n      turnText += opts.extractText(event)\n      const call = opts.extractToolCall(event)\n      if (call && opts.isExecutableTool(call.toolName)) pending.push(call)\n    }\n\n    if (pending.length === 0) return\n\n    // Runaway backstop.\n    if (toolTurn >= backstop) {\n      yield { kind: 'capped', pending: pending.length, stopReason: 'backstop' }\n      return\n    }\n\n    // The assistant turn that emitted the calls — with its tool_calls array.\n    messages.push(assistantToolCallMessage(turnText, pending))\n\n    for (const call of pending) {\n      // Stuck-loop detection.\n      const callHash = canonicalCallHash(call)\n      if (callHash === lastCallHash) {\n        consecutiveCount++\n      } else {\n        lastCallHash = callHash\n        consecutiveCount = 1\n      }\n      if (consecutiveCount >= STUCK_LOOP_THRESHOLD) {\n        yield { kind: 'capped', pending: pending.length, stopReason: 'stuck-loop' }\n        return\n      }\n\n      let outcome: AppToolOutcome\n      try {\n        outcome = await opts.executeToolCall(call)\n      } catch (err) {\n        outcome = { ok: false, code: 'executor_error', message: err instanceof Error ? err.message : String(err) }\n      }\n\n      // Budget check after each tool call.\n      if (opts.maxCostUsd !== undefined && opts.costOf !== undefined) {\n        accumulatedCostUsd += opts.costOf(call, outcome)\n        if (accumulatedCostUsd >= opts.maxCostUsd) {\n          const label = labelFor(call)\n          yield { kind: 'tool_result', toolName: call.toolName, toolCallId: call.toolCallId, label, outcome }\n          messages.push(toolResultMessage(call, render(label, outcome)))\n          yield { kind: 'capped', pending: pending.length, stopReason: 'budget' }\n          return\n        }\n      }\n\n      const label = labelFor(call)\n      yield { kind: 'tool_result', toolName: call.toolName, toolCallId: call.toolCallId, label, outcome }\n      // One role:'tool' message per result, keyed to its call by tool_call_id.\n      messages.push(toolResultMessage(call, render(label, outcome)))\n    }\n  }\n}\n"],"mappings":"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","names":["label"]}

package/dist/{chunk-HZZD3ZYD.js → chunk-OLCVUGGI.js}

@@ -1,7 +1,7 @@
 import {
   dispatchAppTool,
   outcomeStatus
-} from "./chunk-JANT2G2E.js";
+} from "./chunk-QAQBR6KQ.js";
 
 // src/tools/capability.ts
 async function createCapabilityToken(userId, opts) {
@@ -134,4 +134,4 @@ export {
   buildHttpMcpServer,
   buildAppToolMcpServer
 };
-//# sourceMappingURL=chunk-HZZD3ZYD.js.map
+//# sourceMappingURL=chunk-OLCVUGGI.js.map

package/dist/{chunk-JANT2G2E.js → chunk-QAQBR6KQ.js}

@@ -97,8 +97,15 @@ async function dispatchAppTool(toolName, rawArgs, ctx, opts) {
       }
       if (!title) return { ok: false, code: "missing_title", message: "title is required." };
       const description = rawArgs.description == null ? null : String(rawArgs.description);
-      const r2 = await opts.handlers.submitProposal({ type, title, description }, ctx);
-      const regulated = opts.taxonomy.regulatedTypes.includes(type);
+      let regulated = opts.taxonomy.regulatedTypes.includes(type);
+      if (opts.needsApproval) {
+        try {
+          regulated = await opts.needsApproval(type, { title, description }, ctx);
+        } catch {
+          regulated = true;
+        }
+      }
+      const r2 = await opts.handlers.submitProposal({ type, title, description, regulated }, ctx);
       const { proposalId, deduped, status, ...extra } = r2;
       const effectiveStatus = status ?? "queued_for_approval";
       opts.onProduced?.({
@@ -149,4 +156,4 @@ export {
   outcomeStatus,
   createAppToolRuntimeExecutor
 };
-//# sourceMappingURL=chunk-JANT2G2E.js.map
+//# sourceMappingURL=chunk-QAQBR6KQ.js.map

package/dist/chunk-QAQBR6KQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools/errors.ts","../src/tools/openai.ts","../src/tools/dispatch.ts","../src/tools/runtime.ts"],"sourcesContent":["/** A correctable bad-input error a tool handler throws; the HTTP layer maps it\n *  to a 4xx with the code, the runtime layer to a failed tool_result. So the\n *  agent learns the call failed and can correct, instead of a silent success. */\nexport class ToolInputError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n    public status = 400,\n  ) {\n    super(message)\n    this.name = 'ToolInputError'\n  }\n}\n","import type { AppToolTaxonomy } from './types'\n\n/** The four canonical app-tool names. Stable identifiers the model calls in\n *  both the sandbox (MCP server name) and runtime (function-tool name) paths. */\nexport const APP_TOOL_NAMES = ['submit_proposal', 'schedule_followup', 'render_ui', 'add_citation'] as const\nexport type AppToolName = (typeof APP_TOOL_NAMES)[number]\n\nconst NAME_SET = new Set<string>(APP_TOOL_NAMES)\nexport function isAppToolName(name: string): name is AppToolName {\n  return NAME_SET.has(name)\n}\n\n/** A minimal OpenAI Chat Completions function-tool shape — structurally\n *  compatible with `@tangle-network/agent-runtime`'s `OpenAIChatTool` without\n *  importing it (keeps this package runtime-free). */\nexport interface OpenAIFunctionTool {\n  type: 'function'\n  function: {\n    name: string\n    description: string\n    parameters: Record<string, unknown>\n  }\n}\n\n/**\n * Build the four app tools in OpenAI function-tool shape. `submit_proposal`'s\n * `type` enum is the product's {@link AppToolTaxonomy.proposalTypes}; the other\n * three are fixed. Pass the result to the agent-runtime backend's `tools`.\n */\nexport function buildAppToolOpenAITools(taxonomy: AppToolTaxonomy): OpenAIFunctionTool[] {\n  return [\n    {\n      type: 'function',\n      function: {\n        name: 'submit_proposal',\n        description:\n          'Route a regulated or state-changing action to a human for approval (a recommendation, contacting/soliciting a contact, outreach, a record/account change, scheduling). Queues it for a named certified human to approve before it executes.',\n        parameters: {\n          type: 'object',\n          properties: {\n            type: { type: 'string', enum: [...taxonomy.proposalTypes] },\n            title: { type: 'string', description: 'Short label for the approval queue.' },\n            description: { type: 'string', description: 'The full drafted message/recommendation, with sources.' },\n          },\n          required: ['type', 'title'],\n        },\n      },\n    },\n    {\n      type: 'function',\n      function: {\n        name: 'schedule_followup',\n        description: 'Register a dated cadence step (a reminder, chase, or check-in) on the follow-up calendar. Executes immediately.',\n        parameters: {\n          type: 'object',\n          properties: {\n            title: { type: 'string' },\n            dueDate: { type: 'string', description: 'ISO date YYYY-MM-DD.' },\n            priority: { type: 'string', enum: ['low', 'medium', 'high'] },\n          },\n          required: ['title', 'dueDate'],\n        },\n      },\n    },\n    {\n      type: 'function',\n      function: {\n        name: 'render_ui',\n        description: 'Show a generated view live in the workspace. Validates the OpenUI JSON and persists the artifact. Executes immediately.',\n        parameters: {\n          type: 'object',\n          properties: {\n            title: { type: 'string' },\n            schema: { type: 'object', description: 'The OpenUI JSON object.' },\n          },\n          required: ['title', 'schema'],\n        },\n      },\n    },\n    {\n      type: 'function',\n      function: {\n        name: 'add_citation',\n        description: 'Anchor a grounding reference: the exact quote from a file backing a figure or claim. Verifies the quote appears in the file. Executes immediately.',\n        parameters: {\n          type: 'object',\n          properties: {\n            path: { type: 'string', description: 'The vault file path.' },\n            quote: { type: 'string', description: 'The exact text from it.' },\n          },\n          required: ['path', 'quote'],\n        },\n      },\n    },\n  ]\n}\n","import { ToolInputError } from './errors'\nimport { isAppToolName } from './openai'\nimport type {\n  AppToolContext,\n  AppToolHandlers,\n  AppToolOutcome,\n  AppToolProducedEvent,\n  AppToolTaxonomy,\n} from './types'\n\nexport interface DispatchOptions {\n  handlers: AppToolHandlers\n  taxonomy: AppToolTaxonomy\n  /** Per-call approval policy. When provided it OVERRIDES the static\n   *  `taxonomy.regulatedTypes` membership check, so products can gate by\n   *  cost threshold, environment, or first-use instead of always/never.\n   *  Fail-closed: a predicate that throws counts as \"approval required\". */\n  needsApproval?: (type: string, args: { title: string; description: string | null }, ctx: AppToolContext) => boolean | Promise<boolean>\n  /** Called at the real side-effect site for proposals (proposal_created) and\n   *  generated views (artifact) so a consumer's completion oracle credits\n   *  persisted state. Omit when produced state isn't tracked. */\n  onProduced?: (event: AppToolProducedEvent) => void\n}\n\n/**\n * The ONE place an app-tool call is validated, dispatched to the product's\n * handler, and turned into an {@link AppToolOutcome} + produced events. Shared\n * by the HTTP route layer and the agent-runtime executor so both paths apply\n * identical validation and identical side effects. A {@link ToolInputError}\n * (bad input the agent can correct) and any other throw both become\n * `{ ok: false }` — a tool call never silently \"succeeds\" without its effect.\n */\nexport async function dispatchAppTool(\n  toolName: string,\n  rawArgs: Record<string, unknown>,\n  ctx: AppToolContext,\n  opts: DispatchOptions,\n): Promise<AppToolOutcome> {\n  try {\n    if (!isAppToolName(toolName)) {\n      return { ok: false, code: 'unknown_tool', message: `${toolName} is not an app tool.` }\n    }\n\n    if (toolName === 'submit_proposal') {\n      const type = String(rawArgs.type ?? '').trim()\n      const title = String(rawArgs.title ?? '').trim()\n      if (!type || !opts.taxonomy.proposalTypes.includes(type)) {\n        return { ok: false, code: 'invalid_type', message: `type must be one of: ${opts.taxonomy.proposalTypes.join(', ')}.` }\n      }\n      if (!title) return { ok: false, code: 'missing_title', message: 'title is required.' }\n      const description = rawArgs.description == null ? null : String(rawArgs.description)\n      // Approval policy runs BEFORE the handler so the decision can gate the\n      // side effect itself, not merely re-label it afterwards.\n      let regulated = opts.taxonomy.regulatedTypes.includes(type)\n      if (opts.needsApproval) {\n        try {\n          regulated = await opts.needsApproval(type, { title, description }, ctx)\n        } catch {\n          regulated = true // fail-closed: a broken policy means approval required\n        }\n      }\n      const r = await opts.handlers.submitProposal({ type, title, description, regulated }, ctx)\n      // Pass the handler's result through: products with immediate-execute\n      // proposal types return status 'executed' plus their own fields\n      // (e.g. datasetId) — the model must see what actually happened, not a\n      // hard-coded \"queued for approval\".\n      const { proposalId, deduped, status, ...extra } = r\n      const effectiveStatus = status ?? 'queued_for_approval'\n      opts.onProduced?.({\n        type: 'proposal_created',\n        proposalId,\n        title,\n        status: effectiveStatus === 'executed' ? 'executed' : 'pending',\n      })\n      return { ok: true, result: { ...extra, status: effectiveStatus, proposalId, deduped, regulated } }\n    }\n\n    if (toolName === 'schedule_followup') {\n      const r = await opts.handlers.scheduleFollowup(\n        { title: String(rawArgs.title ?? ''), dueDate: String(rawArgs.dueDate ?? ''), priority: rawArgs.priority as string | undefined },\n        ctx,\n      )\n      return { ok: true, result: { followupId: r.id, dueDate: r.dueDate, deduped: r.deduped } }\n    }\n\n    if (toolName === 'render_ui') {\n      const r = await opts.handlers.renderUi({ title: String(rawArgs.title ?? ''), schema: rawArgs.schema }, ctx)\n      opts.onProduced?.({ type: 'artifact', path: r.path, content: r.content })\n      return { ok: true, result: { path: r.path } }\n    }\n\n    // add_citation\n    const r = await opts.handlers.addCitation(\n      { path: String(rawArgs.path ?? ''), quote: String(rawArgs.quote ?? ''), label: rawArgs.label as string | undefined },\n      ctx,\n    )\n    return { ok: true, result: { citationId: r.citationId, path: r.path } }\n  } catch (err) {\n    if (err instanceof ToolInputError) return { ok: false, code: err.code, message: err.message, status: err.status }\n    return { ok: false, code: 'app_tool_error', message: err instanceof Error ? err.message : String(err), status: 500 }\n  }\n}\n\n/** HTTP status for a failed outcome — the handler's `ToolInputError.status`\n *  when present, else 400 for a validation reject. */\nexport function outcomeStatus(outcome: Extract<AppToolOutcome, { ok: false }>): number {\n  return outcome.status ?? 400\n}\n","import { dispatchAppTool, type DispatchOptions } from './dispatch'\nimport type { AppToolContext, AppToolOutcome } from './types'\n\n/** Executes an app-tool call the model emits on the agent-runtime chat path.\n *  Plug into `runChatThroughRuntime({ appToolExecutor })` (or any loop that\n *  dispatches function tool_calls). */\nexport type AppToolRuntimeExecutor = (call: {\n  toolName: string\n  args: Record<string, unknown>\n}) => Promise<AppToolOutcome>\n\nexport interface RuntimeExecutorOptions extends DispatchOptions {\n  /** The trusted per-turn context — supplied directly (not from headers), since\n   *  the runtime path has no HTTP request. */\n  ctx: AppToolContext\n}\n\n/**\n * Build the runtime executor for one turn. The agent-runtime backend must also\n * advertise the tools (`buildAppToolOpenAITools(taxonomy)` on the backend's\n * `tools`) for the model to call them; this executor fulfils each call against\n * the product's handlers and emits produced events via `opts.onProduced`.\n */\nexport function createAppToolRuntimeExecutor(opts: RuntimeExecutorOptions): AppToolRuntimeExecutor {\n  return ({ toolName, args }) => dispatchAppTool(toolName, args, opts.ctx, opts)\n}\n"],"mappings":"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","names":["r"]}

package/dist/{chunk-GMFPCCQZ.js → chunk-SDOT7RNB.js}

@@ -225,6 +225,150 @@ function countUserMessages(messages) {
   return messages.filter((message) => message.role === "user").length;
 }
 
+// src/stream/turn-buffer.ts
+function deltaTypeOf(ev) {
+  const e = ev;
+  if (!e || typeof e !== "object") return null;
+  const inner = e.kind === "event" ? e.event : e;
+  if (!inner || typeof inner !== "object") return null;
+  if ((inner.type === "text" || inner.type === "reasoning") && typeof inner.text === "string") {
+    return inner.type;
+  }
+  return null;
+}
+function coalesceDeltas(events) {
+  const out = [];
+  for (const ev of events) {
+    const type = deltaTypeOf(ev);
+    const prev = out[out.length - 1];
+    if (type && prev && deltaTypeOf(prev) === type) {
+      const read = (x) => x.kind === "event" ? x.event : x;
+      const merged = JSON.parse(JSON.stringify(prev));
+      read(merged).text = String(read(prev).text) + String(read(ev).text);
+      out[out.length - 1] = merged;
+      continue;
+    }
+    out.push(ev);
+  }
+  return out;
+}
+async function pumpBufferedTurn(opts) {
+  const flushIntervalMs = opts.flushIntervalMs ?? 400;
+  let seq = 0;
+  let clientGone = false;
+  let pending = [];
+  let lastFlush = Date.now();
+  async function flush() {
+    if (pending.length === 0) return;
+    const batch = coalesceDeltas(pending);
+    pending = [];
+    const rows = batch.map((ev) => ({ seq: ++seq, event: JSON.stringify(ev) }));
+    await opts.store.append(opts.turnId, rows);
+    lastFlush = Date.now();
+  }
+  await opts.store.setStatus(opts.turnId, "running");
+  try {
+    for await (const ev of opts.source) {
+      pending.push(ev);
+      if (!clientGone && opts.write) {
+        try {
+          await opts.write(JSON.stringify(ev));
+        } catch {
+          clientGone = true;
+        }
+      }
+      if (Date.now() - lastFlush >= flushIntervalMs) await flush();
+    }
+    await flush();
+    await opts.store.setStatus(opts.turnId, "complete");
+  } catch (err) {
+    await flush().catch(() => {
+    });
+    await opts.store.setStatus(opts.turnId, "error").catch(() => {
+    });
+    throw err;
+  }
+}
+async function* replayTurnEvents(opts) {
+  const pollMs = opts.pollMs ?? 500;
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  let cursor = opts.fromSeq ?? 0;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const batch = await opts.store.read(opts.turnId, cursor);
+    for (const row of batch) {
+      cursor = Math.max(cursor, row.seq);
+      yield row;
+    }
+    const status = await opts.store.getStatus(opts.turnId);
+    if (status !== "running") {
+      yield { seq: -1, event: JSON.stringify({ type: "turn_status", status: status ?? "unknown" }) };
+      return;
+    }
+    if (Date.now() >= deadline) {
+      yield { seq: -1, event: JSON.stringify({ type: "turn_status", status: "timeout" }) };
+      return;
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+}
+var TURN_EVENTS_MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS turn_events (
+  turnId TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  event TEXT NOT NULL,
+  PRIMARY KEY (turnId, seq)
+);
+CREATE TABLE IF NOT EXISTS turn_status (
+  turnId TEXT PRIMARY KEY,
+  status TEXT NOT NULL,
+  updatedAt TEXT NOT NULL
+);
+`;
+function createD1TurnEventStore(db) {
+  return {
+    async append(turnId, events) {
+      if (!events.length) return;
+      const placeholders = events.map(() => "(?, ?, ?)").join(", ");
+      const values = events.flatMap((e) => [turnId, e.seq, e.event]);
+      await db.prepare(`INSERT OR IGNORE INTO turn_events (turnId, seq, event) VALUES ${placeholders}`).bind(...values).run();
+    },
+    async read(turnId, fromSeq) {
+      const { results } = await db.prepare("SELECT seq, event FROM turn_events WHERE turnId = ? AND seq > ? ORDER BY seq ASC").bind(turnId, fromSeq).all();
+      return results;
+    },
+    async setStatus(turnId, status) {
+      await db.prepare(
+        "INSERT INTO turn_status (turnId, status, updatedAt) VALUES (?, ?, ?) ON CONFLICT(turnId) DO UPDATE SET status = excluded.status, updatedAt = excluded.updatedAt"
+      ).bind(turnId, status, (/* @__PURE__ */ new Date()).toISOString()).run();
+    },
+    async getStatus(turnId) {
+      const row = await db.prepare("SELECT status FROM turn_status WHERE turnId = ?").bind(turnId).first();
+      return row?.status ?? null;
+    }
+  };
+}
+function createMemoryTurnEventStore() {
+  const events = /* @__PURE__ */ new Map();
+  const status = /* @__PURE__ */ new Map();
+  return {
+    async append(turnId, rows) {
+      const list = events.get(turnId) ?? [];
+      list.push(...rows);
+      events.set(turnId, list);
+    },
+    async read(turnId, fromSeq) {
+      return (events.get(turnId) ?? []).filter((e) => e.seq > fromSeq);
+    },
+    async setStatus(turnId, s) {
+      status.set(turnId, s);
+    },
+    async getStatus(turnId) {
+      return status.get(turnId) ?? null;
+    }
+  };
+}
+
 export {
   asRecord,
   asString,
@@ -240,6 +384,12 @@ export {
   normalizeClientTurnId,
   buildUserTextParts,
   messageHasTurnId,
-  resolveChatTurn
+  resolveChatTurn,
+  coalesceDeltas,
+  pumpBufferedTurn,
+  replayTurnEvents,
+  TURN_EVENTS_MIGRATION_SQL,
+  createD1TurnEventStore,
+  createMemoryTurnEventStore
 };
-//# sourceMappingURL=chunk-GMFPCCQZ.js.map
+//# sourceMappingURL=chunk-SDOT7RNB.js.map

package/dist/chunk-SDOT7RNB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/stream/stream-normalizer.ts","../src/stream/turn-identity.ts","../src/stream/turn-buffer.ts"],"sourcesContent":["export type JsonRecord = Record<string, unknown>\n\nexport interface StreamEvent {\n  type: string\n  data?: JsonRecord\n}\n\nexport function asRecord(value: unknown): JsonRecord | undefined {\n  return value && typeof value === 'object' && !Array.isArray(value)\n    ? value as JsonRecord\n    : undefined\n}\n\nexport function asString(value: unknown): string | undefined {\n  return typeof value === 'string' && value.length > 0 ? value : undefined\n}\n\nexport function resolveToolId(part: JsonRecord): string {\n  return String(\n    part.id ??\n      part.callID ??\n      part.callId ??\n      part.toolUseId ??\n      part.toolCallId ??\n      part.tool ??\n      part.name ??\n      `tool-${Date.now()}`,\n  )\n}\n\nexport function resolveToolName(part: JsonRecord): string {\n  return String(part.tool ?? part.name ?? 'tool')\n}\n\nexport function normalizeTime(value: unknown): JsonRecord | undefined {\n  const record = asRecord(value)\n  if (!record) return undefined\n\n  const start = Number(record.start ?? record.startedAt ?? record.started_at)\n  const end = Number(record.end ?? record.completedAt ?? record.completed_at)\n  if (!Number.isFinite(start) && !Number.isFinite(end)) return undefined\n\n  return {\n    start: Number.isFinite(start) ? start : undefined,\n    end: Number.isFinite(end) ? end : undefined,\n  }\n}\n\nexport function normalizeToolEvent(event: StreamEvent): StreamEvent {\n  if (event.type === 'tool_call' || event.type === 'tool.call') {\n    const data = event.data ?? {}\n    return {\n      type: 'message.part.updated',\n      data: {\n        part: {\n          type: 'tool',\n          id: data.id ?? data.callId ?? data.callID ?? data.name,\n          tool: data.name ?? data.tool ?? 'tool',\n          input: data.arguments ?? data.input,\n          status: 'running',\n        },\n      },\n    }\n  }\n\n  if (event.type === 'tool_result' || event.type === 'tool.result') {\n    const data = event.data ?? {}\n    const error = asString(data.error)\n    return {\n      type: 'message.part.updated',\n      data: {\n        part: {\n          type: 'tool',\n          id: data.id ?? data.callId ?? data.callID ?? data.name,\n          tool: data.name ?? data.tool ?? 'tool',\n          output: data.output,\n          error,\n          status: error ? 'error' : 'completed',\n        },\n      },\n    }\n  }\n\n  return event\n}\n\nexport function normalizePersistedPart(rawPart: JsonRecord): JsonRecord | null {\n  const type = String(rawPart.type ?? '')\n\n  if (type === 'text') {\n    return {\n      type: 'text',\n      text: asString(rawPart.text) ?? asString(rawPart.content) ?? '',\n    }\n  }\n\n  if (type === 'reasoning') {\n    return {\n      type: 'reasoning',\n      text: asString(rawPart.text) ?? asString(rawPart.content) ?? '',\n      time: normalizeTime(rawPart.time),\n    }\n  }\n\n  if (type === 'tool') {\n    const state = asRecord(rawPart.state)\n    const output = state?.output ?? rawPart.output\n    const error = asString(state?.error ?? rawPart.error)\n    const status =\n      state?.status === 'completed' || rawPart.status === 'completed'\n        ? 'completed'\n        : state?.status === 'error' || rawPart.status === 'error' || error\n          ? 'error'\n          : output !== undefined\n            ? 'completed'\n            : 'running'\n\n    return {\n      type: 'tool',\n      id: resolveToolId(rawPart),\n      tool: resolveToolName(rawPart),\n      callID:\n        rawPart.callID != null || rawPart.callId != null\n          ? String(rawPart.callID ?? rawPart.callId)\n          : undefined,\n      state: {\n        status,\n        input: state?.input ?? rawPart.input,\n        output,\n        error,\n        metadata: asRecord(state?.metadata) ?? asRecord(rawPart.metadata),\n        time: normalizeTime(state?.time ?? rawPart.time),\n      },\n    }\n  }\n\n  return null\n}\n\nexport function getPartKey(part: JsonRecord): string {\n  const type = String(part.type ?? 'unknown')\n  if (type === 'tool') {\n    return `tool:${resolveToolId(part)}`\n  }\n\n  if (type === 'reasoning') {\n    return `reasoning:${String(part.id ?? part.partId ?? part.index ?? 'current')}`\n  }\n\n  return `text:${String(part.id ?? part.partId ?? part.index ?? 'current')}`\n}\n\nexport function mergePersistedPart(existing: JsonRecord | undefined, incoming: JsonRecord, delta?: string): JsonRecord {\n  const type = String(incoming.type ?? '')\n  if (!existing) {\n    if (type === 'text' && delta) {\n      return { type: 'text', text: delta }\n    }\n    return incoming\n  }\n\n  if (type === 'text' && String(existing.type ?? '') === 'text') {\n    return {\n      ...existing,\n      ...incoming,\n      text: delta ? `${String(existing.text ?? '')}${delta}` : String(incoming.text ?? ''),\n    }\n  }\n\n  if (type === 'reasoning' && String(existing.type ?? '') === 'reasoning') {\n    const existingText = String(existing.text ?? '')\n    const incomingText = String(incoming.text ?? '')\n    return {\n      ...existing,\n      ...incoming,\n      text: delta && incomingText === existingText ? `${existingText}${delta}` : incomingText || existingText,\n      time: incoming.time ?? existing.time,\n    }\n  }\n\n  if (type === 'tool' && String(existing.type ?? '') === 'tool') {\n    return {\n      ...existing,\n      ...incoming,\n      state: {\n        ...(asRecord(existing.state) ?? {}),\n        ...(asRecord(incoming.state) ?? {}),\n        time: asRecord(incoming.state)?.time ?? asRecord(existing.state)?.time,\n      },\n    }\n  }\n\n  return incoming\n}\n\nexport function finalizeAssistantParts(\n  partOrder: string[],\n  partMap: Map<string, JsonRecord>,\n  finalText: string,\n): JsonRecord[] {\n  const parts = partOrder\n    .map((key) => partMap.get(key))\n    .filter((part): part is JsonRecord => Boolean(part))\n\n  if (!parts.some((part) => String(part.type ?? '') === 'text')) {\n    if (finalText.trim()) {\n      parts.push({ type: 'text', text: finalText })\n    }\n    return parts\n  }\n\n  return parts.map((part) => {\n    if (String(part.type ?? '') !== 'text') return part\n    return {\n      ...part,\n      text: finalText || String(part.text ?? ''),\n    }\n  })\n}\n\nexport function encodeEvent(encoder: TextEncoder, event: StreamEvent): Uint8Array {\n  return encoder.encode(`${JSON.stringify(event)}\\n`)\n}\n","import type { JsonRecord } from './stream-normalizer'\n\nexport interface PersistedChatMessageForTurn {\n  id: string\n  role: 'user' | 'assistant' | 'system' | 'tool'\n  content: string\n  parts: Array<Record<string, unknown>> | null\n}\n\nexport interface ResolvedChatTurn {\n  turnIndex: number\n  shouldInsertUserMessage: boolean\n  priorMessages: PersistedChatMessageForTurn[]\n  userParts: JsonRecord[]\n}\n\nexport function normalizeClientTurnId(value: unknown): string | undefined {\n  if (value === undefined || value === null) return undefined\n  if (typeof value !== 'string') throw new Error('turnId must be a string')\n  const trimmed = value.trim()\n  if (!trimmed) throw new Error('turnId must not be blank')\n  if (trimmed.length > 160) throw new Error('turnId is too long')\n  if (!/^[A-Za-z0-9:_-]+$/.test(trimmed)) {\n    throw new Error('turnId contains unsupported characters')\n  }\n  return trimmed\n}\n\nexport function buildUserTextParts(text: string, turnId: string | undefined): JsonRecord[] {\n  const part: JsonRecord = { type: 'text', text }\n  if (turnId) part.turnId = turnId\n  return [part]\n}\n\nexport function messageHasTurnId(message: PersistedChatMessageForTurn, turnId: string): boolean {\n  for (const part of message.parts ?? []) {\n    if (part && typeof part === 'object' && String(part.turnId ?? '') === turnId) {\n      return true\n    }\n  }\n  return false\n}\n\nexport function resolveChatTurn(input: {\n  existingMessages: PersistedChatMessageForTurn[]\n  userContent: string\n  turnId?: string\n}): ResolvedChatTurn {\n  const { existingMessages, userContent, turnId } = input\n  const reusableIndex = findReusableUserMessageIndex(existingMessages, userContent, turnId)\n  if (reusableIndex >= 0) {\n    return {\n      turnIndex: countUserMessages(existingMessages.slice(0, reusableIndex)),\n      shouldInsertUserMessage: false,\n      priorMessages: existingMessages.slice(0, reusableIndex),\n      userParts: buildUserTextParts(userContent, turnId),\n    }\n  }\n\n  return {\n    turnIndex: countUserMessages(existingMessages),\n    shouldInsertUserMessage: true,\n    priorMessages: existingMessages,\n    userParts: buildUserTextParts(userContent, turnId),\n  }\n}\n\nfunction findReusableUserMessageIndex(\n  messages: PersistedChatMessageForTurn[],\n  userContent: string,\n  turnId: string | undefined,\n): number {\n  if (turnId) {\n    for (let index = messages.length - 1; index >= 0; index -= 1) {\n      const message = messages[index]\n      if (message?.role === 'user' && messageHasTurnId(message, turnId)) return index\n    }\n  }\n\n  const latest = messages.at(-1)\n  if (latest?.role === 'user' && latest.content === userContent) {\n    return messages.length - 1\n  }\n\n  return -1\n}\n\nfunction countUserMessages(messages: PersistedChatMessageForTurn[]): number {\n  return messages.filter((message) => message.role === 'user').length\n}\n","/**\n * Resumable chat turns — the router-path answer to \"streams resume on\n * disconnect\" (issue #27). A turn's loop events are teed into a store as they\n * stream; the turn keeps running under `ctx.waitUntil` when the client drops;\n * a reconnecting client replays the buffered tail by sequence number and\n * keeps following until the turn completes.\n *\n *   POST /chat/stream            → pumpBufferedTurn(...) + live NDJSON\n *   GET  /chat/stream/:turnId    → replayTurnEvents({ fromSeq }) → NDJSON\n *\n * Storage is a structural seam ({@link TurnEventStore}); a D1 implementation\n * ships here because that's what Cloudflare products have (KV is unsuitable:\n * eventually consistent cross-isolate). Per-token deltas would mean hundreds\n * of rows per turn, so consecutive text/reasoning deltas are coalesced within\n * a flush window before they are persisted — replay yields slightly chunkier\n * deltas with identical concatenation.\n */\n\nexport type TurnStatus = 'running' | 'complete' | 'error'\n\nexport interface BufferedTurnEvent {\n  seq: number\n  /** The serialized event line (JSON string, no trailing newline). */\n  event: string\n}\n\nexport interface TurnEventStore {\n  append(turnId: string, events: BufferedTurnEvent[]): Promise<void>\n  read(turnId: string, fromSeq: number): Promise<BufferedTurnEvent[]>\n  setStatus(turnId: string, status: TurnStatus): Promise<void>\n  getStatus(turnId: string): Promise<TurnStatus | null>\n}\n\n// ── coalescing ────────────────────────────────────────────────────────────\n\ntype AnyRecord = Record<string, unknown>\n\nfunction deltaTypeOf(ev: unknown): 'text' | 'reasoning' | null {\n  const e = ev as AnyRecord | null\n  if (!e || typeof e !== 'object') return null\n  const inner = (e.kind === 'event' ? (e.event as AnyRecord | undefined) : e) as AnyRecord | undefined\n  if (!inner || typeof inner !== 'object') return null\n  if ((inner.type === 'text' || inner.type === 'reasoning') && typeof inner.text === 'string') {\n    return inner.type\n  }\n  return null\n}\n\n/** Merge consecutive text/reasoning deltas of the same type into one event.\n *  Concatenation-preserving: replaying the coalesced stream produces the same\n *  accumulated text as the original. */\nexport function coalesceDeltas(events: unknown[]): unknown[] {\n  const out: unknown[] = []\n  for (const ev of events) {\n    const type = deltaTypeOf(ev)\n    const prev = out[out.length - 1]\n    if (type && prev && deltaTypeOf(prev) === type) {\n      const read = (x: unknown): AnyRecord =>\n        ((x as AnyRecord).kind === 'event' ? (x as AnyRecord).event : x) as AnyRecord\n      const merged = JSON.parse(JSON.stringify(prev)) as AnyRecord\n      read(merged).text = String(read(prev).text) + String(read(ev).text)\n      out[out.length - 1] = merged\n      continue\n    }\n    out.push(ev)\n  }\n  return out\n}\n\n// ── pump (producer side) ──────────────────────────────────────────────────\n\nexport interface PumpBufferedTurnOptions {\n  source: AsyncIterable<unknown>\n  store: TurnEventStore\n  turnId: string\n  /** Deliver one serialized line (with seq) to the live client. Throwing here\n   *  (client disconnected) does NOT stop the turn — events keep buffering. */\n  write?: (line: string) => Promise<void> | void\n  /** Flush buffered events to the store at most this often. Default 400ms. */\n  flushIntervalMs?: number\n}\n\n/**\n * Drive a turn to completion regardless of the live client: every source\n * event is sequence-numbered, delivered to `write` (best-effort), and flushed\n * to the store in coalesced batches. Returns a promise that resolves when the\n * turn finishes — hand it to `ctx.waitUntil` so a disconnect can't kill the\n * turn. Never rejects on client-write failure; a source error marks the turn\n * status 'error' (after flushing what was produced) and rethrows.\n */\nexport async function pumpBufferedTurn(opts: PumpBufferedTurnOptions): Promise<void> {\n  const flushIntervalMs = opts.flushIntervalMs ?? 400\n  let seq = 0\n  let clientGone = false\n  let pending: unknown[] = []\n  let lastFlush = Date.now()\n\n  async function flush(): Promise<void> {\n    if (pending.length === 0) return\n    const batch = coalesceDeltas(pending)\n    pending = []\n    const rows = batch.map((ev) => ({ seq: ++seq, event: JSON.stringify(ev) }))\n    await opts.store.append(opts.turnId, rows)\n    lastFlush = Date.now()\n  }\n\n  await opts.store.setStatus(opts.turnId, 'running')\n  try {\n    for await (const ev of opts.source) {\n      pending.push(ev)\n      if (!clientGone && opts.write) {\n        try {\n          // Live delivery carries a provisional ordering hint, not the\n          // persisted seq (coalescing changes seq assignment); clients resume\n          // with the seqs from replay, or 0 for \"everything\".\n          await opts.write(JSON.stringify(ev))\n        } catch {\n          clientGone = true\n        }\n      }\n      if (Date.now() - lastFlush >= flushIntervalMs) await flush()\n    }\n    await flush()\n    await opts.store.setStatus(opts.turnId, 'complete')\n  } catch (err) {\n    await flush().catch(() => {})\n    await opts.store.setStatus(opts.turnId, 'error').catch(() => {})\n    throw err\n  }\n}\n\n// ── replay (consumer side) ────────────────────────────────────────────────\n\nexport interface ReplayTurnEventsOptions {\n  store: TurnEventStore\n  turnId: string\n  /** Replay strictly after this sequence number (0 = from the beginning). */\n  fromSeq?: number\n  /** Poll cadence while the turn is still running. Default 500ms. */\n  pollMs?: number\n  /** Give up following a 'running' turn after this long. Default 120s. */\n  timeoutMs?: number\n}\n\n/**\n * Yield buffered events after `fromSeq`, then keep polling while the turn is\n * still 'running' until it completes, errors, or times out. Terminates with a\n * final `{seq: -1, event: '{\"type\":\"turn_status\",...}'}` marker so clients\n * know why the replay ended.\n */\nexport async function* replayTurnEvents(opts: ReplayTurnEventsOptions): AsyncGenerator<BufferedTurnEvent> {\n  const pollMs = opts.pollMs ?? 500\n  const timeoutMs = opts.timeoutMs ?? 120_000\n  let cursor = opts.fromSeq ?? 0\n  const deadline = Date.now() + timeoutMs\n\n  for (;;) {\n    const batch = await opts.store.read(opts.turnId, cursor)\n    for (const row of batch) {\n      cursor = Math.max(cursor, row.seq)\n      yield row\n    }\n    const status = await opts.store.getStatus(opts.turnId)\n    if (status !== 'running') {\n      yield { seq: -1, event: JSON.stringify({ type: 'turn_status', status: status ?? 'unknown' }) }\n      return\n    }\n    if (Date.now() >= deadline) {\n      yield { seq: -1, event: JSON.stringify({ type: 'turn_status', status: 'timeout' }) }\n      return\n    }\n    await new Promise((r) => setTimeout(r, pollMs))\n  }\n}\n\n// ── D1 store ──────────────────────────────────────────────────────────────\n\n/** Minimal structural D1 contract (Cloudflare `D1Database` satisfies it). */\nexport interface D1LikeForTurns {\n  prepare(sql: string): {\n    bind(...values: unknown[]): {\n      run(): Promise<unknown>\n      all<T = Record<string, unknown>>(): Promise<{ results: T[] }>\n      first<T = Record<string, unknown>>(): Promise<T | null>\n    }\n  }\n}\n\n/** Schema for the D1 store — append to the product's migrations. */\nexport const TURN_EVENTS_MIGRATION_SQL = `\nCREATE TABLE IF NOT EXISTS turn_events (\n  turnId TEXT NOT NULL,\n  seq INTEGER NOT NULL,\n  event TEXT NOT NULL,\n  PRIMARY KEY (turnId, seq)\n);\nCREATE TABLE IF NOT EXISTS turn_status (\n  turnId TEXT PRIMARY KEY,\n  status TEXT NOT NULL,\n  updatedAt TEXT NOT NULL\n);\n`\n\nexport function createD1TurnEventStore(db: D1LikeForTurns): TurnEventStore {\n  return {\n    async append(turnId, events) {\n      if (!events.length) return\n      // One multi-row insert per flush window keeps write volume bounded.\n      const placeholders = events.map(() => '(?, ?, ?)').join(', ')\n      const values = events.flatMap((e) => [turnId, e.seq, e.event])\n      await db.prepare(`INSERT OR IGNORE INTO turn_events (turnId, seq, event) VALUES ${placeholders}`).bind(...values).run()\n    },\n    async read(turnId, fromSeq) {\n      const { results } = await db\n        .prepare('SELECT seq, event FROM turn_events WHERE turnId = ? AND seq > ? ORDER BY seq ASC')\n        .bind(turnId, fromSeq)\n        .all<{ seq: number; event: string }>()\n      return results\n    },\n    async setStatus(turnId, status) {\n      await db\n        .prepare(\n          'INSERT INTO turn_status (turnId, status, updatedAt) VALUES (?, ?, ?) ON CONFLICT(turnId) DO UPDATE SET status = excluded.status, updatedAt = excluded.updatedAt',\n        )\n        .bind(turnId, status, new Date().toISOString())\n        .run()\n    },\n    async getStatus(turnId) {\n      const row = await db.prepare('SELECT status FROM turn_status WHERE turnId = ?').bind(turnId).first<{ status: TurnStatus }>()\n      return row?.status ?? null\n    },\n  }\n}\n\n/** In-memory store for tests and keyless local dev. */\nexport function createMemoryTurnEventStore(): TurnEventStore {\n  const events = new Map<string, BufferedTurnEvent[]>()\n  const status = new Map<string, TurnStatus>()\n  return {\n    async append(turnId, rows) {\n      const list = events.get(turnId) ?? []\n      list.push(...rows)\n      events.set(turnId, list)\n    },\n    async read(turnId, fromSeq) {\n      return (events.get(turnId) ?? []).filter((e) => e.seq > fromSeq)\n    },\n    async setStatus(turnId, s) {\n      status.set(turnId, s)\n    },\n    async getStatus(turnId) {\n      return status.get(turnId) ?? null\n    },\n  }\n}\n"],"mappings":"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","names":[]}