bernard-agent 0.8.1 → 0.9.0

package/dist/tools/wrap-with-specialist.d.ts

@@ -0,0 +1,55 @@
+import { type ToolWrapperDeps } from './tool-wrapper-run.js';
+/**
+ * Builds the natural-language input handed to a wrapper specialist when the
+ * shim forwards a direct tool call. The wrapper sees the original tool name
+ * and its arguments verbatim so it can validate, transform, or pass through.
+ */
+export declare function buildShimInput(toolName: string, args: unknown): string;
+/**
+ * Formats a wrapper's structured result so the main agent — and the
+ * tool-augmentation layer's `detectToolError` — observe the *native* tool
+ * return shape, just as if the shim had been bypassed.
+ *
+ * - On `status: 'ok'`, returns `wrapped.result` as-is (no JSON-stringifying
+ *   structured payloads), so e.g. `shell`'s `{ output, is_error }` and
+ *   `file_*`'s `{ ... }` propagate unchanged.
+ * - On `status: 'error'`, maps the wrapper error to the *same shape* the
+ *   native tool would have produced for an error:
+ *     - `shell` → `{ output: 'Error (...): ...', is_error: true }`
+ *     - `file_read_lines` / `file_edit_lines` / `file_write` → `{ error: '...' }`
+ *     - everything else (web_*, MCP, generic) → `'Error (...): ...'` string
+ *   This keeps `detectToolError` and tool-profile learning working whether or
+ *   not the shim is active.
+ */
+export declare function formatWrappedResult(wrapped: {
+    status: 'ok' | 'error';
+    result: unknown;
+    error?: string;
+}, toolName?: string): unknown;
+/**
+ * Wraps a base tool so that, when the corresponding wrapper specialist is
+ * registered, the model's call is transparently routed through
+ * {@link dispatchToolWrapper}. The model sees the same name, description, and
+ * schema — only the execution path changes.
+ *
+ * When the specialist is absent (or its kind is wrong, etc.), the shim falls
+ * through to the base tool's `execute` so behavior degrades gracefully.
+ *
+ * Only the wrapper's `result` (or `error` message) crosses back to the parent
+ * agent; the wrapper's `reasoning` array is logged separately and never enters
+ * the parent's context.
+ */
+export declare function wrapToolWithSpecialist<TArgs>(baseTool: any, toolName: string, specialistId: string, deps: ToolWrapperDeps): any;
+/**
+ * The default routing table mapping low-level tool names to their wrapper
+ * specialist IDs. Used by the main agent to auto-route raw calls.
+ */
+export declare const DEFAULT_SHIM_ROUTING: Record<string, string>;
+/**
+ * Applies {@link wrapToolWithSpecialist} to every tool name in the given
+ * routing table. Tools not present in the registry are skipped silently.
+ *
+ * Routing is only applied on the main agent — sub-agents, specialists, and
+ * the wrapper specialists themselves keep their raw tools to avoid recursion.
+ */
+export declare function applyShimRouting(tools: Record<string, any>, deps: ToolWrapperDeps, routing?: Record<string, string>): Record<string, any>;

package/dist/tools/wrap-with-specialist.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHIM_ROUTING = void 0;
+exports.buildShimInput = buildShimInput;
+exports.formatWrappedResult = formatWrappedResult;
+exports.wrapToolWithSpecialist = wrapToolWithSpecialist;
+exports.applyShimRouting = applyShimRouting;
+const tool_wrapper_run_js_1 = require("./tool-wrapper-run.js");
+const logger_js_1 = require("../logger.js");
+/**
+ * Builds the natural-language input handed to a wrapper specialist when the
+ * shim forwards a direct tool call. The wrapper sees the original tool name
+ * and its arguments verbatim so it can validate, transform, or pass through.
+ */
+function buildShimInput(toolName, args) {
+    let argsJson;
+    try {
+        argsJson = JSON.stringify(args, null, 2);
+    }
+    catch {
+        argsJson = String(args);
+    }
+    return `The main agent issued a direct call to the \`${toolName}\` tool with these arguments:
+
+\`\`\`json
+${argsJson}
+\`\`\`
+
+Execute this tool call (or a safer/equivalent variant if you spot a clear problem) and return the structured JSON output. Keep your \`result\` field tight — the parent agent only sees \`result\` and any \`error\`, never your \`reasoning\` array.`;
+}
+/**
+ * Formats a wrapper's structured result so the main agent — and the
+ * tool-augmentation layer's `detectToolError` — observe the *native* tool
+ * return shape, just as if the shim had been bypassed.
+ *
+ * - On `status: 'ok'`, returns `wrapped.result` as-is (no JSON-stringifying
+ *   structured payloads), so e.g. `shell`'s `{ output, is_error }` and
+ *   `file_*`'s `{ ... }` propagate unchanged.
+ * - On `status: 'error'`, maps the wrapper error to the *same shape* the
+ *   native tool would have produced for an error:
+ *     - `shell` → `{ output: 'Error (...): ...', is_error: true }`
+ *     - `file_read_lines` / `file_edit_lines` / `file_write` → `{ error: '...' }`
+ *     - everything else (web_*, MCP, generic) → `'Error (...): ...'` string
+ *   This keeps `detectToolError` and tool-profile learning working whether or
+ *   not the shim is active.
+ */
+function formatWrappedResult(wrapped, toolName) {
+    if (wrapped.status === 'ok') {
+        return wrapped.result;
+    }
+    const body = typeof wrapped.result === 'string' ? wrapped.result : JSON.stringify(wrapped.result);
+    const message = wrapped.error ? `Error (${wrapped.error}): ${body}` : `Error: ${body}`;
+    if (toolName === 'shell') {
+        return { output: message, is_error: true };
+    }
+    if (toolName === 'file_read_lines' ||
+        toolName === 'file_edit_lines' ||
+        toolName === 'file_write') {
+        return { error: message };
+    }
+    return message;
+}
+/**
+ * Wraps a base tool so that, when the corresponding wrapper specialist is
+ * registered, the model's call is transparently routed through
+ * {@link dispatchToolWrapper}. The model sees the same name, description, and
+ * schema — only the execution path changes.
+ *
+ * When the specialist is absent (or its kind is wrong, etc.), the shim falls
+ * through to the base tool's `execute` so behavior degrades gracefully.
+ *
+ * Only the wrapper's `result` (or `error` message) crosses back to the parent
+ * agent; the wrapper's `reasoning` array is logged separately and never enters
+ * the parent's context.
+ */
+function wrapToolWithSpecialist(baseTool, toolName, specialistId, deps) {
+    const baseExecute = baseTool.execute;
+    if (typeof baseExecute !== 'function') {
+        return baseTool;
+    }
+    return {
+        ...baseTool,
+        execute: async (args, execOptions) => {
+            const specialist = deps.specialistStore.get(specialistId);
+            if (!specialist) {
+                return baseExecute(args, execOptions);
+            }
+            const kind = specialist.kind ?? 'persona';
+            if (kind !== 'tool-wrapper') {
+                // Not the right kind for shim routing — let the raw tool handle it.
+                return baseExecute(args, execOptions);
+            }
+            try {
+                const wrapped = await (0, tool_wrapper_run_js_1.dispatchToolWrapper)({
+                    specialistId,
+                    input: buildShimInput(toolName, args),
+                    abortSignal: execOptions?.abortSignal,
+                    runLabel: `[shim] ${toolName} → ${specialist.name}`,
+                }, deps);
+                return formatWrappedResult(wrapped, toolName);
+            }
+            catch (err) {
+                // Defensive: if the dispatch itself throws, fall back to the raw tool
+                // rather than killing the turn.
+                (0, logger_js_1.debugLog)(`wrap-with-specialist:${toolName}:dispatch-error`, err instanceof Error ? err.message : String(err));
+                return baseExecute(args, execOptions);
+            }
+        },
+    };
+}
+/**
+ * The default routing table mapping low-level tool names to their wrapper
+ * specialist IDs. Used by the main agent to auto-route raw calls.
+ */
+exports.DEFAULT_SHIM_ROUTING = {
+    shell: 'shell-wrapper',
+    web_read: 'web-wrapper',
+    file_read_lines: 'file-wrapper',
+    file_edit_lines: 'file-wrapper',
+};
+/**
+ * Applies {@link wrapToolWithSpecialist} to every tool name in the given
+ * routing table. Tools not present in the registry are skipped silently.
+ *
+ * Routing is only applied on the main agent — sub-agents, specialists, and
+ * the wrapper specialists themselves keep their raw tools to avoid recursion.
+ */
+function applyShimRouting(tools, deps, routing = exports.DEFAULT_SHIM_ROUTING) {
+    const out = { ...tools };
+    for (const [toolName, specialistId] of Object.entries(routing)) {
+        if (!out[toolName])
+            continue;
+        out[toolName] = wrapToolWithSpecialist(out[toolName], toolName, specialistId, deps);
+    }
+    return out;
+}
+//# sourceMappingURL=wrap-with-specialist.js.map

package/dist/tools/wrap-with-specialist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-with-specialist.js","sourceRoot":"","sources":["../../src/tools/wrap-with-specialist.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "bernard-agent",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Local CLI AI agent with multi-provider support",
   "main": "dist/index.js",
   "bin": {
     "bernard": "dist/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node -e \"require('fs').cpSync('src/builtin-specialists','dist/builtin-specialists',{recursive:true})\"",
     "dev": "BERNARD_DEBUG=1 tsx src/index.ts",
     "start": "node dist/index.js",
     "test": "vitest run",