@botbotgo/agent-harness 0.0.462 → 0.0.463

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.462";
+export declare const AGENT_HARNESS_VERSION = "0.0.463";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.462";
+export const AGENT_HARNESS_VERSION = "0.0.463";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -25,6 +25,8 @@ const RUN_EVIDENCE_AFTER_PREMATURE_PLAN_CLOSE_INSTRUCTION = [
     "The required todo board was closed before any non-TODO evidence tool returned.",
     "Do not call write_todos again yet.",
     "Your next action must be exactly one non-TODO evidence tool call selected from the available tool descriptions and schemas.",
+    "If the current request or todo board explicitly names one available non-TODO tool, call that named tool.",
+    "Do not substitute a neighboring, broader, narrower, or similarly named tool when an exact available tool name is present.",
     "After that evidence tool returns, update the todo board and then provide the final answer required by the agent response format.",
 ].join("\n");
 function readPrimaryToolName(tool) {
@@ -43,11 +45,11 @@ function buildRunEvidenceAfterPlanInstruction(primaryTools) {
         `Available non-planning tool names: ${toolNames.join(", ")}.`,
     ].join("\n");
 }
-function resolveConfiguredPlanEvidenceTool(primaryTools) {
-    const toolName = primaryTools
+function resolveSingleConfiguredPlanEvidenceTool(primaryTools) {
+    const toolNames = primaryTools
         .map(readPrimaryToolName)
-        .find((name) => name.length > 0 && !isPlanToolName(name));
-    return toolName ? [{ name: toolName, args: {}, id: "stream-configured-plan-evidence-tool-1" }] : [];
+        .filter((name) => name.length > 0 && !isPlanToolName(name));
+    return toolNames.length === 1 ? [{ name: toolNames[0], args: {}, id: "stream-single-plan-evidence-tool-1" }] : [];
 }
 const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
     "This agent has a required visible planning contract.",
@@ -704,7 +706,7 @@ export async function* streamRuntimeExecution(options) {
                             && hadPriorPlanToolResult
                             && projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName));
                         if (repeatedPlanToolResultBeforeEvidence) {
-                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
                             earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
@@ -750,7 +752,7 @@ export async function* streamRuntimeExecution(options) {
                             && (hadPriorPlanToolResult
                                 || projectedChunks.some((chunk) => isCompletedPlanToolResultChunk(chunk)))
                             && !sawSuccessfulNonTodoToolResult) {
-                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
                             earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;

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

@@ -13,15 +13,21 @@ const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already availab
 const DEFAULT_MAX_TOOL_ITERATIONS = 10_000;
 const MAX_REPEATED_RECOVERY_WITHOUT_PROGRESS = 2;
 const MAX_REPEATED_PLAN_ONLY_AFTER_PLAN = 2;
-function prioritizeBootstrapEvidenceTools(primaryTools) {
+const REQUIRED_PLAN_CONTRACT_MARKER = "This agent has a required visible planning contract.";
+const INITIAL_WRITE_TODOS_MARKER = "Your first action for this request must be write_todos";
+function resolveSingleBootstrapEvidenceTool(primaryTools) {
     const evidenceTools = primaryTools
         .map((tool) => typeof tool.name === "string" ? tool.name.trim() : "")
         .filter((name) => name.length > 0 && !isPlanToolName(name));
-    return evidenceTools.slice(0, 4);
+    return evidenceTools.length === 1 ? evidenceTools[0] : undefined;
 }
 function createBootstrapTodoPlan(primaryTools) {
-    const evidenceTool = prioritizeBootstrapEvidenceTools(primaryTools)[0];
-    if (!evidenceTool) {
+    const evidenceTool = resolveSingleBootstrapEvidenceTool(primaryTools);
+    const evidenceToolCount = primaryTools
+        .map((tool) => typeof tool.name === "string" ? tool.name.trim() : "")
+        .filter((name) => name.length > 0 && !isPlanToolName(name))
+        .length;
+    if (evidenceToolCount === 0) {
         return [
             {
                 content: "Establish the required visible plan for this request",
@@ -35,7 +41,9 @@ function createBootstrapTodoPlan(primaryTools) {
     }
     return [
         {
-            content: `Run the configured non-planning evidence tool: ${evidenceTool}`,
+            content: evidenceTool
+                ? `Run the only configured non-planning evidence tool: ${evidenceTool}`
+                : "Select and run the appropriate non-planning evidence tool from the declared tool surface",
             status: "in_progress",
         },
         {
@@ -76,6 +84,15 @@ function buildExternalPlanEvidenceToolResult(tools) {
             }],
     };
 }
+function stripSatisfiedInitialPlanInstruction(messages) {
+    return messages.filter((message) => {
+        const typed = typeof message === "object" && message !== null ? message : {};
+        if (typeof typed.content !== "string") {
+            return true;
+        }
+        return !(typed.content.includes(REQUIRED_PLAN_CONTRACT_MARKER) && typed.content.includes(INITIAL_WRITE_TODOS_MARKER));
+    });
+}
 function readPlanStateSummary(output) {
     if (typeof output !== "object" || output === null) {
         return null;
@@ -217,7 +234,7 @@ function debugLocalToolReplay(input) {
     }
     console.error(JSON.stringify({
         type: "local-tool-replay",
-        toolCallNames: input.toolCalls.map((toolCall) => toolCall.name),
+        toolCalls: input.toolCalls.map((toolCall) => ({ name: toolCall.name, args: toolCall.args })),
         resultMessages: summarizeResultMessages(input.result),
         executableToolNames: input.executableToolNames,
         builtinToolNames: input.builtinToolNames,
@@ -534,7 +551,9 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 executedToolResults,
             };
         }
-        currentMessages = nextMessages;
+        currentMessages = hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
+            ? stripSatisfiedInitialPlanInstruction(nextMessages)
+            : nextMessages;
         activeRequest = {
             ...activeRequest,
             messages: currentMessages,

package/dist/runtime/adapter/model/model-providers.js

@@ -6,7 +6,7 @@ import { ChatOpenAI } from "@langchain/openai";
 import { AIMessage } from "langchain";
 import { initChatModel } from "langchain";
 import { salvageToolArgs, tryParseJson } from "../../parsing/output-parsing.js";
-import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
+import { normalizeKnownToolArgs, salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { normalizeModelFacingToolSchema } from "../tool/resolved-tool.js";
 import { normalizeOpenAICompatibleInit } from "../compat/openai-compatible.js";
 import { recordPromptedJsonToolCall } from "./prompted-json-tool-call-capture.js";
@@ -640,7 +640,7 @@ function normalizeParsedToolCall(payload) {
     const args = Array.isArray(argsCandidate)
         ? { args: argsCandidate }
         : salvageToolArgs(argsCandidate) ?? {};
-    return { name, args };
+    return { name, args: normalizeKnownToolArgs(name, args) };
 }
 function buildFallbackTodoContents() {
     return [
@@ -770,6 +770,8 @@ function withPromptedJsonToolPrompt(input, tools, options = {}) {
             ? [
                 "Required evidence tool call:",
                 "A todo board already exists. Your next action must be exactly one non-planning tool call chosen from the available tool descriptions and schemas.",
+                "If the current request or todo board explicitly names one available non-planning tool, call that named tool.",
+                "Do not substitute a neighboring, broader, narrower, or similarly named tool when an exact available tool name is present.",
                 "Do not call write_todos or read_todos now.",
                 "Do not write prose, markdown, analysis, or a plain-text plan.",
             ].join("\n")

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -1,5 +1,5 @@
 import { salvageToolArgs } from "../../parsing/output-parsing.js";
-import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
+import { normalizeKnownToolArgs, salvageJsonToolCalls, salvageResultLabeledToolCall } from "../../parsing/output-tool-args.js";
 import { isRecord } from "../../../utils/object.js";
 import { extractExplicitResourceReferences, hasExplicitResourceReference } from "../../harness/system/runtime-memory-policy.js";
 import { readCapturedPromptedJsonToolCalls } from "../model/prompted-json-tool-call-capture.js";
@@ -175,6 +175,29 @@ function mapDelimitedListLikeArgs(args) {
     }
     return next;
 }
+function dropDelimitedScalarPathArgs(args, shape) {
+    let next = args;
+    for (const [key, schemaPart] of Object.entries(shape)) {
+        const value = next[key];
+        if (typeof value !== "string") {
+            continue;
+        }
+        const normalizedKey = key.trim().toLowerCase();
+        if (!/(?:^path$|path$|^filepath$|^targetpath$)/u.test(normalizedKey)) {
+            continue;
+        }
+        if (schemaPartExpectsArray(schemaPart)) {
+            continue;
+        }
+        const raw = value.trim();
+        if (!/[,;\n]/u.test(raw)) {
+            continue;
+        }
+        const { [key]: _dropped, ...rest } = next;
+        next = rest;
+    }
+    return next;
+}
 export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options = {}) {
     const schemaDef = isObject(schema) ? schema._def : undefined;
     const zodShape = schemaDef
@@ -191,7 +214,7 @@ export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options =
     if (!shape || !isRecord(shape)) {
         return mapDelimitedListLikeArgs(args);
     }
-    const aliasMappedArgs = mapStringArrayFields(mapCommonArgumentAliases(args, shape), shape);
+    const aliasMappedArgs = dropDelimitedScalarPathArgs(mapStringArrayFields(mapCommonArgumentAliases(args, shape), shape), shape);
     const keys = Object.keys(shape);
     if (keys.length !== 1) {
         return fillLatestUserInputForQueryLikeFields(aliasMappedArgs, shape, options.latestUserInput);
@@ -270,7 +293,7 @@ export function extractToolCallsFromResult(result) {
             if (id && answeredToolCallIds.has(id)) {
                 return null;
             }
-            return { id, name, args: rawArgs, rawArgsInput };
+            return { id, name, args: normalizeKnownToolArgs(name, rawArgs), rawArgsInput };
         })
             .filter((item) => item !== null);
         if (extracted.length > 0) {
@@ -296,6 +319,15 @@ export function extractToolCallsFromResult(result) {
         if (!content.trim()) {
             continue;
         }
+        const resultLabeledToolCall = salvageResultLabeledToolCall(content);
+        if (resultLabeledToolCall) {
+            return [{
+                    id: "salvaged-result-label-1",
+                    name: resultLabeledToolCall.name,
+                    args: resultLabeledToolCall.args,
+                    rawArgsInput: content,
+                }];
+        }
         const salvaged = salvageJsonToolCalls(content);
         if (salvaged.length > 0) {
             return salvaged.map((toolCall, salvageIndex) => ({

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

@@ -247,6 +247,32 @@ function hasDelegatedPlanEvidence(result) {
     return Array.isArray(toolResults)
         && toolResults.some((item) => isPlanToolName(item.toolName));
 }
+function hasIncompleteDelegatedTodos(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => hasIncompleteDelegatedTodos(item));
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+    if (status === "pending" || status === "in_progress") {
+        return true;
+    }
+    return hasIncompleteDelegatedTodos(record.todos)
+        || hasIncompleteDelegatedTodos(record.update)
+        || hasIncompleteDelegatedTodos(record.stateSnapshot)
+        || hasIncompleteDelegatedTodos(record.metadata);
+}
+function hasIncompleteDelegatedPlanState(result) {
+    const toolResults = result?.metadata?.executedToolResults;
+    return Array.isArray(toolResults)
+        && toolResults.some((item) => isPlanToolName(item.toolName) && hasIncompleteDelegatedTodos(item.output));
+}
+function needsDelegatedPlanRecovery(binding, result) {
+    return binding?.harnessRuntime.executionContract?.requiresPlan === true
+        && (!hasDelegatedPlanEvidence(result) || hasIncompleteDelegatedPlanState(result));
+}
 function readUpstreamToolEvidence(event) {
     if (typeof event !== "object" || event === null) {
         return null;
@@ -839,6 +865,28 @@ export class AgentRuntimeAdapter {
         const inlineSubagents = input.resolvedSubagents.filter((subagent) => !("graphId" in subagent));
         const asyncSubagents = input.resolvedSubagents.filter((subagent) => "graphId" in subagent);
         const subagents = inlineSubagents;
+        const subagentDefaultMiddleware = [
+            ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
+            ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
+            createSummarizationMiddleware({
+                model: input.resolvedModel,
+                backend,
+            }),
+            createPatchToolCallsMiddleware(),
+        ];
+        const generalPurposeMiddleware = [
+            ...subagentDefaultMiddleware,
+            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
+                    backend,
+                    sources: resolveDeepAgentSkillSourceRootPaths({
+                        workspaceRoot: binding.harnessRuntime.workspaceRoot,
+                        runtimeRoot: binding.harnessRuntime.runtimeRoot,
+                        ownerId: binding.agent.id,
+                        skillPaths: input.resolvedSkills,
+                    }) ?? input.resolvedSkills,
+                })] : []),
+        ];
+        const hasGeneralPurposeOverride = subagents.some((subagent) => subagent.name === "general-purpose");
         const middleware = [
             ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
             ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
@@ -851,15 +899,15 @@ export class AgentRuntimeAdapter {
                     }) ?? input.resolvedSkills,
                 })] : []),
             ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
-            ...(subagents.length > 0
-                ? [createSubAgentMiddleware({
-                        defaultModel: input.resolvedModel,
-                        defaultTools: input.resolvedTools,
-                        defaultInterruptOn: input.resolvedInterruptOn,
-                        subagents: subagents,
-                        generalPurposeAgent: false,
-                    })]
-                : []),
+            createSubAgentMiddleware({
+                defaultModel: input.resolvedModel,
+                defaultTools: input.resolvedTools,
+                defaultMiddleware: subagentDefaultMiddleware,
+                generalPurposeMiddleware: generalPurposeMiddleware,
+                defaultInterruptOn: input.resolvedInterruptOn,
+                subagents: subagents,
+                generalPurposeAgent: !hasGeneralPurposeOverride,
+            }),
             createSummarizationMiddleware({
                 model: input.resolvedModel,
                 backend,
@@ -1195,8 +1243,7 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             try {
                 delegatedResult = await runDelegatedRequest([requestText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry");
             }
@@ -1214,8 +1261,7 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             return {
                 toolOutput: output,
@@ -1606,12 +1652,16 @@ export class AgentRuntimeAdapter {
                     agentId: selectedBinding?.agent.id ?? planned.subagentType,
                 };
                 let delegatedResult = yield* runPlannedDelegation(planned.subagentType, delegatedText);
-                if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
+                if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
                     const previousDelegatedResult = delegatedResult;
                     delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
                 }
-                if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
-                    const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
+                if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
+                    const previousDelegatedResult = delegatedResult;
+                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry"), previousDelegatedResult);
+                }
+                if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
+                    const output = buildDelegatedPlanEvidenceBlocker(selectedBinding?.agent.id ?? planned.subagentType);
                     delegatedResult = {
                         ...delegatedResult,
                         state: "failed",
@@ -1803,18 +1853,15 @@ export class AgentRuntimeAdapter {
             originalRequest: requestText,
         });
         let delegatedResult = yield* runDelegatedStreamAttempt(delegatedText);
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
             delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
             delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry"), previousDelegatedResult);
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             delegatedResult = {
                 ...delegatedResult,

package/dist/runtime/parsing/output-tool-args.d.ts

@@ -7,6 +7,10 @@ export declare function salvageLabeledToolCall(value: unknown): {
     name: string;
     args: Record<string, unknown>;
 } | null;
+export declare function salvageResultLabeledToolCall(value: unknown): {
+    name: string;
+    args: Record<string, unknown>;
+} | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
 export declare function salvageJsonToolCalls(value: unknown): Array<{
     name: string;

package/dist/runtime/parsing/output-tool-args.js

@@ -179,6 +179,22 @@ export function salvageLabeledToolCall(value) {
     }
     return null;
 }
+export function salvageResultLabeledToolCall(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const lines = value
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const label = lines[0]?.replace(/[*`#]/gu, "").trim() ?? "";
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+result\b/iu.exec(label);
+    if (!match || !isToolName(match[1])) {
+        return null;
+    }
+    const args = salvageToolArgs(lines.slice(1).join("\n")) ?? {};
+    return { name: match[1], args: normalizeKnownToolArgs(match[1], args) };
+}
 function extractBalancedJsonValue(value, openChar, closeChar) {
     const start = value.indexOf(openChar);
     if (start < 0)
@@ -514,12 +530,26 @@ function normalizeWriteTodosArgs(args) {
     if (Array.isArray(args.items) && !Array.isArray(args.todos)) {
         return normalizeWriteTodosArgs({ ...args, todos: args.items });
     }
+    if (Array.isArray(args.tasks) && !Array.isArray(args.todos)) {
+        return normalizeWriteTodosArgs({ ...args, todos: args.tasks });
+    }
+    if (Array.isArray(args.todo) && !Array.isArray(args.todos)) {
+        return normalizeWriteTodosArgs({ ...args, todos: args.todo });
+    }
     if (!Array.isArray(args.todos)) {
         return args;
     }
+    const { items: _items, tasks: _tasks, todo: _todo, ...rest } = args;
     return {
-        ...args,
+        ...rest,
         todos: args.todos.map((todo, index) => {
+            if (typeof todo === "string") {
+                const content = todo.trim();
+                return {
+                    content: content.length > 0 ? content : `Step ${index + 1}`,
+                    status: index === 0 ? "in_progress" : "pending",
+                };
+            }
             if (typeof todo !== "object" || !todo || Array.isArray(todo)) {
                 return todo;
             }
@@ -534,7 +564,13 @@ function normalizeWriteTodosArgs(args) {
                             ? record.name
                             : typeof record.text === "string" && record.text.trim().length > 0
                                 ? record.text
-                                : `Step ${index + 1}`;
+                                : typeof record.task === "string" && record.task.trim().length > 0
+                                    ? record.task
+                                    : typeof record.action === "string" && record.action.trim().length > 0
+                                        ? record.action
+                                        : typeof record.step === "string" && record.step.trim().length > 0
+                                            ? record.step
+                                            : `Step ${index + 1}`;
             const normalized = {};
             if (content !== undefined)
                 normalized.content = content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.462",
+  "version": "0.0.463",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",