octoflow-core 1.0.0

package/dist/runtime/bridge/subagents-option.js

@@ -0,0 +1,28 @@
+import { builtInAgentRegistry } from "../../adapters/agents/registry/built-in.js";
+import { createSubagentAction } from "../orchestration/subagent/subagent-action.js";
+function wireSubagentsOption(parentBridge, actionRegistry, opts) {
+  const s = opts.subagents;
+  if (!s) return;
+  const cfg = s === true ? {} : s;
+  const effectiveMaxDepth = cfg.maxDepth ?? 1;
+  if (parentBridge.lineage !== void 0 && parentBridge.lineage.depth >= effectiveMaxDepth) {
+    return;
+  }
+  const action = createSubagentAction({
+    registry: cfg.registry ?? builtInAgentRegistry(),
+    parentBridge,
+    ...cfg.maxDepth !== void 0 ? { maxDepth: cfg.maxDepth } : {},
+    ...cfg.maxConcurrent !== void 0 ? { maxConcurrent: cfg.maxConcurrent } : {},
+    ...cfg.timeoutMs !== void 0 ? { timeoutMs: cfg.timeoutMs } : {},
+    ...cfg.allowedRoles ? { allowedRoles: cfg.allowedRoles } : {},
+    ...cfg.name ? { name: cfg.name } : {},
+    ...cfg.inherit ? { inherit: cfg.inherit } : {},
+    ...cfg.toModelOutput ? { toModelOutput: cfg.toModelOutput } : {},
+    ...cfg.onChildEvent ? { onChildEvent: cfg.onChildEvent } : {}
+  });
+  actionRegistry.register(action);
+}
+export {
+  wireSubagentsOption
+};
+//# sourceMappingURL=subagents-option.js.map

package/dist/runtime/bridge/subagents-option.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/runtime/bridge/subagents-option.ts"],
+  "sourcesContent": ["import type { ActionRegistry } from '../../actions/registry.js';\nimport { builtInAgentRegistry } from '../../adapters/agents/registry/built-in.js';\nimport { createSubagentAction } from '../orchestration/subagent/subagent-action.js';\nimport type { BridgeOptions } from '../sessions/context-manager.js';\nimport type { BridgePort } from './bridge-port.js';\n\nexport function wireSubagentsOption(\n  parentBridge: BridgePort,\n  actionRegistry: ActionRegistry,\n  opts: BridgeOptions\n): void {\n  const s = opts.subagents;\n  if (!s) return;\n  const cfg = s === true ? {} : s;\n\n  // Depth guard: if this bridge is itself a subagent and already at the\n  // effective max depth, skip registration entirely. This converts the\n  // implicit SubagentDepthExceededError (a runtime throw) into explicit tool\n  // absence \u2014 the model sees a clean surface with no `task` tool that would\n  // always fail. Callers who explicitly raise maxDepth can still spawn deeper.\n  const effectiveMaxDepth = cfg.maxDepth ?? 1;\n  if (\n    parentBridge.lineage !== undefined &&\n    parentBridge.lineage.depth >= effectiveMaxDepth\n  ) {\n    return;\n  }\n  const action = createSubagentAction({\n    registry: cfg.registry ?? builtInAgentRegistry(),\n    parentBridge,\n    ...(cfg.maxDepth !== undefined ? { maxDepth: cfg.maxDepth } : {}),\n    ...(cfg.maxConcurrent !== undefined\n      ? { maxConcurrent: cfg.maxConcurrent }\n      : {}),\n    ...(cfg.timeoutMs !== undefined ? { timeoutMs: cfg.timeoutMs } : {}),\n    ...(cfg.allowedRoles ? { allowedRoles: cfg.allowedRoles } : {}),\n    ...(cfg.name ? { name: cfg.name } : {}),\n    ...(cfg.inherit ? { inherit: cfg.inherit } : {}),\n    ...(cfg.toModelOutput ? { toModelOutput: cfg.toModelOutput } : {}),\n    ...(cfg.onChildEvent ? { onChildEvent: cfg.onChildEvent } : {}),\n  });\n  actionRegistry.register(action);\n}\n"],
+  "mappings": "AACA,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AAI9B,SAAS,oBACd,cACA,gBACA,MACM;AACN,QAAM,IAAI,KAAK;AACf,MAAI,CAAC,EAAG;AACR,QAAM,MAAM,MAAM,OAAO,CAAC,IAAI;AAO9B,QAAM,oBAAoB,IAAI,YAAY;AAC1C,MACE,aAAa,YAAY,UACzB,aAAa,QAAQ,SAAS,mBAC9B;AACA;AAAA,EACF;AACA,QAAM,SAAS,qBAAqB;AAAA,IAClC,UAAU,IAAI,YAAY,qBAAqB;AAAA,IAC/C;AAAA,IACA,GAAI,IAAI,aAAa,SAAY,EAAE,UAAU,IAAI,SAAS,IAAI,CAAC;AAAA,IAC/D,GAAI,IAAI,kBAAkB,SACtB,EAAE,eAAe,IAAI,cAAc,IACnC,CAAC;AAAA,IACL,GAAI,IAAI,cAAc,SAAY,EAAE,WAAW,IAAI,UAAU,IAAI,CAAC;AAAA,IAClE,GAAI,IAAI,eAAe,EAAE,cAAc,IAAI,aAAa,IAAI,CAAC;AAAA,IAC7D,GAAI,IAAI,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;AAAA,IACrC,GAAI,IAAI,UAAU,EAAE,SAAS,IAAI,QAAQ,IAAI,CAAC;AAAA,IAC9C,GAAI,IAAI,gBAAgB,EAAE,eAAe,IAAI,cAAc,IAAI,CAAC;AAAA,IAChE,GAAI,IAAI,eAAe,EAAE,cAAc,IAAI,aAAa,IAAI,CAAC;AAAA,EAC/D,CAAC;AACD,iBAAe,SAAS,MAAM;AAChC;",
+  "names": []
+}

package/dist/runtime/bridge/swarm-handoff.d.ts

@@ -0,0 +1,4 @@
+import type { Pack } from '../orchestration/pack.js';
+import type { PackMesh } from '../orchestration/pack.js';
+export declare function wireSwarmHandoffPeer(pack: Pack, mesh: PackMesh, peerName: string): void;
+//# sourceMappingURL=swarm-handoff.d.ts.map

package/dist/runtime/bridge/swarm-handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm-handoff.d.ts","sourceRoot":"","sources":["../../../src/runtime/bridge/swarm-handoff.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAe,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAyCzD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,GACf,IAAI,CAsBN"}

package/dist/runtime/bridge/swarm-handoff.js

@@ -0,0 +1,60 @@
+import crypto from "node:crypto";
+import { OctoFlowError } from "../../domain/errors/index.js";
+import { extractText } from "../../utils/extract-text.js";
+function handoffPayloadToPrompt(payload) {
+  if (typeof payload === "string") return payload;
+  return JSON.stringify(payload);
+}
+function handoffErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runSwarmHandoffTarget(entry, message, contextId) {
+  if (entry.bridge) {
+    const result = await entry.bridge.sendMessage({
+      contextId,
+      message: {
+        kind: "message",
+        messageId: crypto.randomUUID(),
+        role: "user",
+        parts: [{ kind: "text", text: message }]
+      }
+    });
+    return extractText(result);
+  }
+  if (entry.client) {
+    const result = await entry.client.run(message);
+    return result.text;
+  }
+  throw new OctoFlowError(
+    "SWARM_HANDOFF_TARGET_UNAVAILABLE",
+    `Swarm peer "${entry.name}" has no bridge or client.`,
+    { target: entry.name }
+  );
+}
+function wireSwarmHandoffPeer(pack, mesh, peerName) {
+  mesh.onMessage(peerName, (request) => {
+    if (request.replyTo) return;
+    void (async () => {
+      const entry = pack.registry.get(peerName);
+      if (!entry) {
+        mesh.reply(request, {
+          ok: false,
+          error: `Swarm peer "${peerName}" is not registered.`
+        });
+        return;
+      }
+      const result = await runSwarmHandoffTarget(
+        entry,
+        handoffPayloadToPrompt(request.payload),
+        `handoff-${request.id}`
+      );
+      mesh.reply(request, { ok: true, result });
+    })().catch((error) => {
+      mesh.reply(request, { ok: false, error: handoffErrorMessage(error) });
+    });
+  });
+}
+export {
+  wireSwarmHandoffPeer
+};
+//# sourceMappingURL=swarm-handoff.js.map

package/dist/runtime/bridge/swarm-handoff.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/runtime/bridge/swarm-handoff.ts"],
+  "sourcesContent": ["import crypto from 'node:crypto';\n\nimport type { BridgeSendResult } from '../../domain/bridge-api.js';\nimport { OctoFlowError } from '../../domain/errors/index.js';\nimport { extractText } from '../../utils/extract-text.js';\nimport type { Pack, WorkerEntry } from '../orchestration/pack.js';\nimport type { PackMesh } from '../orchestration/pack.js';\n\nfunction handoffPayloadToPrompt(payload: unknown): string {\n  if (typeof payload === 'string') return payload;\n  return JSON.stringify(payload);\n}\n\nfunction handoffErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nasync function runSwarmHandoffTarget(\n  entry: WorkerEntry,\n  message: string,\n  contextId: string\n): Promise<string> {\n  if (entry.bridge) {\n    const result: BridgeSendResult = await entry.bridge.sendMessage({\n      contextId,\n      message: {\n        kind: 'message',\n        messageId: crypto.randomUUID(),\n        role: 'user',\n        parts: [{ kind: 'text', text: message }],\n      },\n    });\n    return extractText(result);\n  }\n\n  if (entry.client) {\n    const result = await entry.client.run(message);\n    return result.text;\n  }\n\n  throw new OctoFlowError(\n    'SWARM_HANDOFF_TARGET_UNAVAILABLE',\n    `Swarm peer \"${entry.name}\" has no bridge or client.`,\n    { target: entry.name }\n  );\n}\n\nexport function wireSwarmHandoffPeer(\n  pack: Pack,\n  mesh: PackMesh,\n  peerName: string\n): void {\n  mesh.onMessage(peerName, (request) => {\n    if (request.replyTo) return;\n    void (async () => {\n      const entry = pack.registry.get(peerName);\n      if (!entry) {\n        mesh.reply(request, {\n          ok: false,\n          error: `Swarm peer \"${peerName}\" is not registered.`,\n        });\n        return;\n      }\n      const result = await runSwarmHandoffTarget(\n        entry,\n        handoffPayloadToPrompt(request.payload),\n        `handoff-${request.id}`\n      );\n      mesh.reply(request, { ok: true, result });\n    })().catch((error: unknown) => {\n      mesh.reply(request, { ok: false, error: handoffErrorMessage(error) });\n    });\n  });\n}\n"],
+  "mappings": "AAAA,OAAO,YAAY;AAGnB,SAAS,qBAAqB;AAC9B,SAAS,mBAAmB;AAI5B,SAAS,uBAAuB,SAA0B;AACxD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,SAAO,KAAK,UAAU,OAAO;AAC/B;AAEA,SAAS,oBAAoB,OAAwB;AACnD,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,eAAe,sBACb,OACA,SACA,WACiB;AACjB,MAAI,MAAM,QAAQ;AAChB,UAAM,SAA2B,MAAM,MAAM,OAAO,YAAY;AAAA,MAC9D;AAAA,MACA,SAAS;AAAA,QACP,MAAM;AAAA,QACN,WAAW,OAAO,WAAW;AAAA,QAC7B,MAAM;AAAA,QACN,OAAO,CAAC,EAAE,MAAM,QAAQ,MAAM,QAAQ,CAAC;AAAA,MACzC;AAAA,IACF,CAAC;AACD,WAAO,YAAY,MAAM;AAAA,EAC3B;AAEA,MAAI,MAAM,QAAQ;AAChB,UAAM,SAAS,MAAM,MAAM,OAAO,IAAI,OAAO;AAC7C,WAAO,OAAO;AAAA,EAChB;AAEA,QAAM,IAAI;AAAA,IACR;AAAA,IACA,eAAe,MAAM,IAAI;AAAA,IACzB,EAAE,QAAQ,MAAM,KAAK;AAAA,EACvB;AACF;AAEO,SAAS,qBACd,MACA,MACA,UACM;AACN,OAAK,UAAU,UAAU,CAAC,YAAY;AACpC,QAAI,QAAQ,QAAS;AACrB,UAAM,YAAY;AAChB,YAAM,QAAQ,KAAK,SAAS,IAAI,QAAQ;AACxC,UAAI,CAAC,OAAO;AACV,aAAK,MAAM,SAAS;AAAA,UAClB,IAAI;AAAA,UACJ,OAAO,eAAe,QAAQ;AAAA,QAChC,CAAC;AACD;AAAA,MACF;AACA,YAAM,SAAS,MAAM;AAAA,QACnB;AAAA,QACA,uBAAuB,QAAQ,OAAO;AAAA,QACtC,WAAW,QAAQ,EAAE;AAAA,MACvB;AACA,WAAK,MAAM,SAAS,EAAE,IAAI,MAAM,OAAO,CAAC;AAAA,IAC1C,GAAG,EAAE,MAAM,CAAC,UAAmB;AAC7B,WAAK,MAAM,SAAS,EAAE,IAAI,OAAO,OAAO,oBAAoB,KAAK,EAAE,CAAC;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": []
+}

package/dist/runtime/bridge/task-executor-events.d.ts

@@ -0,0 +1,5 @@
+import type { AgentEvent, BackendName } from '../../domain/core-client.js';
+import type { ContextState } from '../sessions/context-manager.js';
+import type { TaskExecutorDeps } from './task-executor.js';
+export declare function handleAgentEvent(deps: TaskExecutorDeps, context: ContextState, taskId: string, event: AgentEvent, backend: BackendName): Promise<void>;
+//# sourceMappingURL=task-executor-events.d.ts.map

package/dist/runtime/bridge/task-executor-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor-events.d.ts","sourceRoot":"","sources":["../../../src/runtime/bridge/task-executor-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAEnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAM3D,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAuHf"}

package/dist/runtime/bridge/task-executor-events.js

@@ -0,0 +1,114 @@
+import { parseToolCallsFromText } from "../../capabilities/tool-call-parser.js";
+import { extractTextFromTask } from "../../utils/extract-text.js";
+import { createMessage, textPart } from "../../utils/messages.js";
+import { nowIso } from "../../utils/time.js";
+import { createMetadata } from "../sessions/context-manager.js";
+function isToolCallRequestText(text) {
+  return Boolean(text && parseToolCallsFromText(text));
+}
+async function handleAgentEvent(deps, context, taskId, event, backend) {
+  const task = await deps.store.getTask(taskId);
+  if (!task || task.status.state === "canceled") return;
+  const metadata = createMetadata(context, backend, {
+    sessionId: event.sessionId,
+    sourceEvent: event
+  });
+  if (event.type === "text" && event.text && !isToolCallRequestText(event.text)) {
+    await deps.store.appendArtifact({
+      taskId,
+      artifact: {
+        artifactId: "assistant-response",
+        name: "assistant-response",
+        parts: [textPart(event.text)],
+        metadata
+      },
+      append: true,
+      lastChunk: false,
+      metadata
+    });
+    await deps.emitEvent?.("bridge:message", {
+      taskId,
+      contextId: context.id,
+      backend,
+      text: event.text
+    });
+    return;
+  }
+  if (event.type === "thinking" && event.text) {
+    await deps.emitEvent?.("bridge:thinking", {
+      taskId,
+      contextId: context.id,
+      backend,
+      text: event.text
+    });
+    return;
+  }
+  if (event.type === "input-required" || event.type === "auth-required") {
+    await deps.store.updateStatus({
+      taskId,
+      status: {
+        state: event.type,
+        timestamp: nowIso(),
+        ...event.text ? {
+          message: createMessage({
+            role: "agent",
+            contextId: task.contextId,
+            taskId,
+            parts: [textPart(event.text)],
+            metadata
+          })
+        } : {}
+      },
+      final: true,
+      metadata
+    });
+    return;
+  }
+  if (event.type === "result") {
+    if (event.sessionId != null) {
+      await deps.store.updateBridgeMetadata(taskId, metadata.bridge);
+    }
+    if (event.costUsd && deps.costAccumulator) {
+      deps.costAccumulator.record(
+        context.id,
+        context.tenant,
+        event.costUsd,
+        event.usage ?? null,
+        context.options.model,
+        taskId
+      );
+      const check = deps.costAccumulator.checkBudget(
+        context.id,
+        context.tenant,
+        taskId
+      );
+      if (check.status === "hard-limit" && check.info.scope === "task") {
+        deps.abortControllers.get(taskId)?.abort();
+      }
+    }
+    if (event.text && !isToolCallRequestText(event.text) && extractTextFromTask(task) === "") {
+      await deps.store.appendArtifact({
+        taskId,
+        artifact: {
+          artifactId: "assistant-response",
+          name: "assistant-response",
+          parts: [textPart(event.text)],
+          metadata
+        },
+        append: true,
+        lastChunk: true,
+        metadata
+      });
+    }
+    return;
+  }
+  await deps.store.updateStatus({
+    taskId,
+    status: { state: "working", timestamp: nowIso() },
+    metadata
+  });
+}
+export {
+  handleAgentEvent
+};
+//# sourceMappingURL=task-executor-events.js.map

package/dist/runtime/bridge/task-executor-events.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/runtime/bridge/task-executor-events.ts"],
+  "sourcesContent": ["import { parseToolCallsFromText } from '../../capabilities/tool-call-parser.js';\nimport type { AgentEvent, BackendName } from '../../domain/core-client.js';\nimport { extractTextFromTask } from '../../utils/extract-text.js';\nimport { createMessage, textPart } from '../../utils/messages.js';\nimport { nowIso } from '../../utils/time.js';\nimport type { ContextState } from '../sessions/context-manager.js';\nimport { createMetadata } from '../sessions/context-manager.js';\nimport type { TaskExecutorDeps } from './task-executor.js';\n\nfunction isToolCallRequestText(text: string | undefined): boolean {\n  return Boolean(text && parseToolCallsFromText(text));\n}\n\nexport async function handleAgentEvent(\n  deps: TaskExecutorDeps,\n  context: ContextState,\n  taskId: string,\n  event: AgentEvent,\n  backend: BackendName\n): Promise<void> {\n  const task = await deps.store.getTask(taskId);\n  if (!task || task.status.state === 'canceled') return;\n\n  const metadata = createMetadata(context, backend, {\n    sessionId: event.sessionId,\n    sourceEvent: event,\n  });\n\n  if (\n    event.type === 'text' &&\n    event.text &&\n    !isToolCallRequestText(event.text)\n  ) {\n    await deps.store.appendArtifact({\n      taskId,\n      artifact: {\n        artifactId: 'assistant-response',\n        name: 'assistant-response',\n        parts: [textPart(event.text)],\n        metadata,\n      },\n      append: true,\n      lastChunk: false,\n      metadata,\n    });\n    await deps.emitEvent?.('bridge:message', {\n      taskId,\n      contextId: context.id,\n      backend,\n      text: event.text,\n    });\n    return;\n  }\n\n  if (event.type === 'thinking' && event.text) {\n    await deps.emitEvent?.('bridge:thinking', {\n      taskId,\n      contextId: context.id,\n      backend,\n      text: event.text,\n    });\n    return;\n  }\n\n  if (event.type === 'input-required' || event.type === 'auth-required') {\n    await deps.store.updateStatus({\n      taskId,\n      status: {\n        state: event.type,\n        timestamp: nowIso(),\n        ...(event.text\n          ? {\n              message: createMessage({\n                role: 'agent',\n                contextId: task.contextId,\n                taskId,\n                parts: [textPart(event.text)],\n                metadata,\n              }),\n            }\n          : {}),\n      },\n      final: true,\n      metadata,\n    });\n    return;\n  }\n\n  if (event.type === 'result') {\n    if (event.sessionId != null) {\n      await deps.store.updateBridgeMetadata(taskId, metadata.bridge);\n    }\n\n    if (event.costUsd && deps.costAccumulator) {\n      deps.costAccumulator.record(\n        context.id,\n        context.tenant,\n        event.costUsd,\n        event.usage ?? null,\n        context.options.model,\n        taskId\n      );\n      const check = deps.costAccumulator.checkBudget(\n        context.id,\n        context.tenant,\n        taskId\n      );\n      if (check.status === 'hard-limit' && check.info.scope === 'task') {\n        deps.abortControllers.get(taskId)?.abort();\n      }\n    }\n\n    if (\n      event.text &&\n      !isToolCallRequestText(event.text) &&\n      extractTextFromTask(task) === ''\n    ) {\n      await deps.store.appendArtifact({\n        taskId,\n        artifact: {\n          artifactId: 'assistant-response',\n          name: 'assistant-response',\n          parts: [textPart(event.text)],\n          metadata,\n        },\n        append: true,\n        lastChunk: true,\n        metadata,\n      });\n    }\n    return;\n  }\n\n  await deps.store.updateStatus({\n    taskId,\n    status: { state: 'working', timestamp: nowIso() },\n    metadata,\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/runtime/bridge/task-executor-fallback.d.ts

@@ -0,0 +1,12 @@
+import type { BridgeFallbackOptions, BridgeSendMessageParams } from '../../domain/bridge-api.js';
+import type { BackendName } from '../../domain/core-client.js';
+import type { Task } from '../../domain/core-task.js';
+import type { ContextState, SessionLike } from '../sessions/context-manager.js';
+import type { TaskExecutorDeps } from './task-executor.js';
+export declare function resolveFallbackOptions(params: BridgeSendMessageParams, priorityLength: number): Required<BridgeFallbackOptions>;
+export declare function canFallbackTask(deps: TaskExecutorDeps, task: Task, params: BridgeSendMessageParams, context?: ContextState, currentBackend?: BackendName, nextBackend?: BackendName): Promise<boolean>;
+export declare function tryFallback(deps: TaskExecutorDeps, context: ContextState, taskId: string, backend: BackendName, error: unknown, attemptedBackends: BackendName[], params: BridgeSendMessageParams): Promise<{
+    backend: BackendName;
+    session: SessionLike;
+} | null>;
+//# sourceMappingURL=task-executor-fallback.d.ts.map

package/dist/runtime/bridge/task-executor-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor-fallback.d.ts","sourceRoot":"","sources":["../../../src/runtime/bridge/task-executor-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAGtD,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAEhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,cAAc,EAAE,MAAM,GACrB,QAAQ,CAAC,qBAAqB,CAAC,CAgBjC;AAED,wBAAsB,eAAe,CACnC,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,uBAAuB,EAC/B,OAAO,CAAC,EAAE,YAAY,EACtB,cAAc,CAAC,EAAE,WAAW,EAC5B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,OAAO,CAAC,CAyBlB;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,OAAO,EACd,iBAAiB,EAAE,WAAW,EAAE,EAChC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GAAG,IAAI,CAAC,CAmDhE"}

package/dist/runtime/bridge/task-executor-fallback.js

@@ -0,0 +1,86 @@
+import { toFallbackInfo } from "../../utils/operation-info.js";
+import { nowIso } from "../../utils/time.js";
+import { createMetadata, isApiBackend } from "../sessions/context-manager.js";
+function resolveFallbackOptions(params, priorityLength) {
+  if (!params.fallback) {
+    return { enabled: false, maxBackends: priorityLength };
+  }
+  if (params.fallback === true) {
+    return { enabled: true, maxBackends: priorityLength };
+  }
+  return {
+    enabled: params.fallback.enabled ?? true,
+    maxBackends: Math.max(
+      1,
+      Math.min(priorityLength, params.fallback.maxBackends ?? priorityLength)
+    )
+  };
+}
+async function canFallbackTask(deps, task, params, context, currentBackend, nextBackend) {
+  if (deps.mobilityEnabled) {
+    const maxSwitches = deps.maxSwitchesPerContext ?? 2;
+    if (context && context.switchCount >= maxSwitches) return false;
+    if (!(deps.allowCrossFamilySwitch ?? true) && currentBackend && nextBackend && isApiBackend(currentBackend) !== isApiBackend(nextBackend)) {
+      return false;
+    }
+    return true;
+  }
+  if (params.taskId) return false;
+  if ((task.artifacts?.length ?? 0) > 0) return false;
+  if ((task.history?.length ?? 0) > 1) return false;
+  const tasksInContext = await deps.store.listTasks({
+    contextId: task.contextId,
+    tenant: task.tenant,
+    limit: 2
+  });
+  return tasksInContext.totalSize <= 1;
+}
+async function tryFallback(deps, context, taskId, backend, error, attemptedBackends, params) {
+  if (!deps.switchBackend) return null;
+  const options = resolveFallbackOptions(
+    params,
+    context.options.priority.length
+  );
+  if (!options.enabled || attemptedBackends.length >= options.maxBackends) {
+    return null;
+  }
+  const task = await deps.store.getTask(taskId);
+  if (!task) return null;
+  const nextCandidates = context.options.priority.filter(
+    (b) => !attemptedBackends.includes(b)
+  );
+  const nextBackend = nextCandidates[0];
+  if (!await canFallbackTask(deps, task, params, context, backend, nextBackend)) {
+    return null;
+  }
+  const next = await deps.switchBackend(context, attemptedBackends);
+  if (!next) return null;
+  const fallbackInfo = toFallbackInfo({
+    attempt: attemptedBackends.length,
+    error,
+    fromBackend: backend,
+    maxBackends: options.maxBackends,
+    phase: "session",
+    toBackend: next.backend
+  });
+  await deps.emitEvent?.("backend:fallback", {
+    ...fallbackInfo,
+    taskId,
+    contextId: context.id
+  });
+  await params.onFallback?.(fallbackInfo);
+  await deps.store.updateStatus({
+    taskId,
+    status: { state: "working", timestamp: nowIso() },
+    metadata: createMetadata(context, next.backend, {
+      fallback: { ...fallbackInfo, status: "scheduled" }
+    })
+  });
+  return next;
+}
+export {
+  canFallbackTask,
+  resolveFallbackOptions,
+  tryFallback
+};
+//# sourceMappingURL=task-executor-fallback.js.map

package/dist/runtime/bridge/task-executor-fallback.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/runtime/bridge/task-executor-fallback.ts"],
+  "sourcesContent": ["import type {\n  BridgeFallbackOptions,\n  BridgeSendMessageParams,\n} from '../../domain/bridge-api.js';\nimport type { BackendName } from '../../domain/core-client.js';\nimport type { Task } from '../../domain/core-task.js';\nimport { toFallbackInfo } from '../../utils/operation-info.js';\nimport { nowIso } from '../../utils/time.js';\nimport type { ContextState, SessionLike } from '../sessions/context-manager.js';\nimport { createMetadata, isApiBackend } from '../sessions/context-manager.js';\nimport type { TaskExecutorDeps } from './task-executor.js';\n\nexport function resolveFallbackOptions(\n  params: BridgeSendMessageParams,\n  priorityLength: number\n): Required<BridgeFallbackOptions> {\n  if (!params.fallback) {\n    return { enabled: false, maxBackends: priorityLength };\n  }\n\n  if (params.fallback === true) {\n    return { enabled: true, maxBackends: priorityLength };\n  }\n\n  return {\n    enabled: params.fallback.enabled ?? true,\n    maxBackends: Math.max(\n      1,\n      Math.min(priorityLength, params.fallback.maxBackends ?? priorityLength)\n    ),\n  };\n}\n\nexport async function canFallbackTask(\n  deps: TaskExecutorDeps,\n  task: Task,\n  params: BridgeSendMessageParams,\n  context?: ContextState,\n  currentBackend?: BackendName,\n  nextBackend?: BackendName\n): Promise<boolean> {\n  if (deps.mobilityEnabled) {\n    const maxSwitches = deps.maxSwitchesPerContext ?? 2;\n    if (context && context.switchCount >= maxSwitches) return false;\n    if (\n      !(deps.allowCrossFamilySwitch ?? true) &&\n      currentBackend &&\n      nextBackend &&\n      isApiBackend(currentBackend) !== isApiBackend(nextBackend)\n    ) {\n      return false;\n    }\n    return true;\n  }\n\n  if (params.taskId) return false;\n  if ((task.artifacts?.length ?? 0) > 0) return false;\n  if ((task.history?.length ?? 0) > 1) return false;\n\n  const tasksInContext = await deps.store.listTasks({\n    contextId: task.contextId,\n    tenant: task.tenant,\n    limit: 2,\n  });\n  return tasksInContext.totalSize <= 1;\n}\n\nexport async function tryFallback(\n  deps: TaskExecutorDeps,\n  context: ContextState,\n  taskId: string,\n  backend: BackendName,\n  error: unknown,\n  attemptedBackends: BackendName[],\n  params: BridgeSendMessageParams\n): Promise<{ backend: BackendName; session: SessionLike } | null> {\n  if (!deps.switchBackend) return null;\n\n  const options = resolveFallbackOptions(\n    params,\n    context.options.priority.length\n  );\n  if (!options.enabled || attemptedBackends.length >= options.maxBackends) {\n    return null;\n  }\n\n  const task = await deps.store.getTask(taskId);\n  if (!task) return null;\n\n  const nextCandidates = context.options.priority.filter(\n    (b) => !attemptedBackends.includes(b)\n  );\n  const nextBackend = nextCandidates[0];\n  if (\n    !(await canFallbackTask(deps, task, params, context, backend, nextBackend))\n  ) {\n    return null;\n  }\n\n  const next = await deps.switchBackend(context, attemptedBackends);\n  if (!next) return null;\n\n  const fallbackInfo = toFallbackInfo({\n    attempt: attemptedBackends.length,\n    error,\n    fromBackend: backend,\n    maxBackends: options.maxBackends,\n    phase: 'session',\n    toBackend: next.backend,\n  });\n  await deps.emitEvent?.('backend:fallback', {\n    ...fallbackInfo,\n    taskId,\n    contextId: context.id,\n  });\n  await params.onFallback?.(fallbackInfo);\n\n  await deps.store.updateStatus({\n    taskId,\n    status: { state: 'working', timestamp: nowIso() },\n    metadata: createMetadata(context, next.backend, {\n      fallback: { ...fallbackInfo, status: 'scheduled' },\n    }),\n  });\n\n  return next;\n}\n"],
+  "mappings": "AAMA,SAAS,sBAAsB;AAC/B,SAAS,cAAc;AAEvB,SAAS,gBAAgB,oBAAoB;AAGtC,SAAS,uBACd,QACA,gBACiC;AACjC,MAAI,CAAC,OAAO,UAAU;AACpB,WAAO,EAAE,SAAS,OAAO,aAAa,eAAe;AAAA,EACvD;AAEA,MAAI,OAAO,aAAa,MAAM;AAC5B,WAAO,EAAE,SAAS,MAAM,aAAa,eAAe;AAAA,EACtD;AAEA,SAAO;AAAA,IACL,SAAS,OAAO,SAAS,WAAW;AAAA,IACpC,aAAa,KAAK;AAAA,MAChB;AAAA,MACA,KAAK,IAAI,gBAAgB,OAAO,SAAS,eAAe,cAAc;AAAA,IACxE;AAAA,EACF;AACF;AAEA,eAAsB,gBACpB,MACA,MACA,QACA,SACA,gBACA,aACkB;AAClB,MAAI,KAAK,iBAAiB;AACxB,UAAM,cAAc,KAAK,yBAAyB;AAClD,QAAI,WAAW,QAAQ,eAAe,YAAa,QAAO;AAC1D,QACE,EAAE,KAAK,0BAA0B,SACjC,kBACA,eACA,aAAa,cAAc,MAAM,aAAa,WAAW,GACzD;AACA,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,OAAQ,QAAO;AAC1B,OAAK,KAAK,WAAW,UAAU,KAAK,EAAG,QAAO;AAC9C,OAAK,KAAK,SAAS,UAAU,KAAK,EAAG,QAAO;AAE5C,QAAM,iBAAiB,MAAM,KAAK,MAAM,UAAU;AAAA,IAChD,WAAW,KAAK;AAAA,IAChB,QAAQ,KAAK;AAAA,IACb,OAAO;AAAA,EACT,CAAC;AACD,SAAO,eAAe,aAAa;AACrC;AAEA,eAAsB,YACpB,MACA,SACA,QACA,SACA,OACA,mBACA,QACgE;AAChE,MAAI,CAAC,KAAK,cAAe,QAAO;AAEhC,QAAM,UAAU;AAAA,IACd;AAAA,IACA,QAAQ,QAAQ,SAAS;AAAA,EAC3B;AACA,MAAI,CAAC,QAAQ,WAAW,kBAAkB,UAAU,QAAQ,aAAa;AACvE,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,MAAM,KAAK,MAAM,QAAQ,MAAM;AAC5C,MAAI,CAAC,KAAM,QAAO;AAElB,QAAM,iBAAiB,QAAQ,QAAQ,SAAS;AAAA,IAC9C,CAAC,MAAM,CAAC,kBAAkB,SAAS,CAAC;AAAA,EACtC;AACA,QAAM,cAAc,eAAe,CAAC;AACpC,MACE,CAAE,MAAM,gBAAgB,MAAM,MAAM,QAAQ,SAAS,SAAS,WAAW,GACzE;AACA,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,MAAM,KAAK,cAAc,SAAS,iBAAiB;AAChE,MAAI,CAAC,KAAM,QAAO;AAElB,QAAM,eAAe,eAAe;AAAA,IAClC,SAAS,kBAAkB;AAAA,IAC3B;AAAA,IACA,aAAa;AAAA,IACb,aAAa,QAAQ;AAAA,IACrB,OAAO;AAAA,IACP,WAAW,KAAK;AAAA,EAClB,CAAC;AACD,QAAM,KAAK,YAAY,oBAAoB;AAAA,IACzC,GAAG;AAAA,IACH;AAAA,IACA,WAAW,QAAQ;AAAA,EACrB,CAAC;AACD,QAAM,OAAO,aAAa,YAAY;AAEtC,QAAM,KAAK,MAAM,aAAa;AAAA,IAC5B;AAAA,IACA,QAAQ,EAAE,OAAO,WAAW,WAAW,OAAO,EAAE;AAAA,IAChD,UAAU,eAAe,SAAS,KAAK,SAAS;AAAA,MAC9C,UAAU,EAAE,GAAG,cAAc,QAAQ,YAAY;AAAA,IACnD,CAAC;AAAA,EACH,CAAC;AAED,SAAO;AACT;",
+  "names": []
+}

package/dist/runtime/bridge/task-executor-history.d.ts

@@ -0,0 +1,22 @@
+import type { TaskStore } from '../../adapters/data/task-store/index.js';
+import type { BridgeHistoryStrategy } from '../../domain/bridge-api.js';
+import type { BackendCapabilities } from '../../domain/contracts/backends.js';
+import type { Message } from '../../domain/core-task.js';
+export declare function getConversationHistory(store: TaskStore, contextId: string, tenant: string | undefined, currentMessageId: string, strategy?: BridgeHistoryStrategy): Promise<Message[]>;
+/**
+ * Resolve `'auto'` to a concrete strategy based on backend capabilities
+ *. When the backend natively persists sessions, callers should send
+ * only the current turn — replaying full history would duplicate the
+ * backend's internal transcript. Otherwise, replay everything.
+ *
+ * Explicit strategies pass through unchanged.
+ */
+export declare function resolveHistoryStrategy(requested: BridgeHistoryStrategy | undefined, capabilities: Pick<BackendCapabilities, 'sessionPersistence'> | undefined): BridgeHistoryStrategy;
+export declare function applyHistoryStrategy(history: Message[], strategy: BridgeHistoryStrategy): Message[];
+/**
+ * Mirrors the skill-protection detection used when building `HistoryEntry`
+ * records for compaction. Kept here so the strategy filter and the
+ * compaction layer agree on what "protected" means.
+ */
+export declare function isMessageProtected(message: Message): boolean;
+//# sourceMappingURL=task-executor-history.d.ts.map

package/dist/runtime/bridge/task-executor-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor-history.d.ts","sourceRoot":"","sources":["../../../src/runtime/bridge/task-executor-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,gBAAgB,EAAE,MAAM,EACxB,QAAQ,GAAE,qBAA8B,GACvC,OAAO,CAAC,OAAO,EAAE,CAAC,CAapB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,qBAAqB,GAAG,SAAS,EAC5C,YAAY,EAAE,IAAI,CAAC,mBAAmB,EAAE,oBAAoB,CAAC,GAAG,SAAS,GACxE,qBAAqB,CAIvB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAAE,EAClB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,EAAE,CAoCX;AAiCD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAc5D"}

package/dist/runtime/bridge/task-executor-history.js

@@ -0,0 +1,89 @@
+async function getConversationHistory(store, contextId, tenant, currentMessageId, strategy = "full") {
+  const conversation = await store.getConversation(contextId, {
+    tenant,
+    includeArtifacts: false,
+    includeHistory: true,
+    includeTasks: false
+  });
+  const history = (conversation?.history ?? []).filter(
+    (message) => message.messageId !== currentMessageId
+  );
+  return applyHistoryStrategy(history, strategy);
+}
+function resolveHistoryStrategy(requested, capabilities) {
+  const strategy = requested ?? "full";
+  if (strategy !== "auto") return strategy;
+  return capabilities?.sessionPersistence ? { kind: "lastN", n: 0 } : "full";
+}
+function applyHistoryStrategy(history, strategy) {
+  if (strategy === "full" || strategy === "auto") return history;
+  let kept;
+  if (strategy.kind === "lastN") {
+    kept = takeLast(history, strategy.n);
+  } else if (strategy.kind === "truncate-oldest") {
+    kept = takeLast(history, strategy.keepRecent);
+  } else if (strategy.kind === "since") {
+    const cutoff = Date.parse(strategy.isoDate);
+    if (Number.isNaN(cutoff)) return history;
+    kept = history.filter((message) => {
+      const ts = readTimestamp(message);
+      return ts == null || ts >= cutoff;
+    });
+  } else {
+    return history;
+  }
+  if (kept.length === history.length) return kept;
+  const keptIds = /* @__PURE__ */ new Set();
+  for (const message of kept) keptIds.add(message.messageId);
+  const result = [];
+  for (const message of history) {
+    if (keptIds.has(message.messageId) || isMessageProtected(message)) {
+      result.push(message);
+    }
+  }
+  return result;
+}
+function takeLast(history, count) {
+  const keep = Math.max(0, Math.trunc(count));
+  if (keep === 0) return [];
+  return history.slice(-keep);
+}
+function readTimestamp(message) {
+  const ts = message.metadata?.timestamp;
+  if (typeof ts === "string") {
+    const parsed = Date.parse(ts);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  if (typeof ts === "number") return ts;
+  return null;
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function recordSignalsProtection(record) {
+  if (!record) return false;
+  if (record.skillProtected === true || record.skill_protected === true) {
+    return true;
+  }
+  if (record.source === "skill") return true;
+  return false;
+}
+function isMessageProtected(message) {
+  const metadata = message.metadata;
+  if (!metadata) return false;
+  if (recordSignalsProtection(metadata)) return true;
+  if (isPlainRecord(metadata.meta) && recordSignalsProtection(metadata.meta)) {
+    return true;
+  }
+  if (isPlainRecord(metadata.actionResultMeta) && recordSignalsProtection(metadata.actionResultMeta)) {
+    return true;
+  }
+  return false;
+}
+export {
+  applyHistoryStrategy,
+  getConversationHistory,
+  isMessageProtected,
+  resolveHistoryStrategy
+};
+//# sourceMappingURL=task-executor-history.js.map

package/dist/runtime/bridge/task-executor-history.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/runtime/bridge/task-executor-history.ts"],
+  "sourcesContent": ["import type { TaskStore } from '../../adapters/data/task-store/index.js';\nimport type { BridgeHistoryStrategy } from '../../domain/bridge-api.js';\nimport type { BackendCapabilities } from '../../domain/contracts/backends.js';\nimport type { Message } from '../../domain/core-task.js';\n\nexport async function getConversationHistory(\n  store: TaskStore,\n  contextId: string,\n  tenant: string | undefined,\n  currentMessageId: string,\n  strategy: BridgeHistoryStrategy = 'full'\n): Promise<Message[]> {\n  const conversation = await store.getConversation(contextId, {\n    tenant,\n    includeArtifacts: false,\n    includeHistory: true,\n    includeTasks: false,\n  });\n\n  const history = (conversation?.history ?? []).filter(\n    (message) => message.messageId !== currentMessageId\n  );\n\n  return applyHistoryStrategy(history, strategy);\n}\n\n/**\n * Resolve `'auto'` to a concrete strategy based on backend capabilities\n *. When the backend natively persists sessions, callers should send\n * only the current turn \u2014 replaying full history would duplicate the\n * backend's internal transcript. Otherwise, replay everything.\n *\n * Explicit strategies pass through unchanged.\n */\nexport function resolveHistoryStrategy(\n  requested: BridgeHistoryStrategy | undefined,\n  capabilities: Pick<BackendCapabilities, 'sessionPersistence'> | undefined\n): BridgeHistoryStrategy {\n  const strategy: BridgeHistoryStrategy = requested ?? 'full';\n  if (strategy !== 'auto') return strategy;\n  return capabilities?.sessionPersistence ? { kind: 'lastN', n: 0 } : 'full';\n}\n\nexport function applyHistoryStrategy(\n  history: Message[],\n  strategy: BridgeHistoryStrategy\n): Message[] {\n  // 'auto' is resolved by resolveHistoryStrategy() before reaching this\n  // function; treat a leaked 'auto' as the 'full' default rather than crash.\n  if (strategy === 'full' || strategy === 'auto') return history;\n\n  let kept: Message[];\n  if (strategy.kind === 'lastN') {\n    kept = takeLast(history, strategy.n);\n  } else if (strategy.kind === 'truncate-oldest') {\n    kept = takeLast(history, strategy.keepRecent);\n  } else if (strategy.kind === 'since') {\n    const cutoff = Date.parse(strategy.isoDate);\n    if (Number.isNaN(cutoff)) return history;\n    kept = history.filter((message) => {\n      const ts = readTimestamp(message);\n      return ts == null || ts >= cutoff;\n    });\n  } else {\n    return history;\n  }\n\n  // Strategy-aware protection: re-include skill-protected messages that fell\n  // outside the window. The strategy reduces what gets *replayed*, but it\n  // must not bypass the protection layer \u2014 otherwise compaction never sees\n  // those entries and `protected: true` becomes meaningless for old turns.\n  // Walk the original history once so order is preserved naturally.\n  if (kept.length === history.length) return kept;\n  const keptIds = new Set<string>();\n  for (const message of kept) keptIds.add(message.messageId);\n  const result: Message[] = [];\n  for (const message of history) {\n    if (keptIds.has(message.messageId) || isMessageProtected(message)) {\n      result.push(message);\n    }\n  }\n  return result;\n}\n\nfunction takeLast(history: Message[], count: number): Message[] {\n  const keep = Math.max(0, Math.trunc(count));\n  if (keep === 0) return [];\n  return history.slice(-keep);\n}\n\nfunction readTimestamp(message: Message): number | null {\n  const ts = message.metadata?.timestamp;\n  if (typeof ts === 'string') {\n    const parsed = Date.parse(ts);\n    return Number.isNaN(parsed) ? null : parsed;\n  }\n  if (typeof ts === 'number') return ts;\n  return null;\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction recordSignalsProtection(\n  record: Record<string, unknown> | undefined\n): boolean {\n  if (!record) return false;\n  if (record.skillProtected === true || record.skill_protected === true) {\n    return true;\n  }\n  if (record.source === 'skill') return true;\n  return false;\n}\n\n/**\n * Mirrors the skill-protection detection used when building `HistoryEntry`\n * records for compaction. Kept here so the strategy filter and the\n * compaction layer agree on what \"protected\" means.\n */\nexport function isMessageProtected(message: Message): boolean {\n  const metadata = message.metadata;\n  if (!metadata) return false;\n  if (recordSignalsProtection(metadata)) return true;\n  if (isPlainRecord(metadata.meta) && recordSignalsProtection(metadata.meta)) {\n    return true;\n  }\n  if (\n    isPlainRecord(metadata.actionResultMeta) &&\n    recordSignalsProtection(metadata.actionResultMeta)\n  ) {\n    return true;\n  }\n  return false;\n}\n"],
+  "mappings": "AAKA,eAAsB,uBACpB,OACA,WACA,QACA,kBACA,WAAkC,QACd;AACpB,QAAM,eAAe,MAAM,MAAM,gBAAgB,WAAW;AAAA,IAC1D;AAAA,IACA,kBAAkB;AAAA,IAClB,gBAAgB;AAAA,IAChB,cAAc;AAAA,EAChB,CAAC;AAED,QAAM,WAAW,cAAc,WAAW,CAAC,GAAG;AAAA,IAC5C,CAAC,YAAY,QAAQ,cAAc;AAAA,EACrC;AAEA,SAAO,qBAAqB,SAAS,QAAQ;AAC/C;AAUO,SAAS,uBACd,WACA,cACuB;AACvB,QAAM,WAAkC,aAAa;AACrD,MAAI,aAAa,OAAQ,QAAO;AAChC,SAAO,cAAc,qBAAqB,EAAE,MAAM,SAAS,GAAG,EAAE,IAAI;AACtE;AAEO,SAAS,qBACd,SACA,UACW;AAGX,MAAI,aAAa,UAAU,aAAa,OAAQ,QAAO;AAEvD,MAAI;AACJ,MAAI,SAAS,SAAS,SAAS;AAC7B,WAAO,SAAS,SAAS,SAAS,CAAC;AAAA,EACrC,WAAW,SAAS,SAAS,mBAAmB;AAC9C,WAAO,SAAS,SAAS,SAAS,UAAU;AAAA,EAC9C,WAAW,SAAS,SAAS,SAAS;AACpC,UAAM,SAAS,KAAK,MAAM,SAAS,OAAO;AAC1C,QAAI,OAAO,MAAM,MAAM,EAAG,QAAO;AACjC,WAAO,QAAQ,OAAO,CAAC,YAAY;AACjC,YAAM,KAAK,cAAc,OAAO;AAChC,aAAO,MAAM,QAAQ,MAAM;AAAA,IAC7B,CAAC;AAAA,EACH,OAAO;AACL,WAAO;AAAA,EACT;AAOA,MAAI,KAAK,WAAW,QAAQ,OAAQ,QAAO;AAC3C,QAAM,UAAU,oBAAI,IAAY;AAChC,aAAW,WAAW,KAAM,SAAQ,IAAI,QAAQ,SAAS;AACzD,QAAM,SAAoB,CAAC;AAC3B,aAAW,WAAW,SAAS;AAC7B,QAAI,QAAQ,IAAI,QAAQ,SAAS,KAAK,mBAAmB,OAAO,GAAG;AACjE,aAAO,KAAK,OAAO;AAAA,IACrB;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,SAAS,SAAoB,OAA0B;AAC9D,QAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC;AAC1C,MAAI,SAAS,EAAG,QAAO,CAAC;AACxB,SAAO,QAAQ,MAAM,CAAC,IAAI;AAC5B;AAEA,SAAS,cAAc,SAAiC;AACtD,QAAM,KAAK,QAAQ,UAAU;AAC7B,MAAI,OAAO,OAAO,UAAU;AAC1B,UAAM,SAAS,KAAK,MAAM,EAAE;AAC5B,WAAO,OAAO,MAAM,MAAM,IAAI,OAAO;AAAA,EACvC;AACA,MAAI,OAAO,OAAO,SAAU,QAAO;AACnC,SAAO;AACT;AAEA,SAAS,cAAc,OAAkD;AACvE,SAAO,QAAQ,KAAK,KAAK,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,wBACP,QACS;AACT,MAAI,CAAC,OAAQ,QAAO;AACpB,MAAI,OAAO,mBAAmB,QAAQ,OAAO,oBAAoB,MAAM;AACrE,WAAO;AAAA,EACT;AACA,MAAI,OAAO,WAAW,QAAS,QAAO;AACtC,SAAO;AACT;AAOO,SAAS,mBAAmB,SAA2B;AAC5D,QAAM,WAAW,QAAQ;AACzB,MAAI,CAAC,SAAU,QAAO;AACtB,MAAI,wBAAwB,QAAQ,EAAG,QAAO;AAC9C,MAAI,cAAc,SAAS,IAAI,KAAK,wBAAwB,SAAS,IAAI,GAAG;AAC1E,WAAO;AAAA,EACT;AACA,MACE,cAAc,SAAS,gBAAgB,KACvC,wBAAwB,SAAS,gBAAgB,GACjD;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/runtime/bridge/task-executor.d.ts

@@ -0,0 +1,43 @@
+import type { CostAccumulator } from '../../adapters/data/budget/cost-accumulator.js';
+import type { TaskStore } from '../../adapters/data/task-store/index.js';
+import type { BridgeSendMessageParams } from '../../domain/bridge-api.js';
+import type { BackendName, RunResult } from '../../domain/core-client.js';
+import type { ErrorInfo, RetryInfo } from '../../domain/core-task.js';
+import type { CircuitBreakerRegistry } from '../../resilience/circuit-breaker.js';
+import type { ContextState, SessionLike } from '../sessions/context-manager.js';
+import type { BridgeEventMap } from './events.js';
+export { handleAgentEvent } from './task-executor-events.js';
+export { canFallbackTask, resolveFallbackOptions, tryFallback, } from './task-executor-fallback.js';
+export { applyHistoryStrategy, getConversationHistory, resolveHistoryStrategy, } from './task-executor-history.js';
+export interface TaskExecutorDeps {
+    store: TaskStore;
+    abortControllers: Map<string, AbortController>;
+    circuitBreaker?: CircuitBreakerRegistry;
+    costAccumulator?: CostAccumulator;
+    onSessionResolved?: (context: ContextState, backend: BackendName, cliSessionId: string) => Promise<void>;
+    switchBackend?: (context: ContextState, excludedBackends: BackendName[]) => Promise<{
+        backend: BackendName;
+        session: SessionLike;
+    } | null>;
+    mobilityEnabled?: boolean;
+    maxSwitchesPerContext?: number;
+    allowCrossFamilySwitch?: boolean;
+    /** Emit a bridge event. Optional — existing behavior is unchanged when absent. */
+    emitEvent?: <K extends keyof BridgeEventMap>(event: K, data: BridgeEventMap[K]) => Promise<void>;
+}
+export declare function finalizeTask(deps: TaskExecutorDeps, context: ContextState, taskId: string, result: RunResult, backend: BackendName, historyLength?: number, cacheTelemetry?: {
+    partsCached?: number;
+    backendSupportsCaching?: boolean;
+}): Promise<void>;
+export declare function failTask(deps: TaskExecutorDeps, context: ContextState, taskId: string, error: unknown, backend: BackendName, errorInfo: ErrorInfo, retry?: RetryInfo & {
+    status: 'exhausted' | 'scheduled';
+}): Promise<void>;
+export declare function scheduleRetry(deps: TaskExecutorDeps, context: ContextState, taskId: string, backend: BackendName, error: unknown, attempt: number, maxRetries: number, params: BridgeSendMessageParams): Promise<void>;
+export declare function recoverFromError(deps: TaskExecutorDeps, context: ContextState, taskId: string, error: unknown, backend: BackendName, attempt: number, maxRetries: number, attemptedBackends: BackendName[], params: BridgeSendMessageParams): Promise<{
+    kind: 'fallback';
+    backend: BackendName;
+    session: SessionLike;
+} | {
+    kind: 'retry';
+} | null>;
+//# sourceMappingURL=task-executor.d.ts.map

package/dist/runtime/bridge/task-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../../src/runtime/bridge/task-executor.ts"],"names":[],"mappings":"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"}