@botbotgo/agent-harness 0.0.99 → 0.0.100

package/README.md

@@ -79,7 +79,7 @@ Boundary documents live in:
 - `docs/model-layering.md`
 - `docs/coding-agent-guide.md`
 
-ACP is the intended future client protocol direction when external tools need a standard runtime boundary. The harness should become ACP-capable while keeping runtime lifecycle, persistence, recovery, and governance harness-owned.
+`deepagents-acp` is the required external protocol direction when external tools need a standard runtime boundary. The harness should conform to `deepagents-acp` semantics at that boundary while keeping runtime lifecycle, persistence, recovery, and governance harness-owned.
 
 Recommended orchestration shape for long-running flows:
 
@@ -262,7 +262,7 @@ const result = await run(runtime, {
 });
 ```
 
-`agentId: "auto"` evaluates ordered routing rules in `config/runtime/workspace.yaml`, then `routing.defaultAgentId`, and only falls back to model routing when `routing.modelRouting: true`.
+`agentId: "auto"` evaluates ordered routing rules in `config/runtime/workspace.yaml`, then `routing.defaultAgentId`, and otherwise falls back to the default runtime entry host.
 
 ### Stream Output And Events
 
@@ -416,8 +416,6 @@ Important fields:
 - `concurrency.maxConcurrentRuns`
 - `routing.defaultAgentId`
 - `routing.rules`
-- `routing.systemPrompt`
-- `routing.modelRouting`
 - `maintenance.checkpoints`
 - `maintenance.records`
 - `recovery.enabled`
@@ -444,7 +442,6 @@ spec:
     maxConcurrentRuns: 3
   routing:
     defaultAgentId: orchestra
-    modelRouting: false
   maintenance:
     checkpoints:
       enabled: true
@@ -639,7 +636,7 @@ For backend-specific options, prefer the upstream concept directly inside `spec.
 - `agent-harness` is not a third agent framework
 - public runtime contract stays generic and small
 - application-level orchestration and lifecycle management stays in the harness
-- ACP should be the preferred future external client protocol instead of a parallel harness-only protocol
+- the external protocol boundary should strictly conform to `deepagents-acp` instead of a parallel harness-only protocol
 - upstream LangChain v1 and DeepAgents concepts should be expressed as directly as possible in YAML
 - when a feature can be expressed in YAML, prefer YAML over expanding the public API
 - recovery, approvals, threads, runs, and events are runtime concepts, not backend escape hatches

package/README.zh.md

@@ -79,7 +79,7 @@
 - `docs/model-layering.md`
 - `docs/coding-agent-guide.md`
 
-当外部工具需要标准运行时边界时，ACP 是预期的未来客户端协议方向。`agent-harness` 应该具备 ACP 能力，同时继续把运行时生命周期、持久化、恢复与治理保留在 harness 内部。
+当外部工具需要标准运行时边界时，`deepagents-acp` 是必须遵循的外部协议方向。`agent-harness` 应在该边界上严格契合 `deepagents-acp` 语义，同时继续把运行时生命周期、持久化、恢复与治理保留在 harness 内部。
 
 长链路编排的推荐形态：
 
@@ -633,7 +633,7 @@ spec:
 - `agent-harness` 不是第三个 agent 框架
 - 公共运行时契约保持通用且精简
 - 应用级编排与生命周期管理留在 harness 中
-- ACP 应作为优先对齐的未来外部客户端协议，而不是再做一套并行的 harness 私有协议
+- 外部协议边界应严格契合 `deepagents-acp`，而不是再做一套并行的 harness 私有协议
 - 应尽量在 YAML 中直接表达 LangChain v1 与 DeepAgents 的概念
 - 能用 YAML 表达的能力，优先 YAML 而非扩张公共 API
 - 恢复、审批、线程、运行与事件是运行时概念，不是后端逃生舱

package/dist/benchmark/upstream-runtime-ab-benchmark.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_UPSTREAM_BENCHMARK_PATHS: readonly ["harness", "raw-langchain-v1", "raw-langgraph", "raw-deepagent"];
+export declare const DEFAULT_UPSTREAM_BENCHMARK_PATHS: readonly ["harness", "raw-langchain-v1", "raw-deepagent"];
 export declare const DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD: "tool";
 export type UpstreamBenchmarkPath = (typeof DEFAULT_UPSTREAM_BENCHMARK_PATHS)[number];
 export type UpstreamBenchmarkWorkload = "tool" | "no-tool";

package/dist/benchmark/upstream-runtime-ab-benchmark.js

@@ -1,7 +1,6 @@
 export const DEFAULT_UPSTREAM_BENCHMARK_PATHS = Object.freeze([
     "harness",
     "raw-langchain-v1",
-    "raw-langgraph",
     "raw-deepagent",
 ]);
 export const DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD = "tool";
@@ -48,7 +47,7 @@ export function resolveUpstreamBenchmarkPaths(rawValue) {
     const parsed = rawValue
         .split(",")
         .map((value) => value.trim().toLowerCase())
-        .filter((value) => value === "harness" || value === "raw-langchain-v1" || value === "raw-langgraph" || value === "raw-deepagent");
+        .filter((value) => value === "harness" || value === "raw-langchain-v1" || value === "raw-deepagent");
     return parsed.length > 0 ? parsed : [...DEFAULT_UPSTREAM_BENCHMARK_PATHS];
 }
 export function resolveUpstreamBenchmarkWorkload(rawValue) {

package/dist/contracts/core.d.ts

@@ -1,6 +1,6 @@
-export type ExecutionMode = "deepagent" | "langchain-v1" | "langgraph";
+export type ExecutionMode = "deepagent" | "langchain-v1";
 export declare const AUTO_AGENT_ID = "auto";
-export type RuntimeModelSlot = "routing" | "planning" | "execution" | "review" | "final";
+export type RuntimeModelSlot = "planning" | "execution" | "review" | "final";
 export type RuntimeModelRefMap = Partial<Record<RuntimeModelSlot, string>>;
 export type RuntimeCapabilities = {
     delegation?: boolean;

package/dist/contracts/runtime.d.ts

@@ -9,7 +9,7 @@ export type ThreadSummary = {
     status: RunState;
 };
 export type SessionRecord = ThreadSummary;
-export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.reviewed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
+export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
 export type HarnessEventType = KnownHarnessEventType | (string & {});
 export type HarnessEvent = {
     eventId: string;
@@ -190,8 +190,6 @@ export type RunStartOptions = {
     priority?: number;
     invocation?: InvocationEnvelope;
     listeners?: RunListeners;
-    runtimeListeners?: RuntimeListeners;
-    frontendListeners?: FrontendStreamListeners;
 };
 export type RunDecisionOptions = {
     threadId: string;
@@ -200,8 +198,6 @@ export type RunDecisionOptions = {
     decision: "approve" | "edit" | "reject";
     editedInput?: Record<string, unknown>;
     listeners?: RunListeners;
-    runtimeListeners?: RuntimeListeners;
-    frontendListeners?: FrontendStreamListeners;
 };
 export type RunOptions = RunStartOptions | RunDecisionOptions;
 export type HarnessStreamItem = {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.98";
+export declare const AGENT_HARNESS_VERSION = "0.0.99";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.98";
+export const AGENT_HARNESS_VERSION = "0.0.99";

package/dist/runtime/adapter/deepagent-runnable-config.d.ts

@@ -0,0 +1,30 @@
+import type { DeepAgentParams } from "../../contracts/types.js";
+export declare function buildDeepAgentRunnableConfig(params: {
+    compatibleParams: DeepAgentParams;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    resolvedBackend: unknown;
+    resolvedInterruptOn: unknown;
+    resolvedSkills: string[];
+}): {
+    model: never;
+    tools: never;
+    systemPrompt: string | undefined;
+    responseFormat: never;
+    contextSchema: never;
+    middleware: never;
+    subagents: never;
+    checkpointer: never;
+    store: never;
+    backend: never;
+    interruptOn: never;
+    name: string;
+    memory: string[];
+    skills: string[];
+    generalPurposeAgent: boolean | undefined;
+    taskDescription: string | undefined;
+};

package/dist/runtime/adapter/deepagent-runnable-config.js

@@ -0,0 +1,22 @@
+export function buildDeepAgentRunnableConfig(params) {
+    const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
+    return {
+        ...(compatibleParams.passthrough ?? {}),
+        model: resolvedModel,
+        tools: resolvedTools,
+        systemPrompt: compatibleParams.systemPrompt,
+        responseFormat: compatibleParams.responseFormat,
+        contextSchema: compatibleParams.contextSchema,
+        middleware: resolvedMiddleware,
+        subagents: resolvedSubagents,
+        checkpointer: resolvedCheckpointer,
+        store: resolvedStore,
+        backend: resolvedBackend,
+        interruptOn: resolvedInterruptOn,
+        name: compatibleParams.name,
+        memory: compatibleParams.memory,
+        skills: resolvedSkills,
+        generalPurposeAgent: compatibleParams.generalPurposeAgent,
+        taskDescription: compatibleParams.taskDescription,
+    };
+}

package/dist/runtime/adapter/index.d.ts

@@ -2,8 +2,6 @@ export * from "./tool/declared-middleware.js";
 export * from "./compat/deepagent-compat.js";
 export * from "./tool/interrupt-policy.js";
 export * from "./model/invocation-request.js";
-export * from "./langgraph/presets.js";
-export * from "./langgraph/profiles.js";
 export * from "./model/message-assembly.js";
 export * from "./model/model-providers.js";
 export * from "./compat/openai-compatible.js";

package/dist/runtime/adapter/index.js

@@ -2,8 +2,6 @@ export * from "./tool/declared-middleware.js";
 export * from "./compat/deepagent-compat.js";
 export * from "./tool/interrupt-policy.js";
 export * from "./model/invocation-request.js";
-export * from "./langgraph/presets.js";
-export * from "./langgraph/profiles.js";
 export * from "./model/message-assembly.js";
 export * from "./model/model-providers.js";
 export * from "./compat/openai-compatible.js";

package/dist/runtime/adapter/invocation-result.d.ts

@@ -0,0 +1,13 @@
+import type { RunResult } from "../../contracts/types.js";
+export type ExecutedToolResult = {
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+export declare function finalizeInvocationResult(params: {
+    bindingAgentId: string;
+    threadId: string;
+    runId: string;
+    result: Record<string, unknown>;
+    executedToolResults: ExecutedToolResult[];
+}): RunResult;

package/dist/runtime/adapter/invocation-result.js

@@ -0,0 +1,40 @@
+import { extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
+import { buildStateSnapshot } from "./model/message-assembly.js";
+import { asRecord } from "./tool/resolved-tool.js";
+export function finalizeInvocationResult(params) {
+    const { bindingAgentId, threadId, runId, result, executedToolResults } = params;
+    const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
+    const extractedOutput = extractVisibleOutput(result);
+    const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
+    const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
+    const toolFallback = extractToolFallbackContext(result);
+    if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
+        throw new Error(emptyAssistantMessageFailure);
+    }
+    const output = visibleOutput || toolFallback || JSON.stringify(result, null, 2);
+    const finalMessageText = sanitizeVisibleText(output);
+    const outputContent = extractOutputContent(result);
+    const contentBlocks = extractContentBlocks(result);
+    const structuredResponse = result.structuredResponse;
+    return {
+        threadId,
+        runId,
+        agentId: bindingAgentId,
+        state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
+        interruptContent,
+        output: finalMessageText,
+        finalMessageText,
+        ...(outputContent !== undefined ? { outputContent } : {}),
+        ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+        ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+        metadata: {
+            ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
+            ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+            ...(outputContent !== undefined ? { outputContent } : {}),
+            ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+            ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
+            ...(buildStateSnapshot(result) ? { stateSnapshot: buildStateSnapshot(result) } : {}),
+            upstreamResult: result,
+        },
+    };
+}

package/dist/runtime/adapter/langchain-runnable-config.d.ts

@@ -0,0 +1,25 @@
+import type { LangChainAgentParams } from "../../contracts/types.js";
+export declare function buildLangChainRunnableConfig(params: {
+    langchainParams: LangChainAgentParams;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+}): {
+    model: never;
+    tools: never;
+    systemPrompt: string | undefined;
+    stateSchema: never;
+    responseFormat: never;
+    contextSchema: never;
+    middleware: never;
+    checkpointer: never;
+    store: never;
+    includeAgentName: "inline" | undefined;
+    version: "v1" | "v2" | undefined;
+    name: string | undefined;
+    description: string;
+};

package/dist/runtime/adapter/langchain-runnable-config.js

@@ -0,0 +1,19 @@
+export function buildLangChainRunnableConfig(params) {
+    const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
+    return {
+        ...(passthroughOverride ?? langchainParams.passthrough ?? {}),
+        model: resolvedModel,
+        tools: resolvedTools,
+        systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
+        stateSchema: langchainParams.stateSchema,
+        responseFormat: langchainParams.responseFormat,
+        contextSchema: langchainParams.contextSchema,
+        middleware: resolvedMiddleware,
+        checkpointer: resolvedCheckpointer,
+        store: resolvedStore,
+        includeAgentName: langchainParams.includeAgentName,
+        version: langchainParams.version,
+        name: langchainParams.name,
+        description: langchainParams.description,
+    };
+}

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -0,0 +1,23 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import { type ToolNameMapping } from "./tool/tool-name-mapping.js";
+import type { ExecutedToolResult } from "./invocation-result.js";
+type ExecutableTool = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+type LocalToolInvocationParams = {
+    binding: CompiledAgentBinding;
+    request: unknown;
+    primaryTools: CompiledTool[];
+    toolNameMapping: ToolNameMapping;
+    executableTools: Map<string, ExecutableTool>;
+    builtinExecutableTools: Map<string, ExecutableTool>;
+    callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+};
+type LocalToolInvocationResult = {
+    result: Record<string, unknown>;
+    executedToolResults: ExecutedToolResult[];
+};
+export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
+export {};

package/dist/runtime/adapter/local-tool-invocation.js

@@ -0,0 +1,64 @@
+import { ToolMessage } from "@langchain/core/messages";
+import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
+import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
+import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
+export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
+    const executedToolResults = [];
+    let activeRequest = request;
+    let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
+    const maxToolIterations = 8;
+    let pendingResult;
+    let result;
+    for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
+        result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
+        pendingResult = undefined;
+        const toolCalls = extractToolCallsFromResult(result);
+        if (toolCalls.length === 0) {
+            break;
+        }
+        if (!canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools)) {
+            break;
+        }
+        if (iteration + 1 === maxToolIterations) {
+            throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
+        }
+        const resultMessages = result.messages;
+        const nextMessages = Array.isArray(resultMessages)
+            ? [...resultMessages]
+            : [...currentMessages];
+        for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
+            const toolCall = toolCalls[toolIndex];
+            const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
+            const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
+            const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
+                builtinExecutableTools.get(resolvedToolName) ??
+                createModelFacingToolNameLookupCandidates(toolCall.name)
+                    .map((candidate) => builtinExecutableTools.get(candidate))
+                    .find((candidate) => candidate !== undefined);
+            const activeExecutable = executable ?? builtinExecutable;
+            if (!activeExecutable) {
+                throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
+            }
+            const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
+            const toolResult = await activeExecutable.invoke(normalizedArgs);
+            executedToolResults.push({
+                toolName: activeExecutable.name,
+                output: toolResult,
+            });
+            nextMessages.push(new ToolMessage({
+                name: activeExecutable.name,
+                tool_call_id: toolCall.id ?? `tool-${iteration + 1}-${toolIndex + 1}`,
+                content: stringifyToolOutput(toolResult),
+            }));
+        }
+        currentMessages = nextMessages;
+        activeRequest = {
+            ...activeRequest,
+            messages: currentMessages,
+        };
+    }
+    if (!result) {
+        throw new Error("Agent invocation returned no result");
+    }
+    return { result, executedToolResults };
+}

package/dist/runtime/adapter/runtime-adapter-support.d.ts

@@ -0,0 +1,18 @@
+import type { CompiledAgentBinding } from "../../contracts/types.js";
+export declare function countConfiguredTools(binding: CompiledAgentBinding): number;
+export declare function asObject(value: unknown): Record<string, unknown> | undefined;
+export declare function sleep(ms: number): Promise<void>;
+export declare function hasConfiguredSubagentSupport(binding: CompiledAgentBinding): boolean;
+export declare function hasConfiguredMiddlewareKind(binding: CompiledAgentBinding, kind: string): boolean;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function truncateLines(lines: string[], maxChars?: number): string;
+export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): {
+    total: number;
+    pending: number;
+    completed: number;
+    items: Array<{
+        content: string;
+        status: string;
+    }>;
+};

package/dist/runtime/adapter/runtime-adapter-support.js

@@ -0,0 +1,54 @@
+import { getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryTools } from "../support/compiled-binding.js";
+export function countConfiguredTools(binding) {
+    return getBindingPrimaryTools(binding).length;
+}
+export function asObject(value) {
+    return typeof value === "object" && value ? value : undefined;
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function hasConfiguredSubagentSupport(binding) {
+    const params = getBindingLangChainParams(binding);
+    if (!params) {
+        return false;
+    }
+    return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
+}
+export function hasConfiguredMiddlewareKind(binding, kind) {
+    return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isObject(value) {
+    return isRecord(value);
+}
+export function truncateLines(lines, maxChars = 12_000) {
+    const joined = lines.join("\n");
+    if (joined.length <= maxChars) {
+        return joined;
+    }
+    return `${joined.slice(0, maxChars - 18)}\n...[truncated]`;
+}
+export function summarizeBuiltinWriteTodosArgs(args) {
+    const todos = Array.isArray(args.todos) ? args.todos : [];
+    const items = todos.flatMap((todo) => {
+        if (!isObject(todo)) {
+            return [];
+        }
+        const content = typeof todo.content === "string" && todo.content.trim().length > 0
+            ? todo.content.trim()
+            : typeof todo.description === "string" && todo.description.trim().length > 0
+                ? todo.description.trim()
+                : "";
+        const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
+        return content ? [{ content, status }] : [];
+    });
+    return {
+        total: items.length,
+        pending: items.filter((item) => item.status !== "completed").length,
+        completed: items.filter((item) => item.status === "completed").length,
+        items,
+    };
+}

package/dist/runtime/adapter/stream-event-projection.d.ts

@@ -0,0 +1,19 @@
+import type { CompiledTool } from "../../contracts/types.js";
+import { type RuntimeStreamChunk } from "../parsing/stream-event-parsing.js";
+import { type ToolNameMapping } from "./tool/tool-name-mapping.js";
+export type StreamEventProjectionState = {
+    emittedOutput: string;
+    emittedToolError: boolean;
+    emittedToolResult: boolean;
+    seenTerminalOutputs: Set<string>;
+    lastStep: string;
+};
+export declare function createStreamEventProjectionState(): StreamEventProjectionState;
+export declare function projectRuntimeStreamEvent(params: {
+    event: unknown;
+    allowVisibleStreamDeltas: boolean;
+    includeStateStreamOutput: boolean;
+    toolNameMapping: ToolNameMapping;
+    primaryTools: CompiledTool[];
+    state: StreamEventProjectionState;
+}): RuntimeStreamChunk[];

package/dist/runtime/adapter/stream-event-projection.js

@@ -0,0 +1,79 @@
+import { sanitizeVisibleText } from "../parsing/output-parsing.js";
+import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, normalizeUpstreamRuntimeEvent, } from "../parsing/stream-event-parsing.js";
+import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
+export function createStreamEventProjectionState() {
+    return {
+        emittedOutput: "",
+        emittedToolError: false,
+        emittedToolResult: false,
+        seenTerminalOutputs: new Set(),
+        lastStep: "",
+    };
+}
+export function projectRuntimeStreamEvent(params) {
+    const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
+    const chunks = [{
+            kind: "upstream-event",
+            event: normalizeUpstreamRuntimeEvent(event),
+        }];
+    const interruptPayload = extractInterruptPayload(event);
+    if (interruptPayload) {
+        chunks.push({ kind: "interrupt", content: interruptPayload });
+        return chunks;
+    }
+    const reasoning = extractReasoningStreamOutput(event);
+    if (reasoning) {
+        chunks.push({ kind: "reasoning", content: reasoning });
+    }
+    if (allowVisibleStreamDeltas) {
+        const visibleStreamOutput = extractVisibleStreamOutput(event);
+        if (visibleStreamOutput) {
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
+            state.emittedOutput = nextOutput.accumulated;
+            if (nextOutput.delta) {
+                chunks.push({ kind: "content", content: nextOutput.delta });
+            }
+        }
+    }
+    if (includeStateStreamOutput) {
+        const stateStreamOutput = extractStateStreamOutput(event);
+        if (stateStreamOutput) {
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(stateStreamOutput));
+            state.emittedOutput = nextOutput.accumulated;
+            if (nextOutput.delta) {
+                chunks.push({ kind: "content", content: nextOutput.delta });
+            }
+        }
+    }
+    const agentStep = extractAgentStep(event);
+    if (agentStep && agentStep !== state.lastStep) {
+        state.lastStep = agentStep;
+        chunks.push({ kind: "step", content: agentStep });
+    }
+    const toolResult = extractToolResult(event);
+    if (toolResult) {
+        state.emittedToolResult = true;
+        state.emittedToolError = state.emittedToolError || toolResult.isError === true;
+        chunks.push({
+            kind: "tool-result",
+            toolName: resolveModelFacingToolName(toolResult.toolName, toolNameMapping, primaryTools),
+            output: toolResult.output,
+            isError: toolResult.isError,
+        });
+    }
+    const output = extractTerminalStreamOutput(event);
+    if (output) {
+        const outputKey = normalizeTerminalOutputKey(output);
+        if (!outputKey || !state.seenTerminalOutputs.has(outputKey)) {
+            if (outputKey) {
+                state.seenTerminalOutputs.add(outputKey);
+            }
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(output));
+            state.emittedOutput = nextOutput.accumulated;
+            if (nextOutput.delta) {
+                chunks.push({ kind: "content", content: nextOutput.delta });
+            }
+        }
+    }
+    return chunks;
+}

package/dist/runtime/adapter/stream-text-consumption.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeStreamChunk } from "../parsing/stream-event-parsing.js";
+export declare function projectTextStreamChunks(stream: AsyncIterable<unknown>): AsyncGenerator<RuntimeStreamChunk, {
+    emittedContent: boolean;
+}>;

package/dist/runtime/adapter/stream-text-consumption.js

@@ -0,0 +1,18 @@
+import { extractReasoningText } from "../parsing/output-parsing.js";
+import { readStreamDelta } from "../parsing/stream-event-parsing.js";
+export async function* projectTextStreamChunks(stream) {
+    let emittedContent = false;
+    for await (const chunk of stream) {
+        const delta = readStreamDelta(chunk);
+        if (delta) {
+            emittedContent = true;
+            yield { kind: "content", content: delta };
+            continue;
+        }
+        const reasoning = extractReasoningText(chunk);
+        if (reasoning) {
+            yield { kind: "reasoning", content: reasoning };
+        }
+    }
+    return { emittedContent };
+}