@botbotgo/agent-harness 0.0.42 → 0.0.44

package/dist/presentation.js

@@ -8,6 +8,152 @@ export function escapeHtml(value) {
         .replaceAll('"', """)
         .replaceAll("'", "'");
 }
+/** CSS class for anchors that should open in the host app embedded browser (Wallee). */
+export const WALLEE_OUTPUT_LINK_CLASS = "wallee-output-link";
+/** `data-wallee-url` — target URL for the embedded browser (http/https only). */
+export const WALLEE_BROWSER_URL_ATTR = "data-wallee-url";
+export function isAllowedWalleeBrowserUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.protocol === "http:" || u.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+function walleeOutputAnchor(url, labelEscaped) {
+    return `<a class="${WALLEE_OUTPUT_LINK_CLASS}" ${WALLEE_BROWSER_URL_ATTR}="${escapeHtml(url)}" href="#">${labelEscaped}</a>`;
+}
+/**
+ * Escape plain text and wrap http(s) URLs in Wallee output anchors (open in host embedded browser).
+ */
+export function linkifyPlainTextForWalleeBrowser(text) {
+    const urlRe = /\bhttps?:\/\/[^\s<>"']+/g;
+    const parts = [];
+    let last = 0;
+    let m;
+    while ((m = urlRe.exec(text)) !== null) {
+        parts.push(escapeHtml(text.slice(last, m.index)));
+        const raw = m[0];
+        const trimmed = raw.replace(/[.,;:!?)\]]+$/u, "");
+        const rest = raw.slice(trimmed.length);
+        if (isAllowedWalleeBrowserUrl(trimmed)) {
+            parts.push(walleeOutputAnchor(trimmed, escapeHtml(trimmed)));
+            if (rest) {
+                parts.push(escapeHtml(rest));
+            }
+        }
+        else {
+            parts.push(escapeHtml(raw));
+        }
+        last = m.index + raw.length;
+    }
+    parts.push(escapeHtml(text.slice(last)));
+    return parts.join("");
+}
+function applyBasicInlineMarkdown(escaped) {
+    return escaped
+        .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+        .replace(/\*(.+?)\*/g, "<em>$1</em>")
+        .replace(/`([^`]+)`/g, "<code>$1</code>");
+}
+function linkifyPlainTextSegmentWithWalleeMarkdown(text) {
+    const mdLinkPattern = /\[([^\]]*)\]\((https?:\/\/[^)\s]+)\)/g;
+    const segments = [];
+    let lastIndex = 0;
+    let m;
+    while ((m = mdLinkPattern.exec(text)) !== null) {
+        if (m.index > lastIndex) {
+            segments.push({ type: "text", text: text.slice(lastIndex, m.index) });
+        }
+        segments.push({ type: "mdlink", label: m[1], url: m[2] });
+        lastIndex = m.index + m[0].length;
+    }
+    if (lastIndex < text.length) {
+        segments.push({ type: "text", text: text.slice(lastIndex) });
+    }
+    if (segments.length === 0) {
+        segments.push({ type: "text", text });
+    }
+    return segments
+        .map((seg) => {
+        if (seg.type === "mdlink") {
+            if (!isAllowedWalleeBrowserUrl(seg.url)) {
+                return `${escapeHtml(seg.label)} (${escapeHtml(seg.url)})`;
+            }
+            return walleeOutputAnchor(seg.url, escapeHtml(seg.label));
+        }
+        return linkifyBareUrlsWithInlineMarkdown(seg.text);
+    })
+        .join("");
+}
+function linkifyBareUrlsWithInlineMarkdown(text) {
+    const urlRe = /\bhttps?:\/\/[^\s<>"']+/g;
+    const parts = [];
+    let last = 0;
+    let m;
+    while ((m = urlRe.exec(text)) !== null) {
+        parts.push(applyBasicInlineMarkdown(escapeHtml(text.slice(last, m.index))));
+        const raw = m[0];
+        const trimmed = raw.replace(/[.,;:!?)\]]+$/u, "");
+        const rest = raw.slice(trimmed.length);
+        if (isAllowedWalleeBrowserUrl(trimmed)) {
+            parts.push(walleeOutputAnchor(trimmed, escapeHtml(trimmed)));
+            if (rest) {
+                parts.push(applyBasicInlineMarkdown(escapeHtml(rest)));
+            }
+        }
+        else {
+            parts.push(applyBasicInlineMarkdown(escapeHtml(raw)));
+        }
+        last = m.index + raw.length;
+    }
+    parts.push(applyBasicInlineMarkdown(escapeHtml(text.slice(last))));
+    return parts.join("");
+}
+/**
+ * Like {@link markdownToHtml} but inline http(s) URLs and markdown links `[label](https://…)` render as
+ * Wallee embedded-browser anchors (`wallee-output-link` + `data-wallee-url`).
+ */
+export function markdownToWalleeOutputHtml(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const blocks = normalized.split(/\n\n+/);
+    const html = [];
+    for (const block of blocks) {
+        const trimmed = block.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (trimmed.startsWith("```") && trimmed.endsWith("```")) {
+            const lines = trimmed.split("\n");
+            const language = lines[0]?.slice(3).trim();
+            const code = lines.slice(1, -1).join("\n");
+            html.push(`<pre class="ah-code"><code${language ? ` data-language="${escapeHtml(language)}"` : ""}>${escapeHtml(code)}</code></pre>`);
+            continue;
+        }
+        if (/^#{1,6}\s/.test(trimmed)) {
+            const match = trimmed.match(/^(#{1,6})\s+(.*)$/);
+            const level = match?.[1].length ?? 1;
+            const content = linkifyPlainTextSegmentWithWalleeMarkdown(match?.[2] ?? trimmed);
+            html.push(`<h${level}>${content}</h${level}>`);
+            continue;
+        }
+        if (trimmed.split("\n").every((line) => /^[-*]\s+/.test(line))) {
+            const items = trimmed
+                .split("\n")
+                .map((line) => line.replace(/^[-*]\s+/, ""))
+                .map((line) => `<li>${linkifyPlainTextSegmentWithWalleeMarkdown(line)}</li>`)
+                .join("");
+            html.push(`<ul>${items}</ul>`);
+            continue;
+        }
+        html.push(`<p>${trimmed
+            .split("\n")
+            .map((line) => linkifyPlainTextSegmentWithWalleeMarkdown(line))
+            .join("<br />")}</p>`);
+    }
+    return html.join("");
+}
 function renderInlineMarkdown(text) {
     const escaped = escapeHtml(text);
     return escaped

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

@@ -27,6 +27,7 @@ export declare class AgentRuntimeAdapter {
     private buildToolNameMapping;
     private buildAgentMessages;
     private buildInvocationRequest;
+    private buildStateSnapshot;
     private buildRawModelMessages;
     private resolveTools;
     private normalizeInterruptPolicy;

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

@@ -12,8 +12,9 @@ import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, ex
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
+import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 function countConfiguredTools(binding) {
-    return binding.langchainAgentParams?.tools.length ?? binding.deepAgentParams?.tools.length ?? 0;
+    return getBindingPrimaryTools(binding).length;
 }
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
@@ -142,6 +143,11 @@ function hasCallableToolHandler(value) {
     const typed = value;
     return typeof typed.invoke === "function" || typeof typed.call === "function" || typeof typed.func === "function";
 }
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
 function normalizeResolvedToolSchema(resolvedTool) {
     const schema = resolvedTool.schema;
     if (schema && typeof schema.parse === "function" && "_def" in schema) {
@@ -172,10 +178,10 @@ export class AgentRuntimeAdapter {
         this.options = options;
     }
     resolveBindingTimeout(binding) {
-        return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
+        return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
     }
     resolveStreamIdleTimeout(binding) {
-        const configuredIdleTimeout = resolveTimeoutMs(binding.langchainAgentParams?.model.init.streamIdleTimeout ?? binding.deepAgentParams?.model.init.streamIdleTimeout);
+        const configuredIdleTimeout = resolveTimeoutMs(getBindingModelInit(binding)?.streamIdleTimeout);
         if (configuredIdleTimeout) {
             return configuredIdleTimeout;
         }
@@ -284,35 +290,38 @@ export class AgentRuntimeAdapter {
         };
     }
     applyStrictToolJsonInstruction(binding) {
-        if (binding.langchainAgentParams) {
+        if (isLangChainBinding(binding)) {
+            const params = getBindingLangChainParams(binding);
             return {
                 ...binding,
                 langchainAgentParams: {
-                    ...binding.langchainAgentParams,
-                    systemPrompt: [binding.langchainAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                    ...params,
+                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
                 },
             };
         }
-        if (binding.deepAgentParams) {
+        if (isDeepAgentBinding(binding)) {
+            const params = getBindingDeepAgentParams(binding);
             return {
                 ...binding,
                 deepAgentParams: {
-                    ...binding.deepAgentParams,
-                    systemPrompt: [binding.deepAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                    ...params,
+                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
                 },
             };
         }
         return binding;
     }
     async synthesizeDeepAgentAnswer(binding, input, result) {
-        if (!binding.deepAgentParams) {
+        const params = getBindingDeepAgentParams(binding);
+        if (!params) {
             return "";
         }
         const toolContext = extractToolFallbackContext(result);
         if (!toolContext) {
             return "";
         }
-        const model = (await this.resolveModel(binding.deepAgentParams.model));
+        const model = (await this.resolveModel(params.model));
         if (!model?.invoke) {
             return "";
         }
@@ -365,6 +374,14 @@ export class AgentRuntimeAdapter {
             messages: this.buildAgentMessages(history, input),
         };
     }
+    buildStateSnapshot(result) {
+        const snapshot = { ...result };
+        delete snapshot.messages;
+        delete snapshot.__interrupt__;
+        delete snapshot.structuredResponse;
+        delete snapshot.files;
+        return Object.keys(snapshot).length > 0 ? snapshot : undefined;
+    }
     buildRawModelMessages(systemPrompt, history, input) {
         const messages = [];
         if (systemPrompt) {
@@ -424,14 +441,10 @@ export class AgentRuntimeAdapter {
         return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
     }
     resolveInterruptOn(binding) {
-        if (binding.deepAgentParams) {
-            return this.compileInterruptOn(binding.deepAgentParams.tools, binding.deepAgentParams.interruptOn);
-        }
-        return this.compileInterruptOn(binding.langchainAgentParams?.tools ?? [], binding.agent.langchainAgentConfig?.interruptOn);
+        return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
     }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(binding.langchainAgentParams?.middleware ??
-            binding.deepAgentParams?.middleware, {
+        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
             resolveModel: (model) => this.resolveModel(model),
             resolveCustom: this.options.declaredMiddlewareResolver,
             binding,
@@ -484,30 +497,31 @@ export class AgentRuntimeAdapter {
         })));
     }
     async create(binding) {
-        if (binding.langchainAgentParams) {
+        if (isLangChainBinding(binding)) {
+            const params = getBindingLangChainParams(binding);
             const interruptOn = this.resolveInterruptOn(binding);
-            const model = (await this.resolveModel(binding.langchainAgentParams.model));
-            const tools = this.resolveTools(binding.langchainAgentParams.tools, binding);
+            const model = (await this.resolveModel(params.model));
+            const tools = this.resolveTools(params.tools, binding);
             if (tools.length > 0 && typeof model.bindTools !== "function") {
-                throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${binding.langchainAgentParams.model.id} does not support tool binding.`);
+                throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${params.model.id} does not support tool binding.`);
             }
             return createAgent({
                 model: model,
                 tools: tools,
-                systemPrompt: binding.langchainAgentParams.systemPrompt,
-                stateSchema: binding.langchainAgentParams.stateSchema,
-                responseFormat: binding.langchainAgentParams.responseFormat,
-                contextSchema: binding.langchainAgentParams.contextSchema,
+                systemPrompt: params.systemPrompt,
+                stateSchema: params.stateSchema,
+                responseFormat: params.responseFormat,
+                contextSchema: params.contextSchema,
                 middleware: (await this.resolveMiddleware(binding, interruptOn)),
                 checkpointer: this.resolveCheckpointer(binding),
                 store: this.options.storeResolver?.(binding),
-                includeAgentName: binding.langchainAgentParams.includeAgentName,
-                version: binding.langchainAgentParams.version,
-                name: binding.langchainAgentParams.name,
-                description: binding.langchainAgentParams.description,
+                includeAgentName: params.includeAgentName,
+                version: params.version,
+                name: params.name,
+                description: params.description,
             });
         }
-        const params = binding.deepAgentParams;
+        const params = getBindingDeepAgentParams(binding);
         if (!params) {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
@@ -532,10 +546,8 @@ export class AgentRuntimeAdapter {
         return createDeepAgent(deepAgentConfig);
     }
     async route(input, primaryBinding, secondaryBinding, options = {}) {
-        const routeModelConfig = primaryBinding.langchainAgentParams?.model ??
-            primaryBinding.deepAgentParams?.model ??
-            secondaryBinding.langchainAgentParams?.model ??
-            secondaryBinding.deepAgentParams?.model;
+        const routeModelConfig = getBindingPrimaryModel(primaryBinding) ??
+            getBindingPrimaryModel(secondaryBinding);
         if (!routeModelConfig) {
             throw new Error("No router model configuration available");
         }
@@ -587,13 +599,21 @@ export class AgentRuntimeAdapter {
             throw new Error(emptyAssistantMessageFailure);
         }
         const output = visibleOutput || synthesizedOutput || toolFallback || JSON.stringify(result, null, 2);
+        const finalMessageText = sanitizeVisibleText(output);
         return {
             threadId,
             runId,
             agentId: binding.agent.id,
             state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
             interruptContent,
-            output: sanitizeVisibleText(output),
+            output: finalMessageText,
+            finalMessageText,
+            metadata: {
+                ...(result.structuredResponse !== undefined ? { structuredResponse: result.structuredResponse } : {}),
+                ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
+                ...(this.buildStateSnapshot(result) ? { stateSnapshot: this.buildStateSnapshot(result) } : {}),
+                upstreamResult: result,
+            },
         };
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
@@ -601,9 +621,9 @@ export class AgentRuntimeAdapter {
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-            if (binding.langchainAgentParams) {
-                const langchainParams = binding.langchainAgentParams;
-                const resolvedModel = (await this.resolveModel(binding.langchainAgentParams.model));
+            if (isLangChainBinding(binding)) {
+                const langchainParams = getBindingLangChainParams(binding);
+                const resolvedModel = (await this.resolveModel(langchainParams.model));
                 const tools = this.resolveTools(langchainParams.tools, binding);
                 const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
                 const model = canUseDirectModelStream
@@ -615,7 +635,7 @@ export class AgentRuntimeAdapter {
                 // agent loop and only adds an extra model round-trip before the runnable path.
                 if (canUseDirectModelStream && typeof model.stream === "function") {
                     let emitted = false;
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(langchainParams.systemPrompt, history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
+                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
                     for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs)) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
@@ -637,7 +657,7 @@ export class AgentRuntimeAdapter {
             const request = this.buildInvocationRequest(history, input, options);
             if (typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
-                const allowVisibleStreamDeltas = Boolean(binding.langchainAgentParams);
+                const allowVisibleStreamDeltas = isLangChainBinding(binding);
                 let emittedOutput = "";
                 let emittedToolError = false;
                 const seenTerminalOutputs = new Set();
@@ -662,7 +682,7 @@ export class AgentRuntimeAdapter {
                             }
                         }
                     }
-                    if (binding.deepAgentParams) {
+                    if (isDeepAgentBinding(binding)) {
                         const stateStreamOutput = extractStateStreamOutput(event);
                         if (stateStreamOutput) {
                             const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(stateStreamOutput));
@@ -702,7 +722,7 @@ export class AgentRuntimeAdapter {
                     return;
                 }
             }
-            if (binding.langchainAgentParams && typeof runnable.stream === "function") {
+            if (isLangChainBinding(binding) && typeof runnable.stream === "function") {
                 const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
                 let emitted = false;
                 for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, invokeTimeoutMs)) {

package/dist/runtime/harness.d.ts

@@ -24,6 +24,8 @@ export declare class AgentHarnessRuntime {
     private readonly concurrencyConfig;
     private activeRunSlots;
     private readonly pendingRunSlots;
+    private toPublicApprovalRecord;
+    private normalizeInvocationEnvelope;
     private listHostBindings;
     private defaultRunRoot;
     private heuristicRoute;

package/dist/runtime/harness.js

@@ -15,6 +15,7 @@ import { FileBackedStore } from "./store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -39,6 +40,19 @@ export class AgentHarnessRuntime {
     concurrencyConfig;
     activeRunSlots = 0;
     pendingRunSlots = [];
+    toPublicApprovalRecord(approval) {
+        const { toolCallId: _toolCallId, checkpointRef: _checkpointRef, eventRefs: _eventRefs, ...publicApproval } = approval;
+        return publicApproval;
+    }
+    normalizeInvocationEnvelope(options) {
+        const invocation = options.invocation;
+        return {
+            context: invocation?.context ?? options.context,
+            state: invocation?.inputs ?? options.state,
+            files: invocation?.attachments ?? options.files,
+            invocation,
+        };
+    }
     listHostBindings() {
         return inferRoutingBindings(this.workspace).hostBindings;
     }
@@ -79,7 +93,7 @@ export class AgentHarnessRuntime {
         return requestedAgentId;
     }
     resolveStore(binding) {
-        const storeConfig = binding?.deepAgentParams?.store ?? binding?.harnessRuntime.store;
+        const storeConfig = binding ? getBindingStoreConfig(binding) : undefined;
         const cacheKey = storeConfig ? JSON.stringify(storeConfig) : undefined;
         if (!storeConfig) {
             return this.defaultStore;
@@ -184,7 +198,7 @@ export class AgentHarnessRuntime {
         if (!binding) {
             throw new Error(`Unknown agent ${agentId}`);
         }
-        return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+        return getBindingPrimaryTools(binding);
     }
     resolveAgentTools(agentId) {
         const binding = this.getBinding(agentId);
@@ -259,10 +273,11 @@ export class AgentHarnessRuntime {
                 return false;
             }
             return true;
-        });
+        }).map((approval) => this.toPublicApprovalRecord(approval));
     }
     async getApproval(approvalId) {
-        return this.persistence.getApproval(approvalId);
+        const approval = await this.persistence.getApproval(approvalId);
+        return approval ? this.toPublicApprovalRecord(approval) : null;
     }
     async createToolMcpServer(options) {
         const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
@@ -340,7 +355,8 @@ export class AgentHarnessRuntime {
             threadId,
             runId,
             agentId: binding.agent.id,
-            executionMode: binding.agent.executionMode,
+            executionMode: getBindingAdapterKind(binding),
+            adapterKind: getBindingAdapterKind(binding),
             createdAt,
         });
         return { threadId, runId, createdAt };
@@ -500,6 +516,7 @@ export class AgentHarnessRuntime {
     }
     async dispatchRunListeners(stream, listeners) {
         let latestEvent;
+        let latestResult;
         let output = "";
         for await (const item of stream) {
             if (item.type === "event") {
@@ -507,6 +524,10 @@ export class AgentHarnessRuntime {
                 await this.notifyListener(listeners.onEvent, item.event);
                 continue;
             }
+            if (item.type === "result") {
+                latestResult = item.result;
+                continue;
+            }
             if (item.type === "content") {
                 output += item.content;
                 await this.notifyListener(listeners.onChunk, item.content);
@@ -531,6 +552,13 @@ export class AgentHarnessRuntime {
         if (!latestEvent) {
             throw new Error("run did not emit any events");
         }
+        if (latestResult) {
+            return {
+                ...latestResult,
+                output: latestResult.output || output,
+                finalMessageText: latestResult.finalMessageText ?? latestResult.output ?? output,
+            };
+        }
         const thread = await this.getThread(latestEvent.threadId);
         if (!thread) {
             throw new Error(`Unknown thread ${latestEvent.threadId}`);
@@ -561,6 +589,7 @@ export class AgentHarnessRuntime {
         }
         const releaseRunSlot = await this.acquireRunSlot();
         try {
+            const invocation = this.normalizeInvocationEnvelope(options);
             const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
             const binding = this.workspace.bindings.get(selectedAgentId);
             if (!binding) {
@@ -575,13 +604,13 @@ export class AgentHarnessRuntime {
                 agentId: binding.agent.id,
                 requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
                 selectedAgentId,
-                executionMode: binding.agent.executionMode,
+                executionMode: getBindingAdapterKind(binding),
             });
             try {
                 const actual = await this.invokeWithHistory(binding, options.input, threadId, runId, undefined, {
-                    context: options.context,
-                    state: options.state,
-                    files: options.files,
+                    context: invocation.context,
+                    state: invocation.state,
+                    files: invocation.files,
                 });
                 const finalized = await this.finalizeContinuedRun(threadId, runId, options.input, actual, {
                     previousState: null,
@@ -615,6 +644,7 @@ export class AgentHarnessRuntime {
     async *streamEvents(options) {
         const releaseRunSlot = await this.acquireRunSlot();
         try {
+            const invocation = this.normalizeInvocationEnvelope(options);
             const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
             const binding = this.workspace.bindings.get(selectedAgentId);
             if (!binding) {
@@ -644,9 +674,9 @@ export class AgentHarnessRuntime {
                 let assistantOutput = "";
                 const toolErrors = [];
                 for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory, {
-                    context: options.context,
-                    state: options.state,
-                    files: options.files,
+                    context: invocation.context,
+                    state: invocation.state,
+                    files: invocation.files,
                 })) {
                     if (chunk) {
                         const normalizedChunk = typeof chunk === "string"
@@ -669,6 +699,20 @@ export class AgentHarnessRuntime {
                                 type: "event",
                                 event: approvalRequest.event,
                             };
+                            yield {
+                                type: "result",
+                                result: {
+                                    threadId,
+                                    runId,
+                                    agentId: selectedAgentId,
+                                    state: "waiting_for_approval",
+                                    output: assistantOutput,
+                                    finalMessageText: assistantOutput,
+                                    interruptContent: normalizedChunk.content,
+                                    approvalId: approvalRequest.approval.approvalId,
+                                    pendingActionId: approvalRequest.approval.pendingActionId,
+                                },
+                            };
                             return;
                         }
                         if (normalizedChunk.kind === "reasoning") {
@@ -728,6 +772,17 @@ export class AgentHarnessRuntime {
                     }
                 }
                 await this.appendAssistantMessage(threadId, runId, assistantOutput);
+                yield {
+                    type: "result",
+                    result: {
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        state: "completed",
+                        output: assistantOutput,
+                        finalMessageText: assistantOutput,
+                    },
+                };
                 yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "completed", {
                         previousState: null,
                     }) };
@@ -753,6 +808,17 @@ export class AgentHarnessRuntime {
                         agentId: selectedAgentId,
                         content: renderRuntimeFailure(error),
                     };
+                    yield {
+                        type: "result",
+                        result: {
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            state: "failed",
+                            output: renderRuntimeFailure(error),
+                            finalMessageText: renderRuntimeFailure(error),
+                        },
+                    };
                     return;
                 }
                 try {
@@ -761,6 +827,15 @@ export class AgentHarnessRuntime {
                     if (actual.output) {
                         yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
                     }
+                    yield {
+                        type: "result",
+                        result: {
+                            ...actual,
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                        },
+                    };
                     yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, actual.state, {
                             previousState: null,
                         }) };
@@ -779,6 +854,17 @@ export class AgentHarnessRuntime {
                         agentId: selectedAgentId,
                         content: renderRuntimeFailure(invokeError),
                     };
+                    yield {
+                        type: "result",
+                        result: {
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            state: "failed",
+                            output: renderRuntimeFailure(invokeError),
+                            finalMessageText: renderRuntimeFailure(invokeError),
+                        },
+                    };
                     return;
                 }
             }

package/dist/runtime/inventory.js

@@ -1,4 +1,5 @@
 import { readSkillMetadata } from "./support/skill-metadata.js";
+import { getBindingPrimaryTools } from "./support/compiled-binding.js";
 function listHostBindings(workspace) {
     return Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
 }
@@ -31,7 +32,7 @@ export function listAgentTools(workspace, agentId) {
     if (!binding) {
         return [];
     }
-    return dedupeTools(binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? []);
+    return dedupeTools(getBindingPrimaryTools(binding));
 }
 export function listAgentSkills(workspace, agentId) {
     const binding = findAgentBinding(workspace, agentId);