@botbotgo/agent-harness 0.0.327 → 0.0.328

package/dist/cli/main.js

@@ -24,6 +24,33 @@ import { isTopLevelCliCommand, parseChatOptions, parseInitOptions, parseTopLevel
 import { resolveCliWorkspaceRoot, validateCliWorkspaceRoot, } from "./workspace.js";
 export { renderChatBanner, renderChatPromptLine } from "./chat-ui.js";
 export { probeChatWorkspace, renderChatRuntimeFailure } from "./chat-workspace.js";
+async function stopClientWithTimeout(client, stderr, timeoutMs = 5000) {
+    if (!client) {
+        return;
+    }
+    let timeoutHandle;
+    try {
+        await Promise.race([
+            client.stop(),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    reject(new Error(`Timed out after ${timeoutMs}ms while stopping the chat client.`));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/^Timed out after \d+ms while stopping the chat client\.$/.test(message)) {
+            stderr(`${message}\n`);
+        }
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
 export { installChatSubprocessExitGuard, isChatServerNoiseLine } from "./process-guards.js";
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -150,7 +177,7 @@ export async function runCli(argv, io = {}, deps = {}) {
                     showToolResults: parsed.requestEvents,
                     showRunningState: false,
                 });
-                await client.stop();
+                await stopClientWithTimeout(client, stderr);
                 restoreWriteListenerGuard?.();
                 restoreEmitterListenerGuard?.();
                 restoreStderrNoiseFilter?.();
@@ -199,7 +226,7 @@ export async function runCli(argv, io = {}, deps = {}) {
             activeAgentId = interactiveState.activeAgentId;
             activeSessionId = interactiveState.activeSessionId;
             latestRequestId = interactiveState.latestRequestId;
-            await client.stop();
+            await stopClientWithTimeout(client, stderr);
             restoreWriteListenerGuard?.();
             restoreEmitterListenerGuard?.();
             restoreStderrNoiseFilter?.();
@@ -214,7 +241,7 @@ export async function runCli(argv, io = {}, deps = {}) {
             const message = error instanceof Error ? error.message : String(error);
             stderr(`${message}\n`);
             if (client) {
-                await client.stop().catch(() => undefined);
+                await stopClientWithTimeout(client, () => undefined);
             }
             return 1;
         }

package/dist/contracts/runtime-requests.d.ts

@@ -49,7 +49,7 @@ export type RequestExecutionStep = {
     output?: unknown;
     isError?: boolean;
 };
-export type RequestPlanItemStatus = "pending" | "in_progress" | "completed" | "failed" | "cancelled" | "blocked" | (string & {});
+export type RequestPlanItemStatus = "pending" | "in_progress" | "completed" | "failed" | "cancelled" | (string & {});
 export type RequestPlanItem = {
     id?: string;
     content: string;
@@ -67,7 +67,6 @@ export type RequestPlanSummary = {
     completed: number;
     failed: number;
     cancelled: number;
-    blocked: number;
 };
 export type RequestPlanState = {
     sessionId: string;

package/dist/contracts/runtime-scheduling.d.ts

@@ -92,12 +92,12 @@ export type RuntimeAdapterOptions = {
     storeResolver?: RuntimeStoreResolver;
     backendResolver?: RuntimeBackendResolver;
     scheduleManager?: RuntimeScheduleManager;
+    bindingResolver?: (agentId: string) => CompiledAgentBinding | undefined;
     functionToolContextResolver?: (input: {
         binding?: CompiledAgentBinding;
         sessionId?: string;
         requestId?: string;
     }) => Record<string, unknown> | undefined;
-    deepAgentUpstreamSubstrateMode?: "full" | "minimal";
 };
 export type ToolKindAdapter = {
     type: string;

package/dist/flow/flow-graph-upstream.js

@@ -78,13 +78,9 @@ function extractDelegatedAgentId(event) {
         : asObject(input?.input);
     const subagentType = typeof input?.subagent_type === "string"
         ? input.subagent_type
-        : typeof input?.subagentType === "string"
-            ? input.subagentType
-            : typeof nestedInput?.subagent_type === "string"
-                ? nestedInput.subagent_type
-                : typeof nestedInput?.subagentType === "string"
-                    ? nestedInput.subagentType
-                    : null;
+        : typeof nestedInput?.subagent_type === "string"
+            ? nestedInput.subagent_type
+            : null;
     return subagentType && subagentType.trim().length > 0 ? subagentType.trim() : null;
 }
 export function convertUpstreamEventsWithAgents(upstreamEvents, initialAgentId) {

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.326";
+export declare const AGENT_HARNESS_VERSION = "0.0.327";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-22";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.326";
+export const AGENT_HARNESS_VERSION = "0.0.327";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-22";

package/dist/projections/request-events.js

@@ -10,7 +10,6 @@ function createEmptyPlanSummary() {
         completed: 0,
         failed: 0,
         cancelled: 0,
-        blocked: 0,
     };
 }
 function resolveTodoKey(content, id, index) {

package/dist/resource/isolation.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
-import { cp, mkdir, readFile, stat, symlink } from "node:fs/promises";
+import { cp, mkdir, readFile, realpath, stat, symlink } from "node:fs/promises";
 const HARNESS_PACKAGE_NAME = "@botbotgo/agent-harness";
 const HARNESS_PACKAGE_ROOT = path.resolve(import.meta.dirname, "..", "..");
 const HARNESS_TOOL_AUTHORING_DEPENDENCIES = [
@@ -32,8 +32,17 @@ function declaredDependencyNames(manifest) {
 function dependencyLinkPath(isolatedRoot, dependencyName) {
     return path.join(isolatedRoot, "node_modules", ...dependencyName.split("/"));
 }
-function dependencyPackageRoot(packageJsonPath) {
-    return path.dirname(packageJsonPath);
+function resourcePackageManifestPath(packageRoot) {
+    return path.join(packageRoot, "package.json");
+}
+function hasResourcePackageManifest(packageRoot) {
+    return existsSync(resourcePackageManifestPath(packageRoot));
+}
+function hasInstalledNodeModules(packageRoot) {
+    return existsSync(path.join(packageRoot, "node_modules"));
+}
+async function dependencyPackageRoot(packageJsonPath) {
+    return realpath(path.dirname(packageJsonPath)).catch(() => path.dirname(packageJsonPath));
 }
 function declaredDependencySpec(manifest, dependencyName) {
     return manifest.dependencies?.[dependencyName]
@@ -56,9 +65,9 @@ function resolveDeclaredFileDependency(packageRoot, spec) {
     if (!existsSync(packageJsonPath)) {
         return null;
     }
-    return dependencyPackageRoot(packageJsonPath);
+    return path.dirname(packageJsonPath);
 }
-function resolveDeclaredDependency(packageRoot, manifest, dependencyName) {
+async function resolveDeclaredDependency(packageRoot, manifest, dependencyName) {
     const localPath = path.join(packageRoot, "node_modules", ...dependencyName.split("/"), "package.json");
     if (existsSync(localPath)) {
         return dependencyPackageRoot(localPath);
@@ -66,7 +75,7 @@ function resolveDeclaredDependency(packageRoot, manifest, dependencyName) {
     const declaredSpec = declaredDependencySpec(manifest, dependencyName);
     const localFileDependency = declaredSpec ? resolveDeclaredFileDependency(packageRoot, declaredSpec) : null;
     if (localFileDependency) {
-        return localFileDependency;
+        return realpath(localFileDependency).catch(() => localFileDependency);
     }
     try {
         const requireFromPackage = createRequire(path.join(packageRoot, "package.json"));
@@ -78,7 +87,7 @@ function resolveDeclaredDependency(packageRoot, manifest, dependencyName) {
 }
 async function linkDeclaredDependencies(isolatedRoot, packageRoot, manifest) {
     for (const dependencyName of declaredDependencyNames(manifest)) {
-        const resolved = resolveDeclaredDependency(packageRoot, manifest, dependencyName);
+        const resolved = await resolveDeclaredDependency(packageRoot, manifest, dependencyName);
         if (!resolved) {
             continue;
         }
@@ -95,7 +104,7 @@ async function linkHarnessPackage(isolatedRoot) {
     await mkdir(path.dirname(targetPath), { recursive: true });
     await symlink(HARNESS_PACKAGE_ROOT, targetPath, "junction");
 }
-function resolveHarnessOwnedDependency(dependencyName) {
+async function resolveHarnessOwnedDependency(dependencyName) {
     try {
         const requireFromHarness = createRequire(path.join(HARNESS_PACKAGE_ROOT, "package.json"));
         return dependencyPackageRoot(requireFromHarness.resolve(`${dependencyName}/package.json`));
@@ -110,7 +119,7 @@ async function linkHarnessToolAuthoringDependencies(isolatedRoot) {
         if (existsSync(targetPath)) {
             continue;
         }
-        const resolved = resolveHarnessOwnedDependency(dependencyName);
+        const resolved = await resolveHarnessOwnedDependency(dependencyName);
         if (!resolved) {
             continue;
         }
@@ -119,7 +128,7 @@ async function linkHarnessToolAuthoringDependencies(isolatedRoot) {
     }
 }
 async function buildIsolatedResourceRoot(packageRoot) {
-    const packageJsonPath = path.join(packageRoot, "package.json");
+    const packageJsonPath = resourcePackageManifestPath(packageRoot);
     const manifest = existsSync(packageJsonPath)
         ? JSON.parse(await readFile(packageJsonPath, "utf8"))
         : {};
@@ -139,6 +148,35 @@ async function buildIsolatedResourceRoot(packageRoot) {
     await linkHarnessToolAuthoringDependencies(isolatedRoot);
     return isolatedRoot;
 }
+async function readResourcePackageManifest(packageRoot) {
+    const packageJsonPath = resourcePackageManifestPath(packageRoot);
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    return JSON.parse(await readFile(packageJsonPath, "utf8"));
+}
+async function validateInstalledResourcePackage(packageRoot) {
+    const manifest = await readResourcePackageManifest(packageRoot);
+    if (!manifest) {
+        return false;
+    }
+    const dependencyNames = declaredDependencyNames(manifest);
+    if (dependencyNames.length === 0) {
+        return true;
+    }
+    const missingDependencies = [];
+    for (const dependencyName of dependencyNames) {
+        const resolved = await resolveDeclaredDependency(packageRoot, manifest, dependencyName);
+        if (!resolved) {
+            missingDependencies.push(dependencyName);
+        }
+    }
+    if (missingDependencies.length > 0) {
+        const packageLabel = manifest.name ? `${manifest.name} ` : "";
+        throw new Error(`Resource package ${packageLabel}at ${packageRoot} is missing installed dependencies: ${missingDependencies.join(", ")}. Run npm install in ${packageRoot}.`);
+    }
+    return true;
+}
 async function rebuildIsolatedResourcePackageRoot(packageRoot) {
     const existingBuild = isolatedResourceRootBuilds.get(packageRoot);
     if (existingBuild) {
@@ -171,6 +209,9 @@ export async function ensureIsolatedResourcePackageRoot(packageRoot) {
     return rebuildIsolatedResourcePackageRoot(packageRoot);
 }
 export async function resolveIsolatedResourceModulePath(packageRoot, sourcePath) {
+    if (hasResourcePackageManifest(packageRoot) && hasInstalledNodeModules(packageRoot) && await validateInstalledResourcePackage(packageRoot)) {
+        return sourcePath;
+    }
     const relativeSourcePath = path.relative(packageRoot, sourcePath);
     let isolatedRoot = await ensureIsolatedResourcePackageRoot(packageRoot);
     let isolatedSourcePath = path.join(isolatedRoot, relativeSourcePath);

package/dist/resources/toolkit.mjs

@@ -0,0 +1,183 @@
+export const TOOL_DEFINITION_MARKER = "__agent_harness_tool_definition__";
+
+function isZodSchema(value) {
+  return typeof value === "object" && value !== null && typeof value.parse === "function";
+}
+
+function isParseableSchema(value) {
+  return typeof value === "object" && value !== null && typeof value.parse === "function";
+}
+
+function getZodLikeTypeName(value) {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+  if (typeof value.def?.type === "string") {
+    return value.def.type;
+  }
+  if (typeof value._zod?.def?.type === "string") {
+    return value._zod.def.type;
+  }
+  if (typeof value._def?.typeName === "string") {
+    return value._def.typeName.replace(/^Zod/, "").toLowerCase();
+  }
+  return undefined;
+}
+
+function getZodLikeObjectShape(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const directShape = typeof value.shape === "function"
+    ? value.shape()
+    : typeof value._def?.shape === "function"
+      ? value._def.shape()
+      : value.shape;
+  if (typeof directShape === "object" && directShape !== null && !Array.isArray(directShape)) {
+    return directShape;
+  }
+  const zod4Shape = typeof value._zod?.def?.shape === "function" ? value._zod.def.shape() : value._zod?.def?.shape;
+  if (typeof zod4Shape === "object" && zod4Shape !== null && !Array.isArray(zod4Shape)) {
+    return zod4Shape;
+  }
+  return undefined;
+}
+
+function getZodLikeInnerSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+  return value.def?.innerType
+    ?? value.def?.element
+    ?? value.def?.valueType
+    ?? value.def?.schema
+    ?? value.def?.out
+    ?? value.def?.in
+    ?? value._zod?.def?.innerType
+    ?? value._zod?.def?.element
+    ?? value._zod?.def?.valueType
+    ?? value._def?.innerType
+    ?? value._def?.schema
+    ?? value._def?.type
+    ?? value._def?.valueType
+    ?? value._def?.in
+    ?? value._def?.out;
+}
+
+function isEffectWrappedOptional(value) {
+  const typeName = getZodLikeTypeName(value);
+  if (typeName !== "effects" && typeName !== "pipeline" && typeName !== "pipe" && typeName !== "transform") {
+    return false;
+  }
+  const inner = getZodLikeInnerSchema(value);
+  const innerTypeName = getZodLikeTypeName(inner);
+  return innerTypeName === "optional" || innerTypeName === "default" || innerTypeName === "catch";
+}
+
+function buildJsonSchemaFromZodLike(value) {
+  const shape = getZodLikeObjectShape(value);
+  if (shape) {
+    const properties = Object.fromEntries(
+      Object.entries(shape).map(([key, entry]) => [key, buildJsonSchemaFromZodLike(getZodLikeInnerSchema(entry) ?? entry) ?? {}]),
+    );
+    const required = Object.entries(shape)
+      .filter(([, entry]) => {
+        const typeName = getZodLikeTypeName(entry);
+        return typeName !== "optional" && typeName !== "default" && typeName !== "catch" && !isEffectWrappedOptional(entry);
+      })
+      .map(([key]) => key);
+    return {
+      type: "object",
+      properties,
+      ...(required.length > 0 ? { required } : {}),
+    };
+  }
+  const typeName = getZodLikeTypeName(value);
+  switch (typeName) {
+    case "string":
+      return { type: "string" };
+    case "number":
+      return { type: "number" };
+    case "int":
+    case "integer":
+      return { type: "integer" };
+    case "boolean":
+      return { type: "boolean" };
+    case "unknown":
+    case "any":
+      return {};
+    case "array":
+      return {
+        type: "array",
+        items: buildJsonSchemaFromZodLike(getZodLikeInnerSchema(value)) ?? {},
+      };
+    case "record":
+      return {
+        type: "object",
+        additionalProperties: buildJsonSchemaFromZodLike(getZodLikeInnerSchema(value)) ?? {},
+      };
+    case "optional":
+    case "nullable":
+    case "default":
+    case "catch":
+    case "effects":
+    case "pipeline":
+    case "pipe":
+    case "transform":
+      return buildJsonSchemaFromZodLike(getZodLikeInnerSchema(value)) ?? {};
+    default:
+      return undefined;
+  }
+}
+
+export function buildToolJsonSchema(schema) {
+  if (!schema) {
+    return undefined;
+  }
+  if (isZodSchema(schema)) {
+    return buildJsonSchemaFromZodLike(schema);
+  }
+  return {
+    type: "object",
+    properties: Object.fromEntries(Object.entries(schema).map(([key, value]) => [key, buildJsonSchemaFromZodLike(value) ?? {}])),
+    required: Object.entries(schema)
+      .filter(([, value]) => {
+        const typeName = getZodLikeTypeName(value);
+        return typeName !== "optional" && typeName !== "default" && typeName !== "catch" && !isEffectWrappedOptional(value);
+      })
+      .map(([key]) => key),
+  };
+}
+
+export function normalizeToolSchema(schema) {
+  if (isZodSchema(schema)) {
+    return schema;
+  }
+  const rawShape = schema;
+  return {
+    shape: rawShape,
+    parse(input) {
+      const source = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+      const parsed = {};
+      for (const [key, validator] of Object.entries(rawShape)) {
+        if (!isParseableSchema(validator)) {
+          throw new TypeError(`Tool schema field '${key}' is not parseable.`);
+        }
+        const hasValue = Object.prototype.hasOwnProperty.call(source, key);
+        const value = hasValue ? source[key] : undefined;
+        const parsedValue = validator.parse(value);
+        if (parsedValue !== undefined) {
+          parsed[key] = parsedValue;
+        }
+      }
+      return parsed;
+    },
+  };
+}
+
+export function tool(definition) {
+  return {
+    ...definition,
+    [TOOL_DEFINITION_MARKER]: true,
+  };
+}

package/dist/resources/tools/cancel_request.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getRuntimeApi, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const cancel_request = tool({

package/dist/resources/tools/fetch_url.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, formatHttpResponse, getBackend, maybePersistLargeToolOutput, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const fetch_url = tool({

package/dist/resources/tools/http_request.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, formatHttpResponse, getBackend, maybePersistLargeToolOutput, optionalString, optionalStringRecord } from "./_runtime_tool_helpers.mjs";
 
 export const http_request = tool({

package/dist/resources/tools/inspect_approvals.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getRuntimeApi, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const inspect_approvals = tool({

package/dist/resources/tools/inspect_artifacts.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getCurrentRequestIdentity, getRuntimeApi, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const inspect_artifacts = tool({

package/dist/resources/tools/inspect_events.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getCurrentRequestIdentity, getRuntimeApi, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const inspect_events = tool({

package/dist/resources/tools/inspect_requests.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getRuntimeApi, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const inspect_requests = tool({

package/dist/resources/tools/inspect_sessions.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getRuntimeApi, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const inspect_sessions = tool({

package/dist/resources/tools/list_files.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, formatListEntries, getBackend, normalizeWorkspacePath, optionalString, tryExecuteShallowDirectoryListing } from "./_runtime_tool_helpers.mjs";
 
 export const list_files = tool({

package/dist/resources/tools/read_artifact.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getCurrentRequestIdentity, getRuntimeApi, notAvailable, optionalString, requiredString } from "./_runtime_tool_helpers.mjs";
 
 export const read_artifact = tool({

package/dist/resources/tools/request_approval.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getBackend, notAvailable, optionalObject, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const request_approval = tool({

package/dist/resources/tools/run_command.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getBackend, notAvailable, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const run_command = tool({

package/dist/resources/tools/schedule_task.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getBackend, getRuntimeApi, notAvailable, optionalObject, optionalString } from "./_runtime_tool_helpers.mjs";
 
 function parseScheduleWhen(value) {

package/dist/resources/tools/search_files.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import {
   defineSchema,
   formatGrepResult,

package/dist/resources/tools/send_message.mjs

@@ -1,4 +1,4 @@
-import { tool } from "@botbotgo/agent-harness/tools";
+import { tool } from "../toolkit.mjs";
 import { defineSchema, getBackend, notAvailable, optionalObject, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const send_message = tool({

package/dist/runtime/adapter/compat/deepagent-compat.d.ts

@@ -1,9 +1,3 @@
-import type { CompiledModel, CompiledSubAgent } from "../../../contracts/types.js";
-type DelegationPromptCompatibilityParams = {
-    subagents?: CompiledSubAgent[];
-    generalPurposeAgent?: boolean;
-    taskDescription?: string;
-};
 export declare function relativizeDeepAgentSkillSourcePaths(workspaceRoot: string | undefined, skillPaths: string[] | undefined): string[] | undefined;
 export declare function materializeDeepAgentSkillSourcePaths(options: {
     workspaceRoot?: string;
@@ -17,6 +11,3 @@ export declare function resolveDeepAgentSkillSourcePaths(options: {
     ownerId: string;
     skillPaths?: string[];
 }): string[] | undefined;
-export declare function shouldRelaxDeepAgentDelegationPrompt(model: CompiledModel | undefined, params: DelegationPromptCompatibilityParams): boolean;
-export declare function applyDeepAgentDelegationPromptCompatibility<T extends DelegationPromptCompatibilityParams>(model: CompiledModel | undefined, params: T): T;
-export {};

package/dist/runtime/adapter/compat/deepagent-compat.js

@@ -1,7 +1,4 @@
 import path from "node:path";
-function isOpenAICompatibleGptOssModel(model) {
-    return model?.provider === "openai-compatible" && model.model.trim().toLowerCase().startsWith("gpt-oss");
-}
 export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
     if (!workspaceRoot || !skillPaths) {
         return skillPaths;
@@ -27,22 +24,3 @@ export function resolveDeepAgentSkillSourcePaths(options) {
     }
     return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
 }
-export function shouldRelaxDeepAgentDelegationPrompt(model, params) {
-    if (!isOpenAICompatibleGptOssModel(model)) {
-        return false;
-    }
-    if ((params.subagents?.length ?? 0) === 0) {
-        return false;
-    }
-    return params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
-}
-export function applyDeepAgentDelegationPromptCompatibility(model, params) {
-    if (!shouldRelaxDeepAgentDelegationPrompt(model, params)) {
-        return params;
-    }
-    return {
-        ...params,
-        generalPurposeAgent: undefined,
-        taskDescription: undefined,
-    };
-}

package/dist/runtime/adapter/flow/stream-runtime.d.ts

@@ -5,6 +5,9 @@ type RunnableLike = {
     stream?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
     streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
 };
+export declare class ExecutionReconciliationError extends Error {
+    constructor(message: string);
+}
 export declare function streamRuntimeExecution(options: {
     binding: CompiledAgentBinding;
     input: MessageContent;
@@ -48,5 +51,6 @@ export declare function streamRuntimeExecution(options: {
     isLangChainBinding: (binding: CompiledAgentBinding) => boolean;
     isDeepAgentBinding: (binding: CompiledAgentBinding) => boolean;
     countConfiguredTools: (binding: CompiledAgentBinding) => number;
+    countConfiguredToolsForAgentId?: (agentId: string) => number;
 }): AsyncGenerator<RuntimeStreamChunk>;
 export {};