@botbotgo/agent-harness 0.0.119 → 0.0.121

package/dist/runtime/harness/events/streaming.d.ts

@@ -1,8 +1,29 @@
 import type { HarnessEvent, HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
-export declare function emitOutputDeltaAndCreateItem(emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, threadId: string, runId: string, agentId: string, content: string): Promise<HarnessStreamItem>;
-export declare function createContentBlocksItem(threadId: string, runId: string, agentId: string, contentBlocks: unknown[]): HarnessStreamItem;
+export type InternalHarnessStreamItem = HarnessStreamItem | {
+    type: "content";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    content: string;
+} | {
+    type: "content-blocks";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    contentBlocks: unknown[];
+} | {
+    type: "tool-result";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+export declare function emitOutputDeltaAndCreateItem(emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, threadId: string, runId: string, agentId: string, content: string): Promise<InternalHarnessStreamItem>;
+export declare function createContentBlocksItem(threadId: string, runId: string, agentId: string, contentBlocks: unknown[]): InternalHarnessStreamItem;
 export declare function createToolResultKey(toolName: string, output: unknown, isError?: boolean): string;
-export declare function dispatchRunListeners(stream: AsyncGenerator<HarnessStreamItem>, listeners: RunListeners, options: {
+export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RunListeners, options: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
         currentState: RunResult["state"];

package/dist/runtime/harness/events/streaming.js

@@ -50,28 +50,8 @@ export async function dispatchRunListeners(stream, listeners, options) {
         }
         if (item.type === "content") {
             output += item.content;
-            await options.notifyListener(listeners.onChunk, item.content);
             continue;
         }
-        if (item.type === "content-blocks") {
-            await options.notifyListener(listeners.onContentBlocks, item.contentBlocks);
-            continue;
-        }
-        if (item.type === "reasoning") {
-            await options.notifyListener(listeners.onReasoning, item.content);
-            continue;
-        }
-        if (item.type === "step") {
-            await options.notifyListener(listeners.onStep, item.content);
-            continue;
-        }
-        if (item.type === "tool-result") {
-            await options.notifyListener(listeners.onToolResult, {
-                toolName: item.toolName,
-                output: item.output,
-                isError: item.isError,
-            });
-        }
     }
     if (!latestEvent) {
         throw new Error("run did not emit any events");

package/dist/runtime/harness/run/stream-run.d.ts

@@ -1,14 +1,12 @@
-import type { CompiledAgentBinding, HarnessEvent, HarnessStreamItem, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, HarnessEvent, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import { type InternalHarnessStreamItem } from "../events/streaming.js";
 type RuntimeStreamChunk = string | {
     kind: "content" | "interrupt" | "reasoning" | "step" | "tool-result" | "upstream-event";
     content?: string;
     toolName?: string;
     output?: unknown;
     isError?: boolean;
-    event?: {
-        format?: string;
-        raw?: unknown;
-    } | Record<string, unknown>;
+    event?: unknown;
 };
 type StreamRunOptions = {
     binding: CompiledAgentBinding;
@@ -49,5 +47,5 @@ type StreamRunOptions = {
     clearRunRequest: (threadId: string, runId: string) => Promise<void>;
     emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
 };
-export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<HarnessStreamItem>;
+export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<InternalHarnessStreamItem>;
 export {};

package/dist/runtime/harness/run/stream-run.js

@@ -1,5 +1,4 @@
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
-import { normalizeUpstreamRuntimeEvent } from "../../parsing/stream-event-parsing.js";
 import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { createContentBlocksItem, createToolResultKey, emitOutputDeltaAndCreateItem, } from "../events/streaming.js";
 function normalizeStreamChunk(chunk) {
@@ -18,9 +17,6 @@ function normalizeStreamChunk(chunk) {
     if (chunk.kind === "reasoning") {
         return { kind: "reasoning", content: chunk.content ?? "" };
     }
-    if (chunk.kind === "step") {
-        return { kind: "step", content: chunk.content ?? "" };
-    }
     if (chunk.kind === "tool-result") {
         return {
             kind: "tool-result",
@@ -31,9 +27,6 @@ function normalizeStreamChunk(chunk) {
     }
     return { kind: "content", content: chunk.content ?? "" };
 }
-function isUpstreamRuntimeEvent(event) {
-    return event.format === "langgraph-v2" && "normalized" in event && "streamPart" in event;
-}
 export async function* streamHarnessRun(options) {
     const priorHistoryPromise = Promise.resolve(options.isNewThread ? [] : undefined).then((historyHint) => historyHint ?? options.loadPriorHistory(options.threadId, options.runId));
     yield { type: "event", event: await options.runCreatedEventPromise };
@@ -62,15 +55,12 @@ export async function* streamHarnessRun(options) {
             streamActivityObserved = true;
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
-                const rawEvent = normalizedChunk.event;
                 yield {
                     type: "upstream-event",
                     threadId: options.threadId,
                     runId: options.runId,
                     agentId: options.selectedAgentId,
-                    event: isUpstreamRuntimeEvent(rawEvent)
-                        ? rawEvent
-                        : normalizeUpstreamRuntimeEvent(rawEvent.raw ?? rawEvent),
+                    event: normalizedChunk.event,
                 };
                 continue;
             }
@@ -100,26 +90,6 @@ export async function* streamHarnessRun(options) {
                 return;
             }
             if (normalizedChunk.kind === "reasoning") {
-                await options.emit(options.threadId, options.runId, 3, "reasoning.delta", {
-                    content: normalizedChunk.content,
-                });
-                yield {
-                    type: "reasoning",
-                    threadId: options.threadId,
-                    runId: options.runId,
-                    agentId: options.selectedAgentId,
-                    content: normalizedChunk.content,
-                };
-                continue;
-            }
-            if (normalizedChunk.kind === "step") {
-                yield {
-                    type: "step",
-                    threadId: options.threadId,
-                    runId: options.runId,
-                    agentId: options.selectedAgentId,
-                    content: normalizedChunk.content,
-                };
                 continue;
             }
             if (normalizedChunk.kind === "tool-result") {

package/dist/runtime/harness.js

@@ -38,7 +38,6 @@ export class AgentHarnessRuntime {
         "run.queued",
         "run.dequeued",
         "output.delta",
-        "reasoning.delta",
     ]);
     eventBus = new EventBus();
     persistence;
@@ -464,15 +463,10 @@ export class AgentHarnessRuntime {
         const binding = getWorkspaceBinding(this.workspace, selectedAgentId);
         if (!binding) {
             const result = await this.run(options);
-            for (const line of result.output.split("\n")) {
-                yield {
-                    type: "content",
-                    threadId: result.threadId,
-                    runId: result.runId,
-                    agentId: result.agentId ?? selectedAgentId,
-                    content: `${line}\n`,
-                };
-            }
+            yield {
+                type: "result",
+                result,
+            };
             return;
         }
         const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
@@ -486,7 +480,7 @@ export class AgentHarnessRuntime {
                 state: "running",
             }),
         });
-        yield* streamHarnessRun({
+        const stream = streamHarnessRun({
             binding,
             input: options.input,
             invocation,
@@ -506,6 +500,11 @@ export class AgentHarnessRuntime {
             clearRunRequest: (threadId, runId) => this.persistence.clearRunRequest(threadId, runId),
             emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
+        for await (const item of stream) {
+            if (item.type === "event" || item.type === "upstream-event" || item.type === "result") {
+                yield item;
+            }
+        }
     }
     async resume(options) {
         return resumeRun({

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

@@ -1,2 +1,2 @@
 export { extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, isLikelyToolArgsObject, readTextContent, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./output-parsing.js";
-export { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, type RuntimeStreamChunk, } from "./stream-event-parsing.js";
+export { extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, type RuntimeStreamChunk, } from "./stream-event-parsing.js";

package/dist/runtime/parsing/index.js

@@ -1,2 +1,2 @@
 export { extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, isLikelyToolArgsObject, readTextContent, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./output-parsing.js";
-export { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./stream-event-parsing.js";
+export { extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./stream-event-parsing.js";

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -1,7 +1,6 @@
-import type { CompatibleStreamPart, UpstreamRuntimeEvent } from "../../contracts/types.js";
 export type RuntimeStreamChunk = {
     kind: "upstream-event";
-    event: UpstreamRuntimeEvent;
+    event: unknown;
 } | {
     kind: "content";
     content: string;
@@ -11,22 +10,16 @@ export type RuntimeStreamChunk = {
 } | {
     kind: "interrupt";
     content: string;
-} | {
-    kind: "step";
-    content: string;
 } | {
     kind: "tool-result";
     toolName: string;
     output: unknown;
     isError?: boolean;
 };
-export declare function normalizeUpstreamRuntimeEvent(event: unknown): UpstreamRuntimeEvent;
-export declare function extractCustomCompatibleStreamPart(event: unknown): CompatibleStreamPart | null;
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
 export declare function extractVisibleStreamOutput(event: unknown): string;
 export declare function extractStateStreamOutput(event: unknown): string;
-export declare function extractAgentStep(event: unknown): string | null;
 export declare function extractToolResult(event: unknown): {
     toolName: string;
     output: unknown;

package/dist/runtime/parsing/stream-event-parsing.js

@@ -1,254 +1,4 @@
 import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
-function asObject(value) {
-    return typeof value === "object" && value !== null ? value : undefined;
-}
-function extractCustomStreamData(event) {
-    const typed = asObject(event);
-    if (!typed) {
-        return null;
-    }
-    const eventName = typeof typed.event === "string" ? typed.event : "";
-    const ns = Array.isArray(typed.ns) ? typed.ns.filter((item) => typeof item === "string") : undefined;
-    const data = asObject(typed.data);
-    if (eventName === "on_custom_event") {
-        return {
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            data: typed.data,
-        };
-    }
-    if (eventName === "on_chain_stream" && data && "custom" in data) {
-        return {
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            data: data.custom,
-        };
-    }
-    return null;
-}
-export function normalizeUpstreamRuntimeEvent(event) {
-    const typed = asObject(event);
-    const tags = Array.isArray(typed?.tags) ? typed.tags.filter((item) => typeof item === "string") : undefined;
-    const ns = Array.isArray(typed?.ns) ? typed.ns.filter((item) => typeof item === "string") : undefined;
-    const name = typeof typed?.name === "string" ? typed.name : undefined;
-    const eventName = typeof typed?.event === "string" ? typed.event : undefined;
-    const runType = typeof typed?.run_type === "string" ? typed.run_type : undefined;
-    const data = asObject(typed?.data);
-    const metadata = asObject(typed?.metadata);
-    const normalized = normalizeUpstreamEventShape({
-        raw: event,
-        event: eventName,
-        name,
-        runType,
-        metadata,
-        tags,
-        data,
-        ns,
-    });
-    const streamPart = normalizeCompatibleStreamPart({
-        raw: event,
-        event: eventName,
-        name,
-        runType,
-        metadata,
-        tags,
-        data,
-        ns,
-        normalized,
-    });
-    return {
-        format: "langgraph-v2",
-        normalized,
-        raw: event,
-        event: eventName,
-        name,
-        runType,
-        data,
-        metadata,
-        ...(tags && tags.length > 0 ? { tags } : {}),
-        ...(ns && ns.length > 0 ? { ns } : {}),
-        streamPart,
-    };
-}
-function normalizeUpstreamEventShape(event) {
-    const nodeName = event.name;
-    const ns = event.ns;
-    const interruptPayload = extractInterruptPayload(event.raw);
-    if (interruptPayload) {
-        return {
-            kind: "interrupt",
-            interrupt: parseMaybeJson(interruptPayload),
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const reasoning = extractReasoningStreamOutput(event.raw);
-    if (reasoning) {
-        return {
-            kind: "reasoning-delta",
-            text: reasoning,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const visibleText = extractVisibleStreamOutput(event.raw);
-    if (visibleText) {
-        return {
-            kind: "text-delta",
-            source: "model",
-            text: visibleText,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const stateText = extractStateStreamOutput(event.raw);
-    if (stateText) {
-        return {
-            kind: "text-delta",
-            source: "state",
-            text: stateText,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    if (event.event === "on_tool_start" || (event.event === "on_chain_start" && event.runType === "tool")) {
-        return {
-            kind: "tool-start",
-            toolName: nodeName ?? "tool",
-            ...(event.data && "input" in event.data ? { input: event.data.input } : {}),
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const toolResult = extractToolResult(event.raw);
-    if (toolResult) {
-        return {
-            kind: "tool-end",
-            toolName: toolResult.toolName,
-            ...(toolResult.output !== undefined ? { output: toolResult.output } : {}),
-            ...(toolResult.isError !== undefined ? { isError: toolResult.isError } : {}),
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    const agentStep = extractAgentStep(event.raw);
-    if (agentStep) {
-        return {
-            kind: "agent-step",
-            label: agentStep,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
-    return {
-        kind: "run-event",
-        eventName: event.event ?? "unknown",
-        ...(event.data ? { data: event.data } : {}),
-        ...(ns && ns.length > 0 ? { ns } : {}),
-        ...(nodeName ? { nodeName } : {}),
-    };
-}
-function normalizeCompatibleStreamPart(event) {
-    const custom = extractCustomCompatibleStreamPart(event.raw);
-    if (custom) {
-        return custom;
-    }
-    const ns = event.ns ?? [];
-    const messageChunk = extractMessageCompatibleStreamPart(event);
-    if (messageChunk) {
-        return {
-            type: "messages",
-            ns,
-            data: [messageChunk, buildStreamPartMetadata(event)],
-        };
-    }
-    return {
-        type: "updates",
-        ns,
-        data: buildUpdateCompatiblePayload(event),
-    };
-}
-function buildStreamPartMetadata(event) {
-    return {
-        ...(event.metadata ?? {}),
-        ...(event.event ? { event: event.event } : {}),
-        ...(event.name ? { name: event.name } : {}),
-        ...(event.runType ? { run_type: event.runType } : {}),
-        ...(event.tags && event.tags.length > 0 ? { tags: event.tags } : {}),
-    };
-}
-function extractMessageCompatibleStreamPart(event) {
-    const typed = asObject(event.raw);
-    const data = asObject(typed?.data);
-    if (event.event === "on_chat_model_stream" && data && "chunk" in data) {
-        return data.chunk;
-    }
-    if (event.normalized.kind === "tool-end") {
-        return {
-            type: "tool",
-            name: event.normalized.toolName,
-            content: event.normalized.output,
-            ...(event.normalized.isError !== undefined ? { isError: event.normalized.isError } : {}),
-        };
-    }
-    return null;
-}
-function buildUpdateCompatiblePayload(event) {
-    const key = event.name ?? event.event ?? "event";
-    return {
-        [key]: extractUpdateNodePayload(event),
-    };
-}
-function extractUpdateNodePayload(event) {
-    const data = event.data;
-    if (event.event === "on_chain_stream" && data && "chunk" in data) {
-        return data.chunk;
-    }
-    if ((event.event === "on_tool_start" || event.event === "on_chain_start") && data && "input" in data) {
-        return { input: data.input };
-    }
-    if ((event.event === "on_tool_end" || event.event === "on_chain_end" || event.event === "on_chat_model_end") && data && "output" in data) {
-        return data.output;
-    }
-    if ((event.event === "on_tool_error" || event.event === "on_chain_error") && data) {
-        return {
-            ...(data.output !== undefined ? { output: data.output } : {}),
-            ...(data.error !== undefined ? { error: data.error } : {}),
-        };
-    }
-    if (event.normalized.kind === "interrupt") {
-        return { __interrupt__: event.normalized.interrupt };
-    }
-    return data ?? {};
-}
-export function extractCustomCompatibleStreamPart(event) {
-    const custom = extractCustomStreamData(event);
-    if (!custom) {
-        return null;
-    }
-    return {
-        type: "custom",
-        ns: custom.ns ?? [],
-        data: custom.data,
-    };
-}
-function formatStepValue(value, maxLength = 120) {
-    if (value == null)
-        return "";
-    const normalized = typeof value === "string"
-        ? parseMaybeJson(value)
-        : value;
-    const summarized = summarizeStepValue(normalized);
-    const serialized = typeof summarized === "string"
-        ? summarized
-        : (() => {
-            try {
-                return JSON.stringify(summarized);
-            }
-            catch {
-                return String(summarized);
-            }
-        })();
-    return serialized.length > maxLength ? serialized.slice(0, maxLength) + "…" : serialized;
-}
 function parseMaybeJson(value) {
     const trimmed = value.trim();
     if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
@@ -261,26 +11,6 @@ function parseMaybeJson(value) {
         return value;
     }
 }
-function summarizeStepValue(value) {
-    if (typeof value !== "object" || !value) {
-        return value;
-    }
-    const record = value;
-    if (typeof record.url === "string" && typeof record.status === "number") {
-        const warnings = Array.isArray(record.warnings) ? record.warnings.filter((item) => typeof item === "string") : [];
-        return {
-            status: record.status,
-            ok: record.ok,
-            quality: record.quality,
-            source: record.source,
-            warnings,
-        };
-    }
-    return value;
-}
-function humanizeEventName(name) {
-    return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
-}
 function readToolErrorText(value) {
     if (typeof value === "string") {
         return value;
@@ -352,57 +82,6 @@ export function extractStateStreamOutput(event) {
     }
     return extractVisibleOutput(chunk);
 }
-export function extractAgentStep(event) {
-    if (typeof event !== "object" || !event)
-        return null;
-    const typed = event;
-    const name = typeof typed.name === "string" ? typed.name : "";
-    if (typed.event === "on_tool_start" || (typed.event === "on_chain_start" && typed.run_type === "tool")) {
-        const inputSummary = formatStepValue(typed.data?.input);
-        return inputSummary ? `tool ${name || "tool"}  ${inputSummary}` : `tool ${name || "tool"}`;
-    }
-    if (typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool")) {
-        const outputSummary = formatStepValue(typed.data?.output, 80);
-        return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
-    }
-    if (typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool")) {
-        const errorSummary = formatStepValue(typed.data?.error ?? typed.data?.output, 80);
-        return errorSummary ? `tool ${name || "tool"} error  ${errorSummary}` : `tool ${name || "tool"} error`;
-    }
-    if (typed.event === "on_chat_model_start") {
-        const inputTools = typed.data?.input?.tools;
-        const tools = typed.invocation_params?.tools ?? inputTools ?? [];
-        const toolNames = tools.map((tool) => tool.name ?? tool.function?.name).filter((toolName) => typeof toolName === "string").join(", ");
-        return toolNames ? `calling model  tools: [${toolNames}]` : "calling model…";
-    }
-    if (typed.event === "on_chain_start") {
-        if (/SkillsMiddleware/i.test(name))
-            return "loading skills…";
-        if (/MemoryMiddleware/i.test(name))
-            return "loading memory…";
-        if (/patchToolCallsMiddleware/i.test(name))
-            return "normalizing tool calls…";
-        if (/HumanInTheLoopMiddleware/i.test(name))
-            return "checking approvals…";
-        if (/todoListMiddleware/i.test(name))
-            return "updating plan…";
-        if (/model_request/i.test(name))
-            return "preparing model request…";
-        if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
-            return null;
-        if (/(subagent|specialist)/i.test(name))
-            return `starting ${humanizeEventName(name)}…`;
-        if (/agent$/i.test(name))
-            return `running ${humanizeEventName(name)}…`;
-    }
-    if (typed.event === "on_chain_end") {
-        if (/(subagent|specialist)/i.test(name))
-            return `${humanizeEventName(name)} done`;
-        if (/agent$/i.test(name) && !/^__start__$/.test(name))
-            return `${humanizeEventName(name)} done`;
-    }
-    return null;
-}
 export function extractToolResult(event) {
     if (typeof event !== "object" || !event)
         return null;

package/dist/runtime/support/compiled-binding.d.ts

@@ -1,8 +1,8 @@
-import type { CompiledAgentBinding, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LegacyDeepAgentParams, LegacyLangChainAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
-    langchainParams?: LangChainAgentParams;
-    deepAgentParams?: DeepAgentParams;
+    langchainParams?: LegacyLangChainAgentParams;
+    deepAgentParams?: LegacyDeepAgentParams;
     executionParams?: LangChainAgentParams | DeepAgentParams;
     primaryTools: CompiledTool[];
     primaryModel?: CompiledModel;
@@ -19,8 +19,8 @@ export declare function getBindingExecutionView(binding: CompiledAgentBinding):
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
 export declare function getBindingCanonicalExecution(binding: CompiledAgentBinding): CompiledExecutionBinding | undefined;
 export declare function getBindingRuntimeExecutionMode(binding: CompiledAgentBinding): string;
-export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
-export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
+export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LegacyLangChainAgentParams | undefined;
+export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): LegacyDeepAgentParams | undefined;
 export declare function getBindingExecutionParams(binding: CompiledAgentBinding): LangChainAgentParams | DeepAgentParams | undefined;
 export declare function getBindingExecutionKind(binding: CompiledAgentBinding): "langchain-v1" | "deepagent" | undefined;
 export declare function withUpdatedBindingExecutionParams(binding: CompiledAgentBinding, updater: (params: LangChainAgentParams | DeepAgentParams) => LangChainAgentParams | DeepAgentParams): CompiledAgentBinding;