@botbotgo/agent-harness 0.0.359 → 0.0.362

package/dist/workspace/framework-contract-validation.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { validateSkillMetadata } from "../runtime/skills/skill-metadata.js";
 import { getAgentExecutionConfigValue } from "./support/agent-execution-config.js";
-import { resolvePromptValue } from "./support/workspace-ref-utils.js";
+import { getRuntimeAgentDefaults, getWorkspaceObject, resolvePromptValue } from "./support/workspace-ref-utils.js";
 const FORBIDDEN_GENERAL_PURPOSE_SUBAGENT_NAME = "general-purpose";
 const FRAMEWORK_AGENT_TOOL_NAMES = new Set(["task"]);
 const FRAMEWORK_EXECUTION_TOOL_NAMES = new Set(["write_todos", "read_todos"]);
@@ -87,6 +87,78 @@ function readObject(value) {
         ? value
         : undefined;
 }
+function normalizeResponseFormatRef(ref) {
+    return ref.startsWith("response-format/") ? ref : `response-format/${ref}`;
+}
+function resolveResponseFormatRef(refs, ref) {
+    if (!refs || !ref) {
+        return undefined;
+    }
+    const object = getWorkspaceObject(refs, normalizeResponseFormatRef(ref));
+    if (!object || object.kind !== "response-format") {
+        return undefined;
+    }
+    return object.value.format;
+}
+function mergeResponseFormats(base, override) {
+    if (override === undefined) {
+        return base;
+    }
+    if (typeof base === "object" &&
+        base &&
+        typeof override === "object" &&
+        override &&
+        !Array.isArray(base) &&
+        !Array.isArray(override)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(override)) {
+            if (key === "required" && Array.isArray(merged.required) && Array.isArray(value)) {
+                merged.required = Array.from(new Set([...merged.required, ...value]));
+                continue;
+            }
+            if (key === "properties" &&
+                typeof merged.properties === "object" &&
+                merged.properties &&
+                !Array.isArray(merged.properties) &&
+                typeof value === "object" &&
+                value &&
+                !Array.isArray(value)) {
+                merged.properties = {
+                    ...merged.properties,
+                    ...value,
+                };
+                continue;
+            }
+            merged[key] = key in merged ? mergeResponseFormats(merged[key], value) : value;
+        }
+        return merged;
+    }
+    return override;
+}
+function resolveInheritedResponseFormat(agent, refs) {
+    if (!refs) {
+        return undefined;
+    }
+    const defaults = getRuntimeAgentDefaults(refs);
+    if (defaults && "responseFormat" in defaults) {
+        return defaults.responseFormat === null ? undefined : defaults.responseFormat;
+    }
+    const defaultRef = typeof defaults?.responseFormatRef === "string" ? defaults.responseFormatRef.trim() : "";
+    return defaultRef ? resolveResponseFormatRef(refs, defaultRef) : undefined;
+}
+function resolveEffectiveResponseFormat(agent, refs) {
+    const explicitResponseFormat = getAgentExecutionConfigValue(agent, "responseFormat");
+    if (explicitResponseFormat !== undefined) {
+        return explicitResponseFormat === null
+            ? undefined
+            : mergeResponseFormats(resolveInheritedResponseFormat(agent, refs), explicitResponseFormat);
+    }
+    const explicitRef = getAgentExecutionConfigValue(agent, "responseFormatRef");
+    if (typeof explicitRef === "string" && explicitRef.trim().length > 0) {
+        return resolveResponseFormatRef(refs, explicitRef.trim());
+    }
+    return resolveInheritedResponseFormat(agent, refs);
+}
 function validateResponseFormatTerminalStatus(agent, responseFormat, issues) {
     const schema = readObject(responseFormat);
     const properties = readObject(schema?.properties);
@@ -101,7 +173,7 @@ function validateResponseFormatTerminalStatus(agent, responseFormat, issues) {
         addIssue(issues, "agent.response_format.incomplete_terminal_status_enum", `Agent ${agent.id} responseFormat status enum must include completed, blocked, failed, and refused.`);
     }
 }
-function validateAgentContract(agent, referencedSubagentIds, tools, issues) {
+function validateAgentContract(agent, referencedSubagentIds, tools, refs, issues) {
     const description = agent.description.trim();
     const systemPrompt = resolvePromptValue(getAgentExecutionConfigValue(agent, "systemPrompt"), path.dirname(agent.sourcePath));
     const ownsDelegation = agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0 || (agent.asyncSubagents?.length ?? 0) > 0;
@@ -109,7 +181,7 @@ function validateAgentContract(agent, referencedSubagentIds, tools, issues) {
     const hasTools = agent.toolRefs.length > 0
         || (agent.toolBindings?.length ?? 0) > 0
         || (agent.inlineTools?.length ?? 0) > 0;
-    const responseFormat = getAgentExecutionConfigValue(agent, "responseFormat");
+    const responseFormat = resolveEffectiveResponseFormat(agent, refs);
     const builtinTools = readBuiltinToolsConfig(agent);
     const executionContract = readExecutionContractConfig(agent);
     const localSubagentNames = [
@@ -156,7 +228,7 @@ function validateAgentContract(agent, referencedSubagentIds, tools, issues) {
             addIssue(issues, "agent.subagent.missing_prompt", `Subagent ${agent.id} should define a systemPrompt that makes its operating boundary and output contract explicit.`);
         }
         if (agent.executionMode === "deepagent" && hasTools && responseFormat === undefined) {
-            addIssue(issues, "agent.subagent.deepagent.missing_response_format", `DeepAgents subagent ${agent.id} exposes tools, so it should define config.responseFormat to guarantee a stable task result for its parent agent.`);
+            addIssue(issues, "agent.subagent.deepagent.missing_response_format", `DeepAgents subagent ${agent.id} exposes tools, so it should inherit or define a responseFormat to guarantee a stable task result for its parent agent.`);
         }
         if (agent.executionMode === "deepagent" && hasTools && responseFormat !== undefined) {
             validateResponseFormatTerminalStatus(agent, responseFormat, issues);
@@ -200,7 +272,7 @@ export function validateFrameworkContracts(input) {
         if (!isWorkspaceOwnedPath(agent.sourcePath, input.ownedRoots)) {
             continue;
         }
-        validateAgentContract(agent, referencedSubagentIds, input.tools, issues);
+        validateAgentContract(agent, referencedSubagentIds, input.tools, input.refs, issues);
     }
     for (const [skillName, skillRoot] of input.skillRegistry) {
         if (!isWorkspaceOwnedPath(skillRoot, input.ownedRoots)) {

package/dist/workspace/object-loader.js

@@ -16,6 +16,7 @@ const CONSUMED_AGENT_CONFIG_KEYS = [
     "interruptOn",
     "stateSchema",
     "responseFormat",
+    "responseFormatRef",
     "contextSchema",
     "includeAgentName",
     "version",
@@ -56,6 +57,7 @@ const MIGRATED_AGENT_CONFIG_KEYS = [
     "interruptOn",
     "stateSchema",
     "responseFormat",
+    "responseFormatRef",
     "contextSchema",
     "includeAgentName",
     "version",
@@ -264,6 +266,13 @@ function readSharedAgentConfig(config) {
         ...(typeof config.interruptOn === "object" && config.interruptOn ? { interruptOn: config.interruptOn } : {}),
         ...(config.stateSchema !== undefined ? { stateSchema: config.stateSchema } : {}),
         ...(config.responseFormat !== undefined ? { responseFormat: config.responseFormat } : {}),
+        ...(typeof config.responseFormatRef === "string" && config.responseFormatRef.trim()
+            ? {
+                responseFormatRef: config.responseFormatRef.startsWith("response-format/")
+                    ? config.responseFormatRef
+                    : `response-format/${config.responseFormatRef.trim()}`,
+            }
+            : {}),
         ...(config.contextSchema !== undefined ? { contextSchema: config.contextSchema } : {}),
         ...(config.interactionMode === "stream" || config.interactionMode === "invoke" ? { interactionMode: config.interactionMode } : {}),
         ...(config.includeAgentName === "inline" ? { includeAgentName: "inline" } : {}),

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -37,6 +37,7 @@ export type ToolModuleDiscoveryConfig = {
 };
 export declare function getWorkspaceObject(refs: Map<string, WorkspaceObject | ParsedAgentObject>, ref: string | undefined): WorkspaceObject | undefined;
 export declare function getRuntimeDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
+export declare function getRuntimeAgentDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export type RuntimeStorageRoots = {
     applicationRoot: string;
     dataRoot: string;

package/dist/workspace/support/workspace-ref-utils.js

@@ -27,6 +27,46 @@ export function getRuntimeDefaults(refs) {
     }
     return runtimes[0].value;
 }
+function mergeConfigValue(base, override) {
+    if (override === undefined) {
+        return base;
+    }
+    if (typeof base === "object" &&
+        base &&
+        typeof override === "object" &&
+        override &&
+        !Array.isArray(base) &&
+        !Array.isArray(override)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(override)) {
+            merged[key] = key in merged ? mergeConfigValue(merged[key], value) : value;
+        }
+        return merged;
+    }
+    return override;
+}
+export function getRuntimeAgentDefaults(refs) {
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    const defaults = typeof runtimeDefaults?.defaults === "object" && runtimeDefaults.defaults && !Array.isArray(runtimeDefaults.defaults)
+        ? runtimeDefaults.defaults
+        : undefined;
+    const agentDefaults = typeof defaults?.agent === "object" && defaults.agent && !Array.isArray(defaults.agent)
+        ? defaults.agent
+        : undefined;
+    const agentConfig = typeof agentDefaults?.config === "object" && agentDefaults.config && !Array.isArray(agentDefaults.config)
+        ? agentDefaults.config
+        : undefined;
+    const inlineAgentDefaults = typeof runtimeDefaults?.agent === "object" && runtimeDefaults.agent && !Array.isArray(runtimeDefaults.agent)
+        ? runtimeDefaults.agent
+        : undefined;
+    const inlineAgentConfig = typeof inlineAgentDefaults?.config === "object" && inlineAgentDefaults.config && !Array.isArray(inlineAgentDefaults.config)
+        ? inlineAgentDefaults.config
+        : undefined;
+    const merged = mergeConfigValue(agentConfig, inlineAgentConfig);
+    return typeof merged === "object" && merged && !Array.isArray(merged)
+        ? merged
+        : undefined;
+}
 function asNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }

package/dist/workspace/yaml-object-reader.js

@@ -155,6 +155,8 @@ function normalizeKind(kind) {
             return "embedding-model";
         case "VectorStore":
             return "vector-store";
+        case "ResponseFormat":
+            return "response-format";
         case "Backend":
             return "backend";
         case "Store":
@@ -219,15 +221,17 @@ async function objectItemsFromDocument(document, sourcePath) {
             ? normalizeCatalogSpec(document, { defaultKind: "EmbeddingModel" })
             : catalogKind === "VectorStores"
                 ? normalizeCatalogSpec(document, { defaultKind: "VectorStore" })
-                : catalogKind === "Stores"
-                    ? normalizeCatalogSpec(document)
-                    : catalogKind === "Backends"
-                        ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
-                        : catalogKind === "Tools" || catalogKind === "ToolSets"
-                            ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
-                            : catalogKind === "McpServers"
-                                ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
-                                : [];
+                : catalogKind === "ResponseFormats"
+                    ? normalizeCatalogSpec(document, { defaultKind: "ResponseFormat" })
+                    : catalogKind === "Stores"
+                        ? normalizeCatalogSpec(document)
+                        : catalogKind === "Backends"
+                            ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
+                            : catalogKind === "Tools" || catalogKind === "ToolSets"
+                                ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
+                                : catalogKind === "McpServers"
+                                    ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
+                                    : [];
     if (catalogItems.length > 0) {
         return catalogItems;
     }

package/package.json

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