@botbotgo/agent-harness 0.0.95 → 0.0.97

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

@@ -0,0 +1,206 @@
+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_FINALIZER_PROMPT = "Rewrite the current result into a concise user-facing final answer. Preserve facts and caveats.";
+const DEFAULT_REPLANNER_PROMPT = "Refine the plan based on the reviewer feedback and current result. Return only the updated plan.";
+export const SUPPORTED_LANGGRAPH_PROFILES = [
+    "coding-runtime",
+    "personal-assistant",
+    "research-runtime",
+    "approval-review-runtime",
+    "claw-style-assistant",
+    "chat-operator",
+    "copilot-sidecar",
+    "task-delegation-hub",
+];
+function readStringOption(options, key) {
+    const value = options[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function requireAgentOption(profile, options, key) {
+    const value = readStringOption(options, key);
+    if (value) {
+        return value;
+    }
+    throw new Error(`LangGraph profile ${profile} requires with.${key}`);
+}
+function buildCodingRuntimeWorkflow(options) {
+    const coderAgent = requireAgentOption("coding-runtime", options, "coderAgent");
+    const verifierAgent = readStringOption(options, "verifierAgent");
+    const needsVerification = Boolean(verifierAgent) || options.runIntegrationVerification === true;
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: coderAgent },
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+            ...(needsVerification
+                ? [{ id: "step5", kind: "approval" }, { id: "step6", kind: "agent", agent: verifierAgent ?? coderAgent }]
+                : []),
+            { id: "step7", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+            { from: "step3", to: needsVerification ? "step5" : "step7", when: "review_ok" },
+            { from: "step3", to: "step4", when: "review_incomplete" },
+            { from: "step4", to: "step2", when: "has_plan" },
+            ...(needsVerification
+                ? [
+                    { from: "step5", to: "step6", when: "approval_approved" },
+                    { from: "step5", to: "step6", when: "approval_edited" },
+                    { from: "step6", to: "step7", when: "has_result" },
+                ]
+                : []),
+        ],
+    };
+}
+function buildAssistantWorkflow(options) {
+    const worker = readStringOption(options, "defaultWorkerAgent") ??
+        readStringOption(options, "defaultResearchAgent") ??
+        readStringOption(options, "defaultWritingAgent") ??
+        readStringOption(options, "defaultSchedulingAgent");
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            ...(worker ? [{ id: "step2", kind: "agent", agent: worker }] : [{ id: "step2", kind: "tool", tool: "repo_inventory" }]),
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", kind: "approval" },
+            { 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: "step4", when: "review_incomplete" },
+            { from: "step3", to: "step5", when: "review_ok" },
+            { from: "step4", to: "step5", when: "approval_approved" },
+            { from: "step4", to: "step5", when: "approval_edited" },
+        ],
+    };
+}
+function buildResearchWorkflow(options) {
+    const gathererAgent = requireAgentOption("research-runtime", options, "gathererAgent");
+    const analystAgent = requireAgentOption("research-runtime", options, "analystAgent");
+    const synthesizerAgent = readStringOption(options, "synthesizerAgent");
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: gathererAgent },
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", kind: "agent", agent: analystAgent },
+            ...(synthesizerAgent ? [{ id: "step5", kind: "agent", agent: synthesizerAgent }] : []),
+            { id: "step6", 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" },
+            { from: "step3", to: "step2", when: "review_incomplete" },
+            { from: "step4", to: synthesizerAgent ? "step5" : "step6", when: "has_result" },
+            ...(synthesizerAgent ? [{ from: "step5", to: "step6", when: "has_result" }] : []),
+        ],
+    };
+}
+function buildApprovalReviewWorkflow(options) {
+    const preparerAgent = requireAgentOption("approval-review-runtime", options, "preparerAgent");
+    const reviewerAgent = readStringOption(options, "reviewerAgent");
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: preparerAgent },
+            ...(reviewerAgent ? [{ id: "step3", kind: "agent", agent: reviewerAgent }] : [{ id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT }]),
+            { id: "step4", kind: "approval" },
+            { 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: "step4", when: "has_result" },
+            { from: "step4", to: "step5", when: "approval_approved" },
+            { from: "step4", to: "step5", when: "approval_edited" },
+        ],
+    };
+}
+function buildChatOperatorWorkflow(options) {
+    const routedAgent = readStringOption(options, "assistantAgent") ??
+        readStringOption(options, "researchAgent") ??
+        readStringOption(options, "codingAgent") ??
+        readStringOption(options, "approvalAgent");
+    if (!routedAgent) {
+        throw new Error("LangGraph profile chat-operator requires at least one target agent in with.assistantAgent, with.researchAgent, with.codingAgent, or with.approvalAgent");
+    }
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: routedAgent },
+            { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+        ],
+    };
+}
+function buildCopilotSidecarWorkflow(options) {
+    const coderAgent = requireAgentOption("copilot-sidecar", options, "coderAgent");
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: coderAgent },
+            { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+        ],
+    };
+}
+function buildDelegationHubWorkflow(options) {
+    const workerAgent = readStringOption(options, "defaultWorkerFallback");
+    if (!workerAgent) {
+        throw new Error("LangGraph profile task-delegation-hub requires with.defaultWorkerFallback");
+    }
+    return {
+        entryNode: "step1",
+        nodes: [
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: workerAgent },
+            { 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" },
+        ],
+    };
+}
+export function resolveLangGraphProfileWorkflow(profileName, options = {}) {
+    switch (profileName) {
+        case undefined:
+        case "":
+            return undefined;
+        case "coding-runtime":
+            return buildCodingRuntimeWorkflow(options);
+        case "personal-assistant":
+        case "claw-style-assistant":
+            return buildAssistantWorkflow(options);
+        case "research-runtime":
+            return buildResearchWorkflow(options);
+        case "approval-review-runtime":
+            return buildApprovalReviewWorkflow(options);
+        case "chat-operator":
+            return buildChatOperatorWorkflow(options);
+        case "copilot-sidecar":
+            return buildCopilotSidecarWorkflow(options);
+        case "task-delegation-hub":
+            return buildDelegationHubWorkflow(options);
+        default:
+            throw new Error(`Unsupported LangGraph profile ${String(profileName)}. Supported profiles: ${SUPPORTED_LANGGRAPH_PROFILES.join(", ")}`);
+    }
+}

package/dist/runtime/adapter/model/invocation-request.d.ts

@@ -0,0 +1,10 @@
+import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
+export declare function buildAgentMessages(history: TranscriptMessage[], input: MessageContent): Array<{
+    role: string;
+    content: MessageContent;
+}>;
+export declare function buildSlashCommandSkillInstruction(binding: CompiledAgentBinding, input: MessageContent): string | undefined;
+export declare function buildInvocationRequest(binding: CompiledAgentBinding, history: TranscriptMessage[], input: MessageContent, options?: {
+    state?: Record<string, unknown>;
+    files?: Record<string, unknown>;
+}): Record<string, unknown>;

package/dist/runtime/adapter/model/invocation-request.js

@@ -0,0 +1,46 @@
+import { extractMessageText, normalizeMessageContent } from "../../../utils/message-content.js";
+import { readSkillMetadata } from "../../support/skill-metadata.js";
+export function buildAgentMessages(history, input) {
+    return [
+        ...history.map((item) => ({ role: item.role, content: normalizeMessageContent(item.content) })),
+        { role: "user", content: normalizeMessageContent(input) },
+    ];
+}
+export function buildSlashCommandSkillInstruction(binding, input) {
+    const inputText = extractMessageText(input).trim();
+    const match = inputText.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/i);
+    if (!match) {
+        return undefined;
+    }
+    const invokedName = match[1].toLowerCase();
+    const argumentText = match[2]?.trim() ?? "";
+    const skillPaths = binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [];
+    const matchedSkillPath = skillPaths.find((skillPath) => readSkillMetadata(skillPath).name.toLowerCase() === invokedName);
+    if (!matchedSkillPath) {
+        return undefined;
+    }
+    const metadata = readSkillMetadata(matchedSkillPath);
+    const skillQualifier = metadata.userInvocable === true ? "user-invocable skill" : "skill";
+    const dryRunHint = /\s--dry-run(?:\s|$)/.test(` ${argumentText} `)
+        ? "This invocation includes `--dry-run`. Perform the real fetch or inspection steps needed for dry-run output. Do not return hypothetical or mock results."
+        : undefined;
+    return [
+        `This user message is an explicit command-style invocation of the ${skillQualifier} \`${metadata.name}\`.`,
+        `Read the skill file for \`${metadata.name}\` before taking action, then follow its documented phases and constraints exactly.`,
+        `You must use the \`${metadata.name}\` skill for this request and follow its documented workflow.`,
+        `Treat everything after \`/${metadata.name}\` as the skill argument string: ${argumentText ? JSON.stringify(argumentText) : '""'}.`,
+        "Do not answer with a generic explanation of what the skill would do. Execute the skill workflow using the available tools unless the skill instructions explicitly require confirmation before acting.",
+        dryRunHint,
+    ].filter((line) => typeof line === "string" && line.length > 0).join("\n");
+}
+export function buildInvocationRequest(binding, history, input, options = {}) {
+    const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
+    const messages = buildAgentMessages(history, input);
+    return {
+        ...(options.state ?? {}),
+        ...(options.files ? { files: options.files } : {}),
+        messages: userInvocableInstruction
+            ? [{ role: "system", content: userInvocableInstruction }, ...messages]
+            : messages,
+    };
+}

package/dist/runtime/adapter/model/message-assembly.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
+export declare function buildStateSnapshot(result: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function buildRawModelMessages(binding: CompiledAgentBinding, systemPrompt: string | undefined, history: TranscriptMessage[], input: MessageContent): Array<{
+    role: string;
+    content: MessageContent;
+}>;

package/dist/runtime/adapter/model/message-assembly.js

@@ -0,0 +1,21 @@
+import { buildAgentMessages, buildSlashCommandSkillInstruction } from "./invocation-request.js";
+export function buildStateSnapshot(result) {
+    const snapshot = { ...result };
+    delete snapshot.messages;
+    delete snapshot.__interrupt__;
+    delete snapshot.structuredResponse;
+    delete snapshot.files;
+    return Object.keys(snapshot).length > 0 ? snapshot : undefined;
+}
+export function buildRawModelMessages(binding, systemPrompt, history, input) {
+    const messages = [];
+    if (systemPrompt) {
+        messages.push({ role: "system", content: systemPrompt });
+    }
+    const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
+    if (userInvocableInstruction) {
+        messages.push({ role: "system", content: userInvocableInstruction });
+    }
+    messages.push(...buildAgentMessages(history, input));
+    return messages;
+}

package/dist/runtime/adapter/model/model-providers.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledModel, RuntimeAdapterOptions } from "../../../contracts/types.js";
+export declare function createResolvedModel(model: CompiledModel, modelResolver: RuntimeAdapterOptions["modelResolver"]): Promise<unknown>;

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

@@ -0,0 +1,27 @@
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatGoogle } from "@langchain/google";
+import { ChatOllama } from "@langchain/ollama";
+import { ChatOpenAI } from "@langchain/openai";
+import { initChatModel } from "langchain";
+import { normalizeOpenAICompatibleInit } from "../compat/openai-compatible.js";
+export async function createResolvedModel(model, modelResolver) {
+    if (modelResolver) {
+        return modelResolver(model.id);
+    }
+    if (model.provider === "ollama") {
+        return new ChatOllama({ model: model.model, ...model.init });
+    }
+    if (model.provider === "openai-compatible") {
+        return new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) });
+    }
+    if (model.provider === "openai") {
+        return new ChatOpenAI({ model: model.model, ...model.init });
+    }
+    if (model.provider === "anthropic") {
+        return new ChatAnthropic({ model: model.model, ...model.init });
+    }
+    if (model.provider === "google" || model.provider === "google-genai" || model.provider === "gemini") {
+        return new ChatGoogle({ model: model.model, ...model.init });
+    }
+    return initChatModel(model.model, { modelProvider: model.provider, ...model.init });
+}

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

@@ -0,0 +1,12 @@
+import type { CompiledAgentBinding } from "../../contracts/types.js";
+export declare function resolveTimeoutMs(value: unknown): number | undefined;
+export declare function computeRemainingTimeoutMs(deadlineAt: number | undefined, fallbackTimeoutMs: number | undefined): number | undefined;
+export declare function resolveBindingTimeout(binding: CompiledAgentBinding): number | undefined;
+export declare function resolveStreamIdleTimeout(binding: CompiledAgentBinding): number | undefined;
+export type ProviderRetryPolicy = {
+    maxAttempts: number;
+    backoffMs: number;
+    retryableMessages: string[];
+};
+export declare function resolveProviderRetryPolicy(binding: CompiledAgentBinding): ProviderRetryPolicy;
+export declare function isRetryableProviderError(binding: CompiledAgentBinding, error: unknown): boolean;

package/dist/runtime/adapter/resilience.js

@@ -0,0 +1,60 @@
+import { getBindingModelInit } from "../support/compiled-binding.js";
+export function resolveTimeoutMs(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+export function computeRemainingTimeoutMs(deadlineAt, fallbackTimeoutMs) {
+    if (!deadlineAt) {
+        return fallbackTimeoutMs;
+    }
+    const remaining = deadlineAt - Date.now();
+    if (remaining <= 0) {
+        return 0;
+    }
+    return fallbackTimeoutMs ? Math.min(fallbackTimeoutMs, remaining) : remaining;
+}
+export function resolveBindingTimeout(binding) {
+    return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
+}
+export function resolveStreamIdleTimeout(binding) {
+    const configuredIdleTimeout = resolveTimeoutMs(getBindingModelInit(binding)?.streamIdleTimeout);
+    if (configuredIdleTimeout) {
+        return configuredIdleTimeout;
+    }
+    const invokeTimeout = resolveBindingTimeout(binding);
+    if (invokeTimeout) {
+        return Math.min(invokeTimeout, 15_000);
+    }
+    return 15_000;
+}
+export function resolveProviderRetryPolicy(binding) {
+    const resilience = typeof binding.harnessRuntime.resilience === "object" && binding.harnessRuntime.resilience
+        ? binding.harnessRuntime.resilience
+        : {};
+    const providerRetries = typeof resilience.providerRetries === "object" && resilience.providerRetries
+        ? resilience.providerRetries
+        : {};
+    const maxAttempts = typeof providerRetries.maxAttempts === "number" &&
+        Number.isFinite(providerRetries.maxAttempts) &&
+        providerRetries.maxAttempts > 0
+        ? Math.floor(providerRetries.maxAttempts)
+        : 2;
+    const backoffMs = typeof providerRetries.backoffMs === "number" &&
+        Number.isFinite(providerRetries.backoffMs) &&
+        providerRetries.backoffMs >= 0
+        ? Math.floor(providerRetries.backoffMs)
+        : 1_000;
+    const retryableMessages = Array.isArray(providerRetries.retryableMessages)
+        ? providerRetries.retryableMessages.filter((value) => typeof value === "string" && value.trim().length > 0)
+        : [];
+    return {
+        maxAttempts,
+        backoffMs,
+        retryableMessages,
+    };
+}
+export function isRetryableProviderError(binding, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    const { retryableMessages } = resolveProviderRetryPolicy(binding);
+    return retryableMessages.some((candidate) => normalized.includes(candidate.toLowerCase()));
+}

package/dist/runtime/{declared-middleware.d.ts → adapter/tool/declared-middleware.d.ts}

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledModel } from "../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel } from "../../../contracts/types.js";
 type MiddlewareConfig = Record<string, unknown>;
 type MiddlewareFactoryContext = {
     config: MiddlewareConfig;

package/dist/runtime/adapter/tool/interrupt-policy.d.ts

@@ -0,0 +1,8 @@
+import type { CompiledTool } from "../../../contracts/types.js";
+export type InterruptDecision = "approve" | "edit" | "reject";
+export declare function normalizeInterruptPolicy(rule: boolean | object | undefined): InterruptDecision[] | null;
+export declare function compileInterruptOn(tools: Array<Pick<CompiledTool, "name">> | Array<{
+    name: string;
+}>, compatibilityRules?: Record<string, boolean | object>): Record<string, {
+    allowedDecisions: InterruptDecision[];
+}> | undefined;

package/dist/runtime/adapter/tool/interrupt-policy.js

@@ -0,0 +1,34 @@
+import { buildToolNameMapping } from "./tool-name-mapping.js";
+export function normalizeInterruptPolicy(rule) {
+    if (!rule)
+        return null;
+    if (rule === true)
+        return ["approve", "edit", "reject"];
+    const typed = rule;
+    if (Array.isArray(typed.allowedDecisions)) {
+        return typed.allowedDecisions.filter((item) => item === "approve" || item === "edit" || item === "reject");
+    }
+    const decisions = [];
+    if (typed.allowAccept !== false)
+        decisions.push("approve");
+    if (typed.allowEdit !== false)
+        decisions.push("edit");
+    if (typed.allowReject !== false)
+        decisions.push("reject");
+    return decisions.length > 0 ? decisions : null;
+}
+export function compileInterruptOn(tools, compatibilityRules) {
+    const toolNameMapping = buildToolNameMapping(tools);
+    const compiled = new Map();
+    for (const [toolName, rule] of Object.entries(compatibilityRules ?? {})) {
+        const modelFacingName = toolNameMapping.originalToModelFacing.get(toolName) ?? toolName;
+        const allowedDecisions = normalizeInterruptPolicy(rule);
+        if (!allowedDecisions) {
+            compiled.delete(modelFacingName);
+        }
+        else {
+            compiled.set(modelFacingName, { allowedDecisions });
+        }
+    }
+    return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
+}

package/dist/runtime/adapter/tool/provider-tool.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledTool } from "../../../contracts/types.js";
+export declare function instantiateProviderTool(compiledTool: CompiledTool): unknown;

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

@@ -0,0 +1,25 @@
+import { tools as anthropicProviderTools } from "@langchain/anthropic";
+import { tools as openAIProviderTools } from "@langchain/openai";
+import { asRecord } from "./resolved-tool.js";
+export function instantiateProviderTool(compiledTool) {
+    const providerTool = asRecord(compiledTool.config?.providerTool);
+    const provider = typeof providerTool?.provider === "string" ? providerTool.provider.trim().toLowerCase() : "";
+    const toolName = typeof providerTool?.tool === "string" ? providerTool.tool.trim() : "";
+    const args = asRecord(providerTool?.args) ?? {};
+    if (!provider || !toolName) {
+        throw new Error(`Provider tool ${compiledTool.id} must define providerTool.provider and providerTool.tool`);
+    }
+    const registry = provider === "openai"
+        ? openAIProviderTools
+        : provider === "anthropic"
+            ? anthropicProviderTools
+            : undefined;
+    if (!registry) {
+        throw new Error(`Provider tool ${compiledTool.id} uses unsupported provider ${provider}`);
+    }
+    const factory = registry[toolName];
+    if (typeof factory !== "function") {
+        throw new Error(`Provider tool ${compiledTool.id} references unknown ${provider} tool ${toolName}`);
+    }
+    return factory(args);
+}

package/dist/runtime/adapter/tool/resolved-tool.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export type ResolvedToolLike = {
+    name?: string;
+    description?: string;
+    schema?: {
+        parse?: (input: unknown) => unknown;
+    };
+    invoke?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+    call?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+    func?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+};
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function wrapResolvedToolWithModelFacingName<T>(resolvedTool: T, modelFacingName: string): T;
+export declare function hasCallableToolHandler(value: unknown): value is ResolvedToolLike;
+export declare function normalizeResolvedToolSchema(resolvedTool: ResolvedToolLike): Record<string, unknown> | {
+    parse?: (input: unknown) => unknown;
+} | z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+export declare function asStructuredExecutableTool(resolvedTool: unknown, modelFacingName: string, description: string): unknown;

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

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { tool as createLangChainTool } from "@langchain/core/tools";
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
+export function wrapResolvedToolWithModelFacingName(resolvedTool, modelFacingName) {
+    if (typeof resolvedTool !== "object" || resolvedTool === null) {
+        return resolvedTool;
+    }
+    return new Proxy(resolvedTool, {
+        get(target, prop, receiver) {
+            if (prop === "name") {
+                return modelFacingName;
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (prop === "name") {
+                return {
+                    configurable: true,
+                    enumerable: true,
+                    writable: false,
+                    value: modelFacingName,
+                };
+            }
+            return Reflect.getOwnPropertyDescriptor(target, prop);
+        },
+    });
+}
+export function hasCallableToolHandler(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typed = value;
+    return typeof typed.invoke === "function" || typeof typed.call === "function" || typeof typed.func === "function";
+}
+export function normalizeResolvedToolSchema(resolvedTool) {
+    const schema = resolvedTool.schema;
+    if (schema && typeof schema.parse === "function" && "_def" in schema) {
+        return resolvedTool.schema;
+    }
+    if (schema && (schema.type === "object" || typeof schema.properties === "object")) {
+        return schema;
+    }
+    return z.object({}).passthrough();
+}
+export function asStructuredExecutableTool(resolvedTool, modelFacingName, description) {
+    if (!hasCallableToolHandler(resolvedTool)) {
+        return resolvedTool;
+    }
+    const handler = resolvedTool.invoke ?? resolvedTool.call ?? resolvedTool.func;
+    if (typeof handler !== "function") {
+        return resolvedTool;
+    }
+    return createLangChainTool(async (input, config) => handler(input, config), {
+        name: modelFacingName,
+        description,
+        schema: normalizeResolvedToolSchema(resolvedTool),
+    });
+}

package/dist/runtime/adapter/tool/tool-arguments.d.ts

@@ -0,0 +1,7 @@
+export declare function stringifyToolOutput(output: unknown): string;
+export declare function normalizeToolArgsForSchema(args: Record<string, unknown>, schema: unknown): Record<string, unknown>;
+export declare function extractToolCallsFromResult(result: unknown): Array<{
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+}>;