@a5c-ai/agent-core 0.1.0 → 5.0.1-staging.00fa5317c493

package/README.md

@@ -118,6 +118,7 @@ If you still need the PI-era controls above, use the PI wrapper exposed from `@a
 - delegation tools: `AskUserQuestion`, `task`, `skill`
 - code tools: `calc`, `ast_grep`, `ast_edit`, `render_mermaid`, `notebook`
 - background/discovery/web tools: `background_status`, `background_list`, `tool_search`, `tool_fetch`, `web_search`, `fetch_process`
+- optional programmatic tool calling: `code_executor` when `programmaticToolCalling` is enabled
 
 `AgentCoreToolOptions` controls how those definitions are wired into a host runtime:
 
@@ -127,6 +128,18 @@ If you still need the PI-era controls above, use the PI wrapper exposed from `@a
 - `onToolUse`: observer callback fired after tool wrapping.
 - `onBackgroundComplete`, `maxBackgroundProcesses`, `backgroundRegistry`: background-process lifecycle hooks and limits.
 - `deferredToolRegistry`: enables `tool_search` and `tool_fetch`.
+- `programmaticToolCalling`: opt-in Code Mode / Programmatic Tool Calling surface. When enabled, `code_executor` runs a bounded JavaScript async body with `tools.<name>(params)` and `callTool(name, params)` helpers for batching existing agent-core tools behind one model-level tool call.
+
+Example:
+
+```ts
+const tools = createAgentCoreToolDefinitions({
+  workspace: process.cwd(),
+  interactive: false,
+  deferredToolRegistry,
+  programmaticToolCalling: { maxToolCalls: 10, timeout: 60_000 },
+});
+```
 
 ### Interactive and cancellation contract
 

package/dist/agenticTools/background/state.d.ts

@@ -0,0 +1,5 @@
+import { BackgroundProcessRegistry } from "../../backgroundProcessRegistry";
+import type { AgenticToolOptions } from "../types";
+export declare function getBackgroundRegistry(options: AgenticToolOptions): BackgroundProcessRegistry;
+export declare function disposeBackgroundRegistry(options: AgenticToolOptions): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/agenticTools/background/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/background/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,GAAG,yBAAyB,CAW5F;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAO3E"}

package/dist/agenticTools/background/state.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackgroundRegistry = getBackgroundRegistry;
+exports.disposeBackgroundRegistry = disposeBackgroundRegistry;
+const backgroundProcessRegistry_1 = require("../../backgroundProcessRegistry");
+const scopedRegistries = new WeakMap();
+function getBackgroundRegistry(options) {
+    if (options.backgroundRegistry) {
+        return options.backgroundRegistry;
+    }
+    let registry = scopedRegistries.get(options);
+    if (!registry) {
+        registry = new backgroundProcessRegistry_1.BackgroundProcessRegistry({ maxConcurrent: options.maxBackgroundProcesses });
+        scopedRegistries.set(options, registry);
+    }
+    return registry;
+}
+function disposeBackgroundRegistry(options) {
+    const registry = scopedRegistries.get(options);
+    if (!registry) {
+        return;
+    }
+    registry.dispose();
+    scopedRegistries.delete(options);
+}

package/dist/agenticTools/background/tools.d.ts

@@ -0,0 +1,3 @@
+import type { AgenticToolOptions, CustomToolDefinition } from "../types";
+export declare function createBackgroundTools(options: AgenticToolOptions): CustomToolDefinition[];
+//# sourceMappingURL=tools.d.ts.map

package/dist/agenticTools/background/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/background/tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAIzE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB,EAAE,CA+BzF"}

package/dist/agenticTools/background/tools.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBackgroundTools = createBackgroundTools;
+const typebox_1 = require("@sinclair/typebox");
+const results_1 = require("../shared/results");
+const state_1 = require("./state");
+function createBackgroundTools(options) {
+    return [
+        {
+            name: "background_status",
+            label: "Background Task Status",
+            description: "Query the status of a background task by its backgroundTaskId. Returns the task record including status, stdout, stderr, and exit code.",
+            parameters: typebox_1.Type.Object({
+                backgroundTaskId: typebox_1.Type.String({
+                    description: "The backgroundTaskId returned when launching a background task",
+                }),
+            }),
+            execute: (_toolCallId, params) => {
+                const backgroundTaskId = String(params.backgroundTaskId);
+                const record = (0, state_1.getBackgroundRegistry)(options).get(backgroundTaskId);
+                if (!record) {
+                    return (0, results_1.errorResult)(`Background task not found: ${backgroundTaskId}`);
+                }
+                return (0, results_1.jsonResult)(record);
+            },
+        },
+        {
+            name: "background_list",
+            label: "List Background Tasks",
+            description: "List all tracked background tasks with their current status.",
+            parameters: typebox_1.Type.Object({}),
+            execute: () => (0, results_1.jsonResult)({
+                tasks: (0, state_1.getBackgroundRegistry)(options).list(),
+            }),
+        },
+    ];
+}

package/dist/agenticTools/browser/tool.d.ts

@@ -0,0 +1,3 @@
+import type { CustomToolDefinition } from "../types";
+export declare function createBrowserTool(): CustomToolDefinition;
+//# sourceMappingURL=tool.d.ts.map

package/dist/agenticTools/browser/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/browser/tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAoBrD,wBAAgB,iBAAiB,IAAI,oBAAoB,CA+DxD"}

package/dist/agenticTools/browser/tool.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserTool = createBrowserTool;
+const typebox_1 = require("@sinclair/typebox");
+const results_1 = require("../shared/results");
+let browserInstance = null;
+function createBrowserTool() {
+    return {
+        name: "browser",
+        label: "Headless Browser",
+        description: "Interact with a headless browser. Actions: navigate, click, type, evaluate, screenshot, close.",
+        parameters: typebox_1.Type.Object({
+            action: typebox_1.Type.String({
+                description: "Action: navigate | click | type | evaluate | screenshot | close",
+            }),
+            url: typebox_1.Type.Optional(typebox_1.Type.String({ description: "URL to navigate to" })),
+            selector: typebox_1.Type.Optional(typebox_1.Type.String({ description: "CSS selector for click/type" })),
+            text: typebox_1.Type.Optional(typebox_1.Type.String({ description: "Text to type" })),
+            script: typebox_1.Type.Optional(typebox_1.Type.String({ description: "JavaScript to evaluate in page" })),
+            options: typebox_1.Type.Optional(typebox_1.Type.Object({}, { additionalProperties: true })),
+        }),
+        execute: async (_toolCallId, params) => {
+            let puppeteer;
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-assignment
+                puppeteer = await new Function("id", "return import(id)")("puppeteer");
+            }
+            catch {
+                return (0, results_1.errorResult)("puppeteer is not installed. Install it with: npm install puppeteer");
+            }
+            if (!browserInstance) {
+                browserInstance = await puppeteer.launch({
+                    headless: true,
+                    args: ["--no-sandbox", "--disable-setuid-sandbox"],
+                });
+            }
+            const browser = browserInstance;
+            const page = (await browser.pages())[0] ?? await browser.newPage();
+            switch (String(params.action)) {
+                case "navigate":
+                    await page.goto(String(params.url), { waitUntil: "domcontentloaded" });
+                    return (0, results_1.ok)(`Navigated to ${String(params.url)} — title: ${await page.title()}`);
+                case "click":
+                    await page.click(String(params.selector));
+                    return (0, results_1.ok)(`Clicked ${String(params.selector)}`);
+                case "type":
+                    await page.type(String(params.selector), String(params.text));
+                    return (0, results_1.ok)(`Typed into ${String(params.selector)}`);
+                case "evaluate":
+                    return (0, results_1.jsonResult)(await page.evaluate(String(params.script)));
+                case "screenshot": {
+                    const buffer = await page.screenshot({ encoding: "base64" });
+                    return (0, results_1.ok)(`Screenshot captured (${buffer.length} base64 chars).`);
+                }
+                case "close":
+                    await browser.close();
+                    browserInstance = null;
+                    return (0, results_1.ok)("Browser closed.");
+                default:
+                    return (0, results_1.errorResult)(`Unknown browser action: ${String(params.action)}`);
+            }
+        },
+    };
+}

package/dist/agenticTools/config/state.d.ts

@@ -0,0 +1,10 @@
+export declare function resetRunScopedConfig(): void;
+export declare function isValidConfigKey(key: string): boolean;
+export declare function validateConfigValue(key: string, value: unknown): string | null;
+export declare function getConfigValue(key: string): unknown;
+export declare function getConfigDefault(key: string): unknown;
+export declare function listConfigKeys(): string[];
+export declare function getRunScopedConfigEntries(): IterableIterator<[string, unknown]>;
+export declare function setConfigValue(key: string, value: unknown, scope: string): void;
+export declare function resetConfigValue(key?: string): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/agenticTools/config/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/config/state.ts"],"names":[],"mappings":"AAwDA,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAKrD;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAY9E;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CASnD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAKrD;AAED,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAMzC;AAED,wBAAgB,yBAAyB,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAE/E;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAU/E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAMnD"}

package/dist/agenticTools/config/state.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetRunScopedConfig = resetRunScopedConfig;
+exports.isValidConfigKey = isValidConfigKey;
+exports.validateConfigValue = validateConfigValue;
+exports.getConfigValue = getConfigValue;
+exports.getConfigDefault = getConfigDefault;
+exports.listConfigKeys = listConfigKeys;
+exports.getRunScopedConfigEntries = getRunScopedConfigEntries;
+exports.setConfigValue = setConfigValue;
+exports.resetConfigValue = resetConfigValue;
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const EXTENDED_CONFIG_KEYS = new Set([
+    "model",
+    "provider",
+    "breakpoint.autoApproveAfterN",
+    "breakpoint.presentAlwaysApprove",
+]);
+const BABYSITTER_CONFIG_KEYS = new Set([
+    "runsDir",
+    "maxIterations",
+    "qualityThreshold",
+    "timeout",
+    "logLevel",
+    "allowSecretLogs",
+    "hookTimeout",
+    "nodeTaskTimeout",
+    "clockStepMs",
+    "clockStartMs",
+    "layoutVersion",
+    "largeResultPreviewLimit",
+]);
+const CONFIG_KEY_TYPES = {
+    runsDir: "string",
+    maxIterations: "number",
+    qualityThreshold: "number",
+    timeout: "number",
+    logLevel: "string",
+    allowSecretLogs: "boolean",
+    hookTimeout: "number",
+    nodeTaskTimeout: "number",
+    clockStepMs: "number",
+    clockStartMs: "number",
+    layoutVersion: "string",
+    largeResultPreviewLimit: "number",
+    model: "string",
+    provider: "string",
+};
+const VALID_LOG_LEVELS = new Set(["debug", "info", "warn", "error", "silent"]);
+const CONFIG_KEY_TO_ENV = {
+    runsDir: babysitter_sdk_1.CONFIG_ENV_VARS.RUNS_DIR,
+    maxIterations: babysitter_sdk_1.CONFIG_ENV_VARS.MAX_ITERATIONS,
+    qualityThreshold: babysitter_sdk_1.CONFIG_ENV_VARS.QUALITY_THRESHOLD,
+    timeout: babysitter_sdk_1.CONFIG_ENV_VARS.TIMEOUT,
+    logLevel: babysitter_sdk_1.CONFIG_ENV_VARS.LOG_LEVEL,
+    allowSecretLogs: babysitter_sdk_1.CONFIG_ENV_VARS.ALLOW_SECRET_LOGS,
+    hookTimeout: babysitter_sdk_1.CONFIG_ENV_VARS.HOOK_TIMEOUT,
+    nodeTaskTimeout: babysitter_sdk_1.CONFIG_ENV_VARS.NODE_TASK_TIMEOUT,
+};
+const runScopedConfig = new Map();
+function resetRunScopedConfig() {
+    runScopedConfig.clear();
+}
+function isValidConfigKey(key) {
+    return BABYSITTER_CONFIG_KEYS.has(key)
+        || EXTENDED_CONFIG_KEYS.has(key)
+        || key.startsWith("compression.")
+        || key.startsWith("breakpoint.");
+}
+function validateConfigValue(key, value) {
+    const expectedType = CONFIG_KEY_TYPES[key];
+    if (expectedType && typeof value !== expectedType) {
+        return `Expected '${key}' to be ${expectedType}, got ${typeof value}.`;
+    }
+    if (key === "logLevel" && typeof value === "string" && !VALID_LOG_LEVELS.has(value)) {
+        return `Invalid logLevel '${value}'. Must be one of: ${[...VALID_LOG_LEVELS].join(", ")}.`;
+    }
+    if (expectedType === "number" && typeof value === "number" && key !== "clockStartMs" && value <= 0) {
+        return `'${key}' must be a positive number.`;
+    }
+    return null;
+}
+function getConfigValue(key) {
+    if (runScopedConfig.has(key)) {
+        return runScopedConfig.get(key);
+    }
+    if (BABYSITTER_CONFIG_KEYS.has(key)) {
+        const config = (0, babysitter_sdk_1.getConfig)();
+        return config[key];
+    }
+    return undefined;
+}
+function getConfigDefault(key) {
+    if (BABYSITTER_CONFIG_KEYS.has(key)) {
+        return babysitter_sdk_1.DEFAULTS[key];
+    }
+    return undefined;
+}
+function listConfigKeys() {
+    return [...new Set([
+            ...BABYSITTER_CONFIG_KEYS,
+            ...EXTENDED_CONFIG_KEYS,
+            ...runScopedConfig.keys(),
+        ])];
+}
+function getRunScopedConfigEntries() {
+    return runScopedConfig.entries();
+}
+function setConfigValue(key, value, scope) {
+    if (scope === "global") {
+        const envKey = CONFIG_KEY_TO_ENV[key];
+        if (envKey) {
+            process.env[envKey] = String(value);
+        }
+        else {
+            process.env[`BABYSITTER_${key.replace(/\./g, "_").toUpperCase()}`] = String(value);
+        }
+    }
+    runScopedConfig.set(key, value);
+}
+function resetConfigValue(key) {
+    if (key) {
+        runScopedConfig.delete(key);
+        return;
+    }
+    runScopedConfig.clear();
+}

package/dist/agenticTools/config/tool.d.ts

@@ -0,0 +1,3 @@
+import type { CustomToolDefinition } from "../types";
+export declare function createConfigTool(): CustomToolDefinition;
+//# sourceMappingURL=tool.d.ts.map

package/dist/agenticTools/config/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/config/tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAarD,wBAAgB,gBAAgB,IAAI,oBAAoB,CAuFvD"}

package/dist/agenticTools/config/tool.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigTool = createConfigTool;
+const typebox_1 = require("@sinclair/typebox");
+const results_1 = require("../shared/results");
+const state_1 = require("./state");
+function createConfigTool() {
+    return {
+        name: "config",
+        label: "Runtime Config",
+        description: "Read and modify babysitter configuration at runtime. Supports get/set/list/reset actions for standard config keys, model/provider selection, and compression settings.",
+        parameters: typebox_1.Type.Object({
+            action: typebox_1.Type.Union([
+                typebox_1.Type.Literal("get"),
+                typebox_1.Type.Literal("set"),
+                typebox_1.Type.Literal("list"),
+                typebox_1.Type.Literal("reset"),
+            ], { description: "Action to perform: get, set, list, or reset" }),
+            key: typebox_1.Type.Optional(typebox_1.Type.String({ description: "Config key path (dot notation for nested, e.g. 'compression.enabled')" })),
+            value: typebox_1.Type.Optional(typebox_1.Type.Unknown({ description: "New value for set action" })),
+            scope: typebox_1.Type.Optional(typebox_1.Type.Union([typebox_1.Type.Literal("run"), typebox_1.Type.Literal("global")], {
+                description: "Scope: 'run' (default, in-memory) or 'global' (env vars)",
+            })),
+        }),
+        execute: (_toolCallId, params) => {
+            const action = params.action;
+            if (!action) {
+                return (0, results_1.errorResult)("'action' parameter is required (get, set, list, reset).");
+            }
+            const key = params.key;
+            const value = params.value;
+            const scope = params.scope ?? "run";
+            switch (action) {
+                case "get":
+                    if (!key) {
+                        const merged = {};
+                        for (const configKey of (0, state_1.listConfigKeys)()) {
+                            merged[configKey] = (0, state_1.getConfigValue)(configKey);
+                        }
+                        return (0, results_1.jsonResult)(merged);
+                    }
+                    if (!(0, state_1.isValidConfigKey)(key)) {
+                        return (0, results_1.errorResult)(`Error: Unknown config key '${key}'.`);
+                    }
+                    return (0, results_1.jsonResult)({ key, value: (0, state_1.getConfigValue)(key) });
+                case "set":
+                    if (!key) {
+                        return (0, results_1.errorResult)("Error: 'key' parameter is required for set action.");
+                    }
+                    if (value === undefined) {
+                        return (0, results_1.errorResult)("Error: 'value' parameter is required for set action.");
+                    }
+                    if (!(0, state_1.isValidConfigKey)(key)) {
+                        return (0, results_1.errorResult)(`Error: Unknown config key '${key}'.`);
+                    }
+                    {
+                        const validationError = (0, state_1.validateConfigValue)(key, value);
+                        if (validationError) {
+                            return (0, results_1.errorResult)(`Error: ${validationError}`);
+                        }
+                    }
+                    (0, state_1.setConfigValue)(key, value, scope);
+                    return (0, results_1.ok)(`Set '${key}' to ${JSON.stringify(value)} (scope: ${scope}).`);
+                case "list": {
+                    const entries = {};
+                    for (const configKey of (0, state_1.listConfigKeys)()) {
+                        entries[configKey] = {
+                            current: (0, state_1.getConfigValue)(configKey),
+                            default: (0, state_1.getConfigDefault)(configKey),
+                        };
+                    }
+                    for (const [configKey, configValue] of (0, state_1.getRunScopedConfigEntries)()) {
+                        if (!entries[configKey]) {
+                            entries[configKey] = { current: configValue, default: undefined };
+                        }
+                    }
+                    return (0, results_1.jsonResult)(entries);
+                }
+                case "reset":
+                    (0, state_1.resetConfigValue)(key);
+                    return (0, results_1.ok)(key ? `Reset '${key}' to default.` : "Reset all config to defaults.");
+                default:
+                    return (0, results_1.errorResult)(`Error: Unknown action '${action}'. Use get, set, list, or reset.`);
+            }
+        },
+    };
+}

package/dist/agenticTools/discovery/tools.d.ts

@@ -0,0 +1,3 @@
+import type { AgenticToolOptions, CustomToolDefinition } from "../types";
+export declare function createDiscoveryTools(options: AgenticToolOptions): CustomToolDefinition[];
+//# sourceMappingURL=tools.d.ts.map

package/dist/agenticTools/discovery/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/discovery/tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAGzE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB,EAAE,CA0ExF"}

package/dist/agenticTools/discovery/tools.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiscoveryTools = createDiscoveryTools;
+const typebox_1 = require("@sinclair/typebox");
+const results_1 = require("../shared/results");
+function createDiscoveryTools(options) {
+    return [
+        {
+            name: "tool_search",
+            label: "Search Tools",
+            description: "Search available tools by name or description. Returns lightweight entries. Use tool_fetch to get full schema for a specific tool.",
+            parameters: typebox_1.Type.Object({
+                query: typebox_1.Type.String({ description: "Search query (matched against tool names and descriptions)" }),
+                max_results: typebox_1.Type.Optional(typebox_1.Type.Number({ description: "Maximum results to return (default 20)" })),
+            }),
+            execute: (_toolCallId, params) => {
+                const registry = options.deferredToolRegistry;
+                if (!registry) {
+                    return (0, results_1.errorResult)("Tool search is not available — no deferred tool registry configured.");
+                }
+                const query = String(params.query ?? "");
+                const maxResults = typeof params.max_results === "number" ? params.max_results : 20;
+                const results = registry.searchTools(query, maxResults);
+                return (0, results_1.jsonResult)({
+                    query,
+                    resultCount: results.length,
+                    tools: results.map((tool) => ({
+                        name: tool.name,
+                        description: tool.description,
+                        source: tool.source,
+                        sourceQualifier: tool.sourceQualifier,
+                    })),
+                });
+            },
+        },
+        {
+            name: "tool_fetch",
+            label: "Fetch Tool Schema",
+            description: "Fetch the full JSON Schema for a tool by name. Returns the complete input/output schema needed to invoke the tool.",
+            parameters: typebox_1.Type.Object({
+                name: typebox_1.Type.String({ description: "Tool name to fetch schema for" }),
+                source: typebox_1.Type.Optional(typebox_1.Type.String({ description: "Source filter: builtin, mcp, plugin, custom" })),
+                source_qualifier: typebox_1.Type.Optional(typebox_1.Type.String({ description: "Source qualifier (e.g. MCP server name)" })),
+            }),
+            execute: async (_toolCallId, params) => {
+                const registry = options.deferredToolRegistry;
+                if (!registry) {
+                    return (0, results_1.errorResult)("Tool fetch is not available — no deferred tool registry configured.");
+                }
+                const toolName = String(params.name ?? "");
+                const validSources = new Set(["builtin", "mcp", "plugin", "custom"]);
+                const rawSource = typeof params.source === "string" ? params.source : undefined;
+                if (rawSource && !validSources.has(rawSource)) {
+                    return (0, results_1.errorResult)(`Invalid source "${rawSource}". Valid sources: builtin, mcp, plugin, custom.`);
+                }
+                const resolved = await registry.fetchSchema(toolName, rawSource, typeof params.source_qualifier === "string" ? params.source_qualifier : undefined);
+                if (!resolved) {
+                    return (0, results_1.errorResult)(`Tool "${toolName}" not found or schema could not be loaded.`);
+                }
+                return (0, results_1.jsonResult)({
+                    name: resolved.name,
+                    description: resolved.description,
+                    source: resolved.source,
+                    sourceQualifier: resolved.sourceQualifier,
+                    inputSchema: resolved.schema.inputSchema,
+                    outputSchema: resolved.schema.outputSchema,
+                });
+            },
+        },
+    ];
+}

package/dist/agenticTools/index.d.ts

@@ -0,0 +1,5 @@
+import type { AgenticToolOptions, CustomToolDefinition } from "./types";
+export declare function createAgentCoreToolDefinitions(options: AgenticToolOptions): CustomToolDefinition[];
+export declare function disposeAgentCoreToolDefinitions(definitions: CustomToolDefinition[]): void;
+export declare const createAgenticToolDefinitions: typeof createAgentCoreToolDefinitions;
+//# sourceMappingURL=index.d.ts.map

package/dist/agenticTools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agenticTools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAmBxE,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB,EAAE,CAsBlG;AAED,wBAAgB,+BAA+B,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAOzF;AAED,eAAO,MAAM,4BAA4B,uCAAiC,CAAC"}

package/dist/agenticTools/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgenticToolDefinitions = void 0;
+exports.createAgentCoreToolDefinitions = createAgentCoreToolDefinitions;
+exports.disposeAgentCoreToolDefinitions = disposeAgentCoreToolDefinitions;
+const state_1 = require("./background/state");
+const tools_1 = require("./background/tools");
+const tool_1 = require("./browser/tool");
+const tool_2 = require("./config/tool");
+const tools_2 = require("./discovery/tools");
+const results_1 = require("./shared/results");
+const tools_3 = require("./web/tools");
+const code_1 = require("./tools/code");
+const delegation_1 = require("./tools/delegation");
+const execution_1 = require("./tools/execution");
+const fileSystem_1 = require("./tools/fileSystem");
+const programmaticToolCalling_1 = require("./tools/programmaticToolCalling");
+const toolDefinitionScopes = new WeakMap();
+function createAgentCoreToolDefinitions(options) {
+    const baseTools = [
+        ...(0, fileSystem_1.createFileSystemTools)(options),
+        ...(0, execution_1.createExecutionTools)(options),
+        (0, tool_1.createBrowserTool)(),
+        ...(0, delegation_1.createDelegationTools)(options),
+        ...(0, code_1.createCodeTools)(options),
+        (0, tool_2.createConfigTool)(),
+        ...(0, tools_1.createBackgroundTools)(options),
+        ...(0, tools_2.createDiscoveryTools)(options),
+        ...(0, tools_3.createWebTools)(),
+    ].map((tool) => (0, results_1.wrapToolDefinition)(tool, options.onToolUse));
+    const tools = (0, programmaticToolCalling_1.shouldEnableProgrammaticToolCalling)(options)
+        ? [
+            ...baseTools,
+            (0, results_1.wrapToolDefinition)((0, programmaticToolCalling_1.createProgrammaticToolCallingTool)(options, baseTools), options.onToolUse),
+        ]
+        : baseTools;
+    toolDefinitionScopes.set(tools, options);
+    return tools;
+}
+function disposeAgentCoreToolDefinitions(definitions) {
+    const options = toolDefinitionScopes.get(definitions);
+    if (!options) {
+        return;
+    }
+    (0, state_1.disposeBackgroundRegistry)(options);
+    toolDefinitionScopes.delete(definitions);
+}
+exports.createAgenticToolDefinitions = createAgentCoreToolDefinitions;

package/dist/agenticTools/shared/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function assertInsideWorkspace(target: string, workspace: string): void;
+export declare function resolveSafe(workspace: string, filePath: string): string;
+export declare function globToRegex(pattern: string): RegExp;
+export declare function walkDir(directory: string, includeHidden: boolean, limit: number, results: string[]): void;
+//# sourceMappingURL=paths.d.ts.map

package/dist/agenticTools/shared/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/shared/paths.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAU7E;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIvE;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA2BnD;AAED,wBAAgB,OAAO,CACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,OAAO,EACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,GAChB,IAAI,CA2BN"}