@botbotgo/agent-harness 0.0.95 → 0.0.97

package/dist/contracts/workspace.d.ts

@@ -0,0 +1,229 @@
+import type { ExecutionMode, RuntimeCapabilities, RuntimeModelRefMap, RuntimeModelSlot } from "./core.js";
+export type ParsedAgentObject = {
+    id: string;
+    executionMode: ExecutionMode;
+    runtimeModelRefs?: RuntimeModelRefMap;
+    capabilities?: RuntimeCapabilities;
+    description: string;
+    modelRef: string;
+    runRoot?: string;
+    toolRefs: string[];
+    mcpServers?: Array<Record<string, unknown>>;
+    skillPathRefs: string[];
+    memorySources: string[];
+    subagentRefs: string[];
+    subagentPathRefs: string[];
+    langchainAgentConfig?: Record<string, unknown>;
+    deepAgentConfig?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type WorkspaceObject = {
+    id: string;
+    kind: string;
+    sourcePath: string;
+    value: Record<string, unknown>;
+};
+export type ParsedModelObject = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    fallbacks: string[];
+    metadata?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type ParsedEmbeddingModelObject = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    metadata?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type ParsedVectorStoreObject = {
+    id: string;
+    kind: string;
+    url?: string;
+    authToken?: string;
+    table?: string;
+    column?: string;
+    embeddingModelRef?: string;
+    metadata?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type ParsedMcpServerObject = {
+    id: string;
+    transport: "stdio" | "http" | "sse" | "websocket";
+    url?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    token?: string;
+    headers?: Record<string, string>;
+    sourcePath: string;
+};
+export type ParsedToolObject = {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    implementationName?: string;
+    config?: Record<string, unknown>;
+    inputSchemaRef?: string;
+    backendOperation?: string;
+    mcpRef?: string;
+    bundleRefs: string[];
+    hitl?: {
+        enabled: boolean;
+        allow?: Array<"approve" | "edit" | "reject">;
+    };
+    retryable?: boolean;
+    sourcePath: string;
+};
+export type CompiledModel = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    fallbacks: string[];
+    runtimeValue: string;
+};
+export type CompiledEmbeddingModel = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    runtimeValue: string;
+};
+export type CompiledVectorStore = {
+    id: string;
+    kind: string;
+    url?: string;
+    authToken?: string;
+    table?: string;
+    column?: string;
+    embeddingModelRef?: string;
+    runtimeValue: string;
+};
+export type CompiledTool = {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    config?: Record<string, unknown>;
+    inputSchemaRef?: string;
+    backendOperation?: string;
+    mcpRef?: string;
+    bundleRefs: string[];
+    hitl?: {
+        enabled: boolean;
+        allow: Array<"approve" | "edit" | "reject">;
+    };
+    retryable?: boolean;
+    runtimeValue: {
+        name: string;
+        description: string;
+        type: string;
+    };
+};
+export type CompiledSubAgent = {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools?: CompiledTool[];
+    model?: CompiledModel;
+    interruptOn?: Record<string, boolean | object>;
+    skills?: string[];
+    memory?: string[];
+    responseFormat?: unknown;
+    contextSchema?: unknown;
+    middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
+};
+export type LangChainAgentParams = {
+    model: CompiledModel;
+    tools: CompiledTool[];
+    systemPrompt?: string;
+    stateSchema?: unknown;
+    responseFormat?: unknown;
+    contextSchema?: unknown;
+    filesystem?: Record<string, unknown>;
+    middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
+    subagents?: CompiledSubAgent[];
+    memory?: string[];
+    skills?: string[];
+    generalPurposeAgent?: boolean;
+    taskDescription?: string;
+    includeAgentName?: "inline";
+    version?: "v1" | "v2";
+    name?: string;
+    description: string;
+};
+export type DeepAgentParams = {
+    model: CompiledModel;
+    tools: CompiledTool[];
+    systemPrompt?: string;
+    responseFormat?: unknown;
+    contextSchema?: unknown;
+    middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
+    description: string;
+    subagents: CompiledSubAgent[];
+    interruptOn?: Record<string, boolean | object>;
+    backend?: Record<string, unknown>;
+    store?: Record<string, unknown>;
+    name: string;
+    memory: string[];
+    skills: string[];
+    generalPurposeAgent?: boolean;
+    taskDescription?: string;
+};
+export type RuntimeModelMap = Partial<Record<RuntimeModelSlot, CompiledModel>>;
+export type CompiledAgentBinding = {
+    agent: ParsedAgentObject;
+    adapter?: {
+        kind: string;
+        config: Record<string, unknown>;
+    };
+    langchainAgentParams?: LangChainAgentParams;
+    deepAgentParams?: DeepAgentParams;
+    harnessRuntime: {
+        runRoot: string;
+        workspaceRoot?: string;
+        modelRefs?: RuntimeModelRefMap;
+        models?: RuntimeModelMap;
+        capabilities?: RuntimeCapabilities;
+        resilience?: Record<string, unknown>;
+        checkpointer?: Record<string, unknown> | boolean;
+        store?: Record<string, unknown>;
+        runtimeMemory?: Record<string, unknown>;
+    };
+};
+export type WorkspaceBundle = {
+    workspaceRoot: string;
+    resourceSources: string[];
+    refs: Map<string, WorkspaceObject | ParsedAgentObject>;
+    models: Map<string, ParsedModelObject>;
+    embeddings: Map<string, ParsedEmbeddingModelObject>;
+    vectorStores: Map<string, ParsedVectorStoreObject>;
+    mcpServers: Map<string, ParsedMcpServerObject>;
+    tools: Map<string, ParsedToolObject>;
+    agents: Map<string, ParsedAgentObject>;
+    bindings: Map<string, CompiledAgentBinding>;
+};
+export type WorkspaceLoadOptions = {
+    /**
+     * Additional workspace roots to load before the runtime workspace root.
+     * Merge order is deterministic:
+     * framework defaults -> each overlayRoot (in order) -> workspaceRoot.
+     * Later values always override earlier values.
+     */
+    overlayRoots?: string[];
+    resourceSources?: string[];
+};

package/dist/contracts/workspace.js

@@ -0,0 +1 @@
+export {};

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.94";
+export declare const AGENT_HARNESS_VERSION = "0.0.96";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.94";
+export const AGENT_HARNESS_VERSION = "0.0.96";

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

@@ -0,0 +1,16 @@
+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;
+    runRoot?: string;
+    ownerId: string;
+    skillPaths?: string[];
+}): Promise<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

@@ -0,0 +1,45 @@
+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;
+    }
+    return skillPaths.map((skillPath) => {
+        if (!path.isAbsolute(skillPath)) {
+            return skillPath;
+        }
+        const relative = path.relative(workspaceRoot, skillPath);
+        if (!relative || relative.startsWith("..")) {
+            return skillPath;
+        }
+        return relative.split(path.sep).join("/");
+    });
+}
+export async function materializeDeepAgentSkillSourcePaths(options) {
+    const { workspaceRoot, skillPaths } = options;
+    if (!skillPaths) {
+        return skillPaths;
+    }
+    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/compat/openai-compatible.d.ts

@@ -0,0 +1,2 @@
+export declare function buildAuthOmittingFetch(baseFetch?: typeof fetch): typeof fetch;
+export declare function normalizeOpenAICompatibleInit(init: Record<string, unknown>): Record<string, unknown>;

package/dist/runtime/adapter/compat/openai-compatible.js

@@ -0,0 +1,43 @@
+function asObject(value) {
+    return typeof value === "object" && value ? value : undefined;
+}
+function isPlaceholderApiKey(value) {
+    return typeof value === "string" && value.trim().toLowerCase() === "dummy";
+}
+export function buildAuthOmittingFetch(baseFetch = fetch) {
+    return async (input, init) => {
+        const sanitizedHeaders = new Headers(input instanceof Request ? input.headers : undefined);
+        const initHeaders = new Headers(init?.headers);
+        initHeaders.forEach((value, key) => {
+            sanitizedHeaders.set(key, value);
+        });
+        sanitizedHeaders.delete("authorization");
+        if (input instanceof Request) {
+            return baseFetch(new Request(input, {
+                ...init,
+                headers: sanitizedHeaders,
+            }));
+        }
+        return baseFetch(input, {
+            ...init,
+            headers: sanitizedHeaders,
+        });
+    };
+}
+export function normalizeOpenAICompatibleInit(init) {
+    const normalized = { ...init };
+    const configuration = asObject(init.configuration) ?? {};
+    const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim() ? init.baseUrl.trim() : undefined;
+    const omitAuthHeader = init.omitAuthHeader === true || isPlaceholderApiKey(init.apiKey);
+    const nextConfiguration = { ...configuration };
+    if (baseUrl && typeof nextConfiguration.baseURL !== "string") {
+        nextConfiguration.baseURL = baseUrl;
+    }
+    if (omitAuthHeader) {
+        nextConfiguration.fetch = buildAuthOmittingFetch(typeof configuration.fetch === "function" ? configuration.fetch : fetch);
+    }
+    normalized.configuration = nextConfiguration;
+    delete normalized.baseUrl;
+    delete normalized.omitAuthHeader;
+    return normalized;
+}

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

@@ -0,0 +1,15 @@
+export * from "./tool/declared-middleware.js";
+export * from "./compat/deepagent-compat.js";
+export * from "./tool/interrupt-policy.js";
+export * from "./model/invocation-request.js";
+export * from "./langgraph/presets.js";
+export * from "./langgraph/profiles.js";
+export * from "./model/message-assembly.js";
+export * from "./model/model-providers.js";
+export * from "./compat/openai-compatible.js";
+export * from "./tool/provider-tool.js";
+export * from "./resilience.js";
+export * from "./tool/resolved-tool.js";
+export * from "./tool/tool-arguments.js";
+export * from "./tool/tool-hitl.js";
+export * from "./tool/tool-name-mapping.js";

package/dist/runtime/adapter/index.js

@@ -0,0 +1,15 @@
+export * from "./tool/declared-middleware.js";
+export * from "./compat/deepagent-compat.js";
+export * from "./tool/interrupt-policy.js";
+export * from "./model/invocation-request.js";
+export * from "./langgraph/presets.js";
+export * from "./langgraph/profiles.js";
+export * from "./model/message-assembly.js";
+export * from "./model/model-providers.js";
+export * from "./compat/openai-compatible.js";
+export * from "./tool/provider-tool.js";
+export * from "./resilience.js";
+export * from "./tool/resolved-tool.js";
+export * from "./tool/tool-arguments.js";
+export * from "./tool/tool-hitl.js";
+export * from "./tool/tool-name-mapping.js";

package/dist/runtime/adapter/langgraph/presets.js

@@ -0,0 +1,165 @@
+const DEFAULT_PLANNER_PROMPT = "You are the workflow planner. Produce a concise execution plan for the user request before execution starts.";
+const DEFAULT_REVIEWER_PROMPT = "Review the current result, call out missing verification or obvious gaps, and state whether the work looks sufficient.";
+const DEFAULT_REPLANNER_PROMPT = "Refine the plan based on the reviewer feedback and current result. Return only the updated plan.";
+const DEFAULT_FINALIZER_PROMPT = "Rewrite the current result into a concise user-facing final answer. Preserve facts and caveats.";
+export const SUPPORTED_LANGGRAPH_PRESETS = [
+    "react",
+    "prompt-chaining",
+    "routing",
+    "parallelization",
+    "plan-execute",
+    "review-loop",
+    "evaluator-optimizer",
+    "approval-gate",
+    "handoff",
+    "orchestrator-workers",
+];
+function requireAgent(preset, options) {
+    if (typeof options.agent === "string" && options.agent.trim()) {
+        return options.agent.trim();
+    }
+    throw new Error(`LangGraph preset ${preset} requires config.agent`);
+}
+export function resolveLangGraphPresetWorkflow(presetName, options = {}) {
+    switch (presetName) {
+        case undefined:
+        case "":
+            return undefined;
+        case "react":
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "agent" },
+                ],
+                edges: [],
+            };
+        case "prompt-chaining":
+        case "plan-execute":
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent" },
+                    { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                ],
+            };
+        case "routing": {
+            const agent = requireAgent("routing", options);
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent", agent },
+                    { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                ],
+            };
+        }
+        case "parallelization": {
+            const agent = requireAgent("parallelization", options);
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent", agent },
+                    { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                    { from: "step3", to: "step4", when: "review_ok" },
+                ],
+            };
+        }
+        case "review-loop":
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent" },
+                    { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step4", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "step5", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                    { from: "step3", to: "step5", when: "review_ok" },
+                    { from: "step3", to: "step4", when: "review_incomplete" },
+                    { from: "step4", to: "step2", when: "has_plan" },
+                ],
+            };
+        case "evaluator-optimizer":
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "agent" },
+                    { id: "step2", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step3", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2", when: "has_result" },
+                    { from: "step2", to: "step4", when: "review_ok" },
+                    { from: "step2", to: "step3", when: "review_incomplete" },
+                    { from: "step3", to: "step1", when: "has_plan" },
+                ],
+            };
+        case "approval-gate":
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "approval" },
+                    { id: "step3", kind: "agent" },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "approval_approved" },
+                    { from: "step2", to: "step3", when: "approval_edited" },
+                    { from: "step3", to: "step4", when: "has_result" },
+                ],
+            };
+        case "handoff": {
+            const agent = requireAgent("handoff", options);
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "agent", agent },
+                    { id: "step2", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2", when: "has_result" },
+                ],
+            };
+        }
+        case "orchestrator-workers": {
+            const agent = requireAgent("orchestrator-workers", options);
+            return {
+                entryNode: "step1",
+                nodes: [
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent", agent },
+                    { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                    { from: "step3", to: "step4", when: "review_ok" },
+                ],
+            };
+        }
+        default:
+            throw new Error(`Unsupported LangGraph preset ${String(presetName)}. Supported presets: ${SUPPORTED_LANGGRAPH_PRESETS.join(", ")}`);
+    }
+}

package/dist/runtime/{langgraph-profiles.d.ts → adapter/langgraph/profiles.d.ts}

@@ -1,4 +1,4 @@
-import type { LangGraphPresetWorkflow } from "./langgraph-presets.js";
+import type { LangGraphPresetWorkflow } from "./presets.js";
 export type LangGraphProfileName = "coding-runtime" | "personal-assistant" | "research-runtime" | "approval-review-runtime" | "claw-style-assistant" | "chat-operator" | "copilot-sidecar" | "task-delegation-hub";
 type LangGraphProfileOptions = Record<string, unknown>;
 export declare const SUPPORTED_LANGGRAPH_PROFILES: LangGraphProfileName[];