@a5c-ai/agent-core 5.0.1-staging.ee42097a6d34 → 5.0.1-staging.ee474eb45

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/index.d.ts.map

@@ -1 +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;AAexE,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,kBAAkB,GAAG,oBAAoB,EAAE,CAelG;AAED,wBAAgB,+BAA+B,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAOzF;AAED,eAAO,MAAM,4BAA4B,uCAAiC,CAAC"}
+{"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

@@ -14,9 +14,10 @@ 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 tools = [
+    const baseTools = [
         ...(0, fileSystem_1.createFileSystemTools)(options),
         ...(0, execution_1.createExecutionTools)(options),
         (0, tool_1.createBrowserTool)(),
@@ -27,6 +28,12 @@ function createAgentCoreToolDefinitions(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;
 }

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

@@ -0,0 +1,4 @@
+import type { AgenticToolOptions, CustomToolDefinition } from "../types";
+export declare function shouldEnableProgrammaticToolCalling(options: AgenticToolOptions): boolean;
+export declare function createProgrammaticToolCallingTool(options: AgenticToolOptions, availableTools: CustomToolDefinition[]): CustomToolDefinition;
+//# sourceMappingURL=programmaticToolCalling.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"programmaticToolCalling.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/tools/programmaticToolCalling.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAc,MAAM,UAAU,CAAC;AAgBrF,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAExF;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,kBAAkB,EAC3B,cAAc,EAAE,oBAAoB,EAAE,GACrC,oBAAoB,CAwEtB"}

package/dist/agenticTools/tools/programmaticToolCalling.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldEnableProgrammaticToolCalling = shouldEnableProgrammaticToolCalling;
+exports.createProgrammaticToolCallingTool = createProgrammaticToolCallingTool;
+const node_vm_1 = __importDefault(require("node:vm"));
+const typebox_1 = require("@sinclair/typebox");
+const results_1 = require("../shared/results");
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_MAX_TOOL_CALLS = 25;
+function shouldEnableProgrammaticToolCalling(options) {
+    return Boolean(options.programmaticToolCalling);
+}
+function createProgrammaticToolCallingTool(options, availableTools) {
+    const config = resolveExecutorConfig(options);
+    const callableTools = availableTools.filter((tool) => tool.name !== "code_executor");
+    return {
+        name: "code_executor",
+        label: "Programmatic Tool Calling",
+        description: [
+            "Execute a JavaScript tool chain against the agent-core tool surface.",
+            "Use tools.<name>(params) or callTool(name, params) to batch discovery,",
+            "fetch, filesystem, shell, web, and other enabled tools in one request.",
+        ].join(" "),
+        promptSnippet: [
+            "Programmatic Tool Calling is available through code_executor.",
+            "Write JavaScript inside an async function body and return the final value.",
+            "Call agent-core tools with await tools.read({ path: 'README.md' }) or await callTool('tool_search', { query: 'git' }).",
+        ].join("\n"),
+        parameters: typebox_1.Type.Object({
+            code: typebox_1.Type.String({
+                description: "JavaScript async function body. Use return <value> for the final result.",
+            }),
+            timeout: typebox_1.Type.Optional(typebox_1.Type.Number({ description: `Timeout in ms (default: ${config.timeout})` })),
+            max_tool_calls: typebox_1.Type.Optional(typebox_1.Type.Number({
+                description: `Maximum nested tool calls (default: ${config.maxToolCalls})`,
+            })),
+        }),
+        execute: async (_toolCallId, params) => {
+            const calls = [];
+            const timeout = resolveInvocationLimit(params.timeout, config.timeout);
+            const maxToolCalls = resolveInvocationLimit(params.max_tool_calls, config.maxToolCalls);
+            const logs = [];
+            const toolMap = new Map(callableTools.map((tool) => [tool.name, tool]));
+            const callTool = async (name, toolParams = {}) => {
+                if (calls.length >= maxToolCalls) {
+                    throw new Error(`code_executor exceeded max_tool_calls (${maxToolCalls})`);
+                }
+                const tool = toolMap.get(name);
+                if (!tool) {
+                    throw new Error(`Tool "${name}" is not available to code_executor.`);
+                }
+                calls.push({ tool: name, params: toolParams });
+                return unwrapToolResult(await tool.execute(`code-executor:${calls.length}:${name}`, toolParams));
+            };
+            const tools = Object.create(null);
+            for (const tool of callableTools) {
+                tools[tool.name] = (toolParams = {}) => callTool(tool.name, toolParams);
+            }
+            const context = node_vm_1.default.createContext({
+                callTool,
+                tools,
+                console: {
+                    log: (...items) => logs.push(items.map(stringifyLogItem).join(" ")),
+                    error: (...items) => logs.push(items.map(stringifyLogItem).join(" ")),
+                    warn: (...items) => logs.push(items.map(stringifyLogItem).join(" ")),
+                },
+            });
+            const script = new node_vm_1.default.Script(`(async () => {\n${String(params.code ?? "")}\n})()`);
+            const startedAt = Date.now();
+            const result = await withTimeout(Promise.resolve(script.runInContext(context, { timeout })), timeout);
+            return (0, results_1.jsonResult)({
+                result,
+                logs,
+                toolCalls: calls,
+                duration: Date.now() - startedAt,
+            });
+        },
+    };
+}
+function resolveInvocationLimit(value, configuredLimit) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return configuredLimit;
+    }
+    return Math.min(Math.floor(value), configuredLimit);
+}
+function resolveExecutorConfig(options) {
+    const configured = options.programmaticToolCalling;
+    if (configured && typeof configured === "object") {
+        return {
+            timeout: configured.timeout ?? DEFAULT_TIMEOUT_MS,
+            maxToolCalls: configured.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS,
+        };
+    }
+    return {
+        timeout: DEFAULT_TIMEOUT_MS,
+        maxToolCalls: DEFAULT_MAX_TOOL_CALLS,
+    };
+}
+async function withTimeout(promise, timeout) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`code_executor timed out after ${timeout}ms`)), timeout);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+function unwrapToolResult(result) {
+    const text = result.content.map((item) => item.text).join("\n");
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function stringifyLogItem(item) {
+    if (typeof item === "string") {
+        return item;
+    }
+    try {
+        return JSON.stringify(item);
+    }
+    catch {
+        return String(item);
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { AgentCorePromptResult, AgentCoreSessionEvent, AgentCoreSessionOptions, AgentCoreToolOptions, AgentCoreToolOptions as AgenticToolOptions, CustomToolDefinition, ToolResult, } from "./types";
+export type { AgentCorePromptResult, AgentCoreSessionEvent, AgentCoreSessionOptions, AgentCoreToolOptions, AgentCoreToolOptions as AgenticToolOptions, CustomToolDefinition, ProgrammaticToolCallingOptions, ToolResult, } from "./types";
 export { AGENT_CORE_TOOL_NAMES } from "./types";
 export { AGENT_CORE_TOOL_NAMES as AGENTIC_TOOL_NAMES } from "./types";
 export { AgentCoreSessionHandle, createAgentCoreSession, type AgentCoreEventListener, } from "./session";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,IAAI,kBAAkB,EAC1C,oBAAoB,EACpB,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,qBAAqB,IAAI,kBAAkB,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,IAAI,kBAAkB,EAC1C,oBAAoB,EACpB,8BAA8B,EAC9B,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,qBAAqB,IAAI,kBAAkB,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/session.d.ts

@@ -3,12 +3,13 @@ export type AgentCoreEventListener = (event: AgentCoreSessionEvent) => void;
 export declare class AgentCoreSessionHandle {
     private readonly options;
     private readonly listeners;
-    private activeHandle;
     private queuedFollowUps;
     private currentSessionId;
+    private isActive;
     constructor(options?: AgentCoreSessionOptions);
     initialize(): Promise<void>;
     prompt(text: string, timeout?: number): Promise<AgentCorePromptResult>;
+    private emit;
     steer(text: string): Promise<void>;
     followUp(text: string): Promise<void>;
     subscribe(listener: AgentCoreEventListener): () => void;

package/dist/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,SAAS,CAAC;AASjB,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;AAsG5E,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAAqB;gBAEjC,OAAO,GAAE,uBAA4B;IAI3C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA8DtE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3C,SAAS,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,IAAI;IAOjD,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAsC1E,WAAW,CACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAI1E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B,OAAO,IAAI,IAAI;IASf,IAAI,SAAS,IAAI,MAAM,GAAG,SAAS,CAElC;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;CACF;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,sBAAsB,CAEhG"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAIjB,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;AAiH5E,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,uBAA4B;IAI3C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAuD5E,OAAO,CAAC,IAAI;IAMN,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C,SAAS,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,IAAI;IAOjD,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAsC1E,WAAW,CACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAI1E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,OAAO,IAAI,IAAI;IAKf,IAAI,SAAS,IAAI,MAAM,GAAG,SAAS,CAElC;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;CACF;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,sBAAsB,CAEhG"}

package/dist/session.js

@@ -37,30 +37,6 @@ exports.AgentCoreSessionHandle = void 0;
 exports.createAgentCoreSession = createAgentCoreSession;
 const childProcess = __importStar(require("node:child_process"));
 const DEFAULT_TIMEOUT_MS = 900_000;
-const DEFAULT_BACKEND = "codex-sdk";
-const SDK_BACKEND_SUFFIX = "-sdk";
-let agentMuxPromise = null;
-let agentMuxClientPromise = null;
-async function loadAgentMux() {
-    if (!agentMuxPromise) {
-        agentMuxPromise = Promise.resolve().then(() => __importStar(require("@a5c-ai/agent-mux")));
-    }
-    return agentMuxPromise;
-}
-async function getAgentMuxClient() {
-    if (!agentMuxClientPromise) {
-        agentMuxClientPromise = (async () => {
-            const agentMux = await loadAgentMux();
-            const client = agentMux.createClient({
-                approvalMode: "prompt",
-                stream: true,
-            });
-            agentMux.registerBuiltInAdapters(client);
-            return client;
-        })();
-    }
-    return agentMuxClientPromise;
-}
 function buildSystemPrompt(options) {
     const segments = [];
     if (options.systemPrompt?.trim()) {
@@ -78,57 +54,77 @@ function buildSystemPrompt(options) {
     }
     return segments.join("\n\n");
 }
-function mapThinkingLevel(thinkingLevel) {
-    switch (thinkingLevel) {
-        case "minimal":
-        case "low":
-            return "low";
-        case "medium":
-            return "medium";
-        case "high":
-            return "high";
-        case "xhigh":
-            return "max";
-        default:
-            return undefined;
-    }
+function resolveEndpoint(options) {
+    const model = options.model ?? "gpt-4o";
+    const amuxProvider = process.env["AMUX_PROVIDER"];
+    const amuxApiBase = process.env["AMUX_API_BASE"];
+    const amuxApiKey = process.env["AMUX_API_KEY"];
+    const azureApiKey = process.env["AZURE_API_KEY"];
+    const openaiApiKey = process.env["OPENAI_API_KEY"];
+    const anthropicApiKey = process.env["ANTHROPIC_API_KEY"];
+    if (amuxProvider === "foundry" || amuxProvider === "azure") {
+        const apiBase = amuxApiBase ?? "";
+        const apiKey = amuxApiKey ?? azureApiKey ?? "";
+        return { apiBase: `${apiBase}/openai`, apiKey, model, isAzure: true };
+    }
+    if (amuxApiBase) {
+        const apiKey = amuxApiKey ?? openaiApiKey ?? "";
+        return { apiBase: amuxApiBase, apiKey, model, isAzure: false };
+    }
+    if (openaiApiKey) {
+        return { apiBase: "https://api.openai.com/v1", apiKey: openaiApiKey, model, isAzure: false };
+    }
+    if (anthropicApiKey) {
+        return { apiBase: "https://api.anthropic.com", apiKey: anthropicApiKey, model, isAzure: false };
+    }
+    return { apiBase: "https://api.openai.com/v1", apiKey: amuxApiKey ?? "", model, isAzure: false };
 }
-function mapEventPayload(event) {
-    if (!event || typeof event !== "object") {
-        return { type: "unknown", value: event };
-    }
-    const typed = event;
-    return {
-        type: typeof typed.type === "string" ? typed.type : "unknown",
-        ...typed,
-    };
-}
-function resolveRunBackend(client, options) {
-    const configuredBackend = options.backend ?? process.env.AGENT_CORE_BACKEND;
-    if (configuredBackend) {
-        return configuredBackend;
-    }
-    if (!options.model) {
-        return DEFAULT_BACKEND;
-    }
-    const defaultBackendSupportsModel = client.models.model(DEFAULT_BACKEND, options.model);
-    if (defaultBackendSupportsModel) {
-        return DEFAULT_BACKEND;
-    }
-    if (DEFAULT_BACKEND.endsWith(SDK_BACKEND_SUFFIX)) {
-        const fallbackBackend = DEFAULT_BACKEND.slice(0, -SDK_BACKEND_SUFFIX.length);
-        if (client.adapters.get(fallbackBackend)) {
-            return fallbackBackend;
+async function callCompletionApi(endpoint, messages, timeout) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        let url;
+        const headers = { "Content-Type": "application/json" };
+        if (endpoint.isAzure) {
+            url = `${endpoint.apiBase}/deployments/${endpoint.model}/chat/completions?api-version=2025-04-01-preview`;
+            headers["api-key"] = endpoint.apiKey;
         }
+        else {
+            url = `${endpoint.apiBase}/chat/completions`;
+            headers["Authorization"] = `Bearer ${endpoint.apiKey}`;
+        }
+        const body = JSON.stringify({
+            model: endpoint.model,
+            messages,
+            max_completion_tokens: 16384,
+        });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API request failed (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        const text = data.choices?.[0]?.message?.content ?? "";
+        const usage = data.usage
+            ? { promptTokens: data.usage.prompt_tokens ?? 0, completionTokens: data.usage.completion_tokens ?? 0 }
+            : undefined;
+        return { text, usage };
+    }
+    finally {
+        clearTimeout(timer);
     }
-    return DEFAULT_BACKEND;
 }
 class AgentCoreSessionHandle {
     options;
     listeners = new Set();
-    activeHandle = null;
     queuedFollowUps = [];
     currentSessionId;
+    isActive = false;
     constructor(options = {}) {
         this.options = options;
     }
@@ -136,72 +132,62 @@ class AgentCoreSessionHandle {
         return;
     }
     async prompt(text, timeout) {
-        if (this.activeHandle) {
+        if (this.isActive) {
             throw new Error("Agent core session is already processing a prompt");
         }
-        const agentMux = await loadAgentMux();
-        const client = await getAgentMuxClient();
+        this.isActive = true;
         const effectiveTimeout = timeout ?? this.options.timeout ?? DEFAULT_TIMEOUT_MS;
-        const backend = resolveRunBackend(client, this.options);
-        const thinkingEffort = mapThinkingLevel(this.options.thinkingLevel);
         const start = Date.now();
         const followUps = this.queuedFollowUps;
         this.queuedFollowUps = [];
         const promptText = followUps.length > 0
             ? [text, ...followUps.map((item) => `Follow-up instruction:\n${item}`)].join("\n\n")
             : text;
-        const handle = client.run({
-            agent: backend,
-            prompt: promptText,
-            cwd: this.options.workspace,
-            model: this.options.model,
-            timeout: effectiveTimeout,
-            sessionId: this.currentSessionId,
-            systemPrompt: buildSystemPrompt(this.options),
-            systemPromptMode: this.options.systemPrompt ? "replace" : "append",
-            approvalMode: this.options.uiContext ? "prompt" : "yolo",
-            ...(thinkingEffort ? { thinkingEffort } : {}),
-            collectEvents: true,
-        });
-        this.activeHandle = handle;
-        const pump = (async () => {
-            for await (const event of handle) {
-                const mapped = mapEventPayload(event);
-                if (mapped.type === "session_start" && typeof mapped.sessionId === "string") {
-                    this.currentSessionId = mapped.sessionId;
-                }
-                for (const listener of this.listeners) {
-                    listener(mapped);
-                }
+        try {
+            const endpoint = resolveEndpoint(this.options);
+            const messages = [];
+            const systemPrompt = buildSystemPrompt(this.options);
+            if (systemPrompt) {
+                messages.push({ role: "system", content: systemPrompt });
             }
-        })();
-        const result = await handle;
-        await pump;
-        this.activeHandle = null;
-        if (result.sessionId) {
-            this.currentSessionId = result.sessionId;
+            messages.push({ role: "user", content: promptText });
+            const sessionId = this.currentSessionId ?? `agent-core-${Date.now()}`;
+            this.currentSessionId = sessionId;
+            this.emit({ type: "session_start", sessionId });
+            const result = await callCompletionApi(endpoint, messages, effectiveTimeout);
+            this.emit({ type: "text_delta", delta: result.text });
+            this.emit({ type: "session_end", sessionId });
+            return {
+                output: result.text,
+                duration: Date.now() - start,
+                success: true,
+                exitCode: 0,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.emit({ type: "error", message });
+            return {
+                output: message,
+                duration: Date.now() - start,
+                success: false,
+                exitCode: 1,
+            };
+        }
+        finally {
+            this.isActive = false;
         }
-        const output = result.text || result.error?.message || "";
-        return {
-            output,
-            duration: Date.now() - start,
-            success: result.exitReason === "completed" && !result.error,
-            exitCode: result.exitCode ?? (result.error ? 1 : 0),
-        };
     }
-    async steer(text) {
-        if (!this.activeHandle) {
-            this.queuedFollowUps.push(text);
-            return;
+    emit(event) {
+        for (const listener of this.listeners) {
+            listener(event);
         }
-        await this.activeHandle.send(text);
+    }
+    async steer(text) {
+        this.queuedFollowUps.push(text);
     }
     async followUp(text) {
-        if (!this.activeHandle) {
-            this.queuedFollowUps.push(text);
-            return;
-        }
-        await this.activeHandle.queue(text, { when: "after-response" });
+        this.queuedFollowUps.push(text);
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -247,15 +233,9 @@ class AgentCoreSessionHandle {
         return this.executeCommand(command, onChunk);
     }
     async abort() {
-        if (this.activeHandle) {
-            await this.activeHandle.abort();
-        }
+        // Direct API calls don't support mid-request abort easily
     }
     dispose() {
-        if (this.activeHandle) {
-            void this.activeHandle.abort().catch(() => undefined);
-            this.activeHandle = null;
-        }
         this.listeners.clear();
         this.queuedFollowUps = [];
     }
@@ -263,7 +243,7 @@ class AgentCoreSessionHandle {
         return this.currentSessionId;
     }
     get isStreaming() {
-        return this.activeHandle !== null;
+        return this.isActive;
     }
 }
 exports.AgentCoreSessionHandle = AgentCoreSessionHandle;

package/dist/session.test.js

@@ -1,258 +1,116 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
-function createHandle(result, events = []) {
-    const handle = Object.assign(Promise.resolve(result), {
-        send: vitest_1.vi.fn(async () => undefined),
-        queue: vitest_1.vi.fn(async () => undefined),
-        abort: vitest_1.vi.fn(async () => undefined),
-        async *[Symbol.asyncIterator]() {
-            for (const event of events) {
-                yield event;
-            }
-        },
-    });
-    return handle;
-}
-function createPendingHandle(events = []) {
-    let resolveResult;
-    const promise = new Promise((resolve) => {
-        resolveResult = resolve;
-    });
-    const handle = Object.assign(promise, {
-        send: vitest_1.vi.fn(async () => undefined),
-        queue: vitest_1.vi.fn(async () => undefined),
-        abort: vitest_1.vi.fn(async () => undefined),
-        async *[Symbol.asyncIterator]() {
-            for (const event of events) {
-                yield event;
-            }
-        },
-    });
-    return {
-        handle,
-        resolve(result) {
-            resolveResult?.(result);
-        },
-    };
-}
-async function loadSessionModule(args) {
-    vitest_1.vi.resetModules();
-    const run = vitest_1.vi.fn((options) => args.runImplementation?.(options) ?? createHandle(args.handleResult ?? { text: "ok", exitReason: "completed", exitCode: 0, sessionId: "session-1" }, args.events));
-    const models = {
-        model: vitest_1.vi.fn((agent, modelId) => args.modelImplementation?.(agent, modelId) ?? null),
-    };
-    const adapters = {
-        get: vitest_1.vi.fn((agent) => args.adapterImplementation?.(agent)),
-    };
-    const createClient = vitest_1.vi.fn(() => ({ run, models, adapters }));
-    const registerBuiltInAdapters = vitest_1.vi.fn();
-    vitest_1.vi.doMock("@a5c-ai/agent-mux", () => ({
-        createClient,
-        registerBuiltInAdapters,
-    }));
-    const sessionModule = await Promise.resolve().then(() => __importStar(require("./session")));
-    return { ...sessionModule, createClient, registerBuiltInAdapters, run, models, adapters };
-}
+const session_1 = require("./session");
+const mockFetch = vitest_1.vi.fn();
 (0, vitest_1.describe)("AgentCoreSessionHandle", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.stubGlobal("fetch", mockFetch);
+        vitest_1.vi.stubEnv("OPENAI_API_KEY", "test-key");
+    });
     (0, vitest_1.afterEach)(() => {
-        vitest_1.vi.resetModules();
-        vitest_1.vi.clearAllMocks();
+        vitest_1.vi.unstubAllGlobals();
         vitest_1.vi.unstubAllEnvs();
+        vitest_1.vi.clearAllMocks();
     });
-    (0, vitest_1.it)("forwards the supported run options and translates thinkingLevel", async () => {
-        const sessionModule = await loadSessionModule({
-            events: [{ type: "session_start", sessionId: "started-session" }],
-        });
-        const session = sessionModule.createAgentCoreSession({
-            workspace: "/tmp/workspace",
-            model: "gpt-5.4",
-            timeout: 12_345,
-            thinkingLevel: "xhigh",
-            uiContext: { interactive: true },
-            systemPrompt: "Base prompt",
-            appendSystemPrompt: ["More context"],
-            backend: "codex",
-            toolsMode: "coding",
-            customTools: [{ name: "ignored-tool" }],
-            isolated: true,
-            ephemeral: true,
-            bashSandbox: "secure",
-            enableCompaction: true,
-            agentDir: "/tmp/agents",
-        });
-        await session.prompt("Implement the change");
-        (0, vitest_1.expect)(sessionModule.createClient).toHaveBeenCalledWith({
-            approvalMode: "prompt",
-            stream: true,
-        });
-        (0, vitest_1.expect)(sessionModule.registerBuiltInAdapters).toHaveBeenCalledTimes(1);
-        (0, vitest_1.expect)(sessionModule.run).toHaveBeenCalledWith({
-            agent: "codex",
-            prompt: "Implement the change",
-            cwd: "/tmp/workspace",
-            model: "gpt-5.4",
-            timeout: 12_345,
-            sessionId: undefined,
-            systemPrompt: "Base prompt\n\nMore context",
-            systemPromptMode: "replace",
-            approvalMode: "prompt",
-            thinkingEffort: "max",
-            collectEvents: true,
+    function mockApiResponse(text) {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                choices: [{ message: { content: text } }],
+                usage: { prompt_tokens: 10, completion_tokens: 5 },
+            }),
         });
-        const firstCall = sessionModule.run.mock.calls[0];
-        (0, vitest_1.expect)(firstCall).toBeDefined();
-        const forwarded = firstCall?.[0];
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("toolsMode");
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("customTools");
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("isolated");
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("ephemeral");
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("bashSandbox");
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("enableCompaction");
-        (0, vitest_1.expect)(forwarded).not.toHaveProperty("agentDir");
+    }
+    (0, vitest_1.it)("makes a direct API call with the prompt", async () => {
+        mockApiResponse("hello world");
+        const session = (0, session_1.createAgentCoreSession)({ model: "gpt-5.5" });
+        const result = await session.prompt("Say hello");
+        (0, vitest_1.expect)(result.success).toBe(true);
+        (0, vitest_1.expect)(result.output).toBe("hello world");
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledTimes(1);
+        const [url, options] = mockFetch.mock.calls[0];
+        (0, vitest_1.expect)(url).toBe("https://api.openai.com/v1/chat/completions");
+        const body = JSON.parse(options.body);
+        (0, vitest_1.expect)(body.model).toBe("gpt-5.5");
+        (0, vitest_1.expect)(body.messages).toEqual([{ role: "user", content: "Say hello" }]);
     });
-    (0, vitest_1.it)("uses append mode and yolo approval when no interactive UI context is provided", async () => {
-        const sessionModule = await loadSessionModule({});
-        const session = sessionModule.createAgentCoreSession({
-            appendSystemPrompt: ["Line one", "Line two"],
-        });
-        await session.prompt("Review this");
-        (0, vitest_1.expect)(sessionModule.run).toHaveBeenCalledWith({
-            agent: "codex-sdk",
-            prompt: "Review this",
-            cwd: undefined,
-            model: undefined,
-            timeout: 900_000,
-            sessionId: undefined,
-            systemPrompt: "Line one\n\nLine two",
-            systemPromptMode: "append",
-            approvalMode: "yolo",
-            collectEvents: true,
-        });
+    (0, vitest_1.it)("includes system prompt when provided", async () => {
+        mockApiResponse("ok");
+        const session = (0, session_1.createAgentCoreSession)({
+            systemPrompt: "You are helpful",
+            appendSystemPrompt: ["Be concise"],
+        });
+        await session.prompt("Do something");
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        (0, vitest_1.expect)(body.messages[0]).toEqual({ role: "system", content: "You are helpful\n\nBe concise" });
+        (0, vitest_1.expect)(body.messages[1]).toEqual({ role: "user", content: "Do something" });
     });
-    (0, vitest_1.it)("falls back from the implicit sdk backend to the paired subprocess backend for unsupported models", async () => {
-        const sessionModule = await loadSessionModule({
-            modelImplementation: () => null,
-            adapterImplementation: (agent) => (agent === "codex" ? { agent } : undefined),
-        });
-        const session = sessionModule.createAgentCoreSession({
-            model: "gpt-5.4",
-        });
-        await session.prompt("Plan the run");
-        (0, vitest_1.expect)(sessionModule.models.model).toHaveBeenCalledWith("codex-sdk", "gpt-5.4");
-        (0, vitest_1.expect)(sessionModule.adapters.get).toHaveBeenCalledWith("codex");
-        (0, vitest_1.expect)(sessionModule.run).toHaveBeenCalledWith({
-            agent: "codex",
-            prompt: "Plan the run",
-            cwd: undefined,
-            model: "gpt-5.4",
-            timeout: 900_000,
-            sessionId: undefined,
-            systemPrompt: undefined,
-            systemPromptMode: "append",
-            approvalMode: "yolo",
-            collectEvents: true,
-        });
+    (0, vitest_1.it)("routes to Azure foundry when AMUX_PROVIDER=foundry", async () => {
+        vitest_1.vi.stubEnv("AMUX_PROVIDER", "foundry");
+        vitest_1.vi.stubEnv("AMUX_API_BASE", "https://myresource.services.ai.azure.com");
+        vitest_1.vi.stubEnv("AZURE_API_KEY", "az-key-123");
+        mockApiResponse("azure response");
+        const session = (0, session_1.createAgentCoreSession)({ model: "gpt-5.5" });
+        await session.prompt("Hello");
+        const [url, options] = mockFetch.mock.calls[0];
+        (0, vitest_1.expect)(url).toBe("https://myresource.services.ai.azure.com/openai/deployments/gpt-5.5/chat/completions?api-version=2025-04-01-preview");
+        (0, vitest_1.expect)(options.headers["api-key"]).toBe("az-key-123");
+        (0, vitest_1.expect)(options.headers["Authorization"]).toBeUndefined();
     });
-    (0, vitest_1.it)("reuses the session id learned from the prior run", async () => {
-        const sessionModule = await loadSessionModule({
-            handleResult: { text: "ok", exitReason: "completed", exitCode: 0, sessionId: "persisted-session" },
-        });
-        const session = sessionModule.createAgentCoreSession();
-        await session.prompt("First prompt");
-        await session.prompt("Second prompt");
-        const firstCall = sessionModule.run.mock.calls[0];
-        const secondCall = sessionModule.run.mock.calls[1];
-        (0, vitest_1.expect)(firstCall).toBeDefined();
-        (0, vitest_1.expect)(secondCall).toBeDefined();
-        (0, vitest_1.expect)(firstCall?.[0]).toMatchObject({
-            sessionId: undefined,
-        });
-        (0, vitest_1.expect)(secondCall?.[0]).toMatchObject({
-            sessionId: "persisted-session",
-        });
+    (0, vitest_1.it)("uses OPENAI_API_KEY with Bearer auth for OpenAI", async () => {
+        mockApiResponse("openai response");
+        const session = (0, session_1.createAgentCoreSession)({});
+        await session.prompt("Test");
+        const [, options] = mockFetch.mock.calls[0];
+        (0, vitest_1.expect)(options.headers["Authorization"]).toBe("Bearer test-key");
+        (0, vitest_1.expect)(options.headers["api-key"]).toBeUndefined();
     });
     (0, vitest_1.it)("appends queued follow-up instructions to the next prompt only once", async () => {
-        const sessionModule = await loadSessionModule({});
-        const session = sessionModule.createAgentCoreSession();
+        mockApiResponse("first");
+        mockApiResponse("second");
+        const session = (0, session_1.createAgentCoreSession)({});
         await session.steer("Use the session export path");
         await session.followUp("Add the registry regression");
         await session.prompt("Implement tests");
         await session.prompt("Verify again");
-        (0, vitest_1.expect)(sessionModule.run.mock.calls[0]?.[0]).toMatchObject({
-            prompt: [
-                "Implement tests",
-                "Follow-up instruction:\nUse the session export path",
-                "Follow-up instruction:\nAdd the registry regression",
-            ].join("\n\n"),
-        });
-        (0, vitest_1.expect)(sessionModule.run.mock.calls[1]?.[0]).toMatchObject({
-            prompt: "Verify again",
-        });
+        const firstBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+        const secondBody = JSON.parse(mockFetch.mock.calls[1][1].body);
+        (0, vitest_1.expect)(firstBody.messages[0].content).toContain("Implement tests");
+        (0, vitest_1.expect)(firstBody.messages[0].content).toContain("Follow-up instruction:\nUse the session export path");
+        (0, vitest_1.expect)(secondBody.messages[0].content).toBe("Verify again");
     });
-    (0, vitest_1.it)("normalizes unknown event payloads for subscribers", async () => {
-        const sessionModule = await loadSessionModule({
-            events: [null, { foo: "bar" }, { type: "session_start", sessionId: "event-session" }],
-            handleResult: { text: "ok", exitReason: "completed", exitCode: 0, sessionId: "event-session" },
-        });
-        const session = sessionModule.createAgentCoreSession();
-        const received = [];
-        session.subscribe((event) => {
-            received.push(event);
-        });
-        await session.prompt("Inspect event flow");
-        (0, vitest_1.expect)(received).toEqual([
-            { type: "unknown", value: null },
-            { type: "unknown", foo: "bar" },
-            { type: "session_start", sessionId: "event-session" },
-        ]);
-        (0, vitest_1.expect)(session.sessionId).toBe("event-session");
-        (0, vitest_1.expect)(session.isStreaming).toBe(false);
+    (0, vitest_1.it)("emits events to subscribers", async () => {
+        mockApiResponse("streamed text");
+        const session = (0, session_1.createAgentCoreSession)({});
+        const events = [];
+        session.subscribe((event) => events.push(event));
+        await session.prompt("Test events");
+        (0, vitest_1.expect)(events.some((e) => e.type === "session_start")).toBe(true);
+        (0, vitest_1.expect)(events.some((e) => e.type === "text_delta" && e.delta === "streamed text")).toBe(true);
+        (0, vitest_1.expect)(events.some((e) => e.type === "session_end")).toBe(true);
     });
-    (0, vitest_1.it)("rejects concurrent prompt attempts while a prompt is active", async () => {
-        const pending = createPendingHandle();
-        const sessionModule = await loadSessionModule({
-            runImplementation: () => pending.handle,
-        });
-        const session = sessionModule.createAgentCoreSession();
-        const firstPrompt = session.prompt("First prompt");
+    (0, vitest_1.it)("rejects concurrent prompt attempts", async () => {
+        let resolveResponse;
+        mockFetch.mockReturnValueOnce(new Promise((resolve) => { resolveResponse = resolve; }));
+        const session = (0, session_1.createAgentCoreSession)({});
+        const firstPrompt = session.prompt("First");
         await new Promise((resolve) => setTimeout(resolve, 0));
-        await (0, vitest_1.expect)(session.prompt("Second prompt")).rejects.toThrow("Agent core session is already processing a prompt");
-        pending.resolve({ text: "done", exitReason: "completed", exitCode: 0, sessionId: "session-1" });
+        await (0, vitest_1.expect)(session.prompt("Second")).rejects.toThrow("Agent core session is already processing a prompt");
+        resolveResponse({ ok: true, json: async () => ({ choices: [{ message: { content: "done" } }] }) });
         await firstPrompt;
         (0, vitest_1.expect)(session.isStreaming).toBe(false);
     });
+    (0, vitest_1.it)("handles API errors gracefully", async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            text: async () => "Unauthorized",
+        });
+        const session = (0, session_1.createAgentCoreSession)({});
+        const result = await session.prompt("Will fail");
+        (0, vitest_1.expect)(result.success).toBe(false);
+        (0, vitest_1.expect)(result.exitCode).toBe(1);
+        (0, vitest_1.expect)(result.output).toContain("401");
+    });
 });

package/dist/tools.test.js

@@ -185,6 +185,83 @@ function mockSpawnExit(exitCode = 0, stdoutText = "") {
             exitCode: 7,
         });
     });
+    (0, vitest_1.it)("exposes code_executor only when programmatic tool calling is enabled", () => {
+        const workspace = (0, node_fs_1.mkdtempSync)(path.join(os.tmpdir(), "agent-core-code-mode-toggle-"));
+        (0, vitest_1.expect)(getToolDefinitions(workspace).some((tool) => tool.name === "code_executor")).toBe(false);
+        (0, vitest_1.expect)(getToolDefinitions(workspace, { programmaticToolCalling: true }).some((tool) => tool.name === "code_executor"))
+            .toBe(true);
+    });
+    (0, vitest_1.it)("executes a programmatic tool chain against existing tools", async () => {
+        const workspace = (0, node_fs_1.mkdtempSync)(path.join(os.tmpdir(), "agent-core-code-mode-"));
+        (0, node_fs_1.writeFileSync)(path.join(workspace, "note.txt"), "alpha\nbeta\n", "utf8");
+        const onToolUse = vitest_1.vi.fn();
+        const definitions = getToolDefinitions(workspace, {
+            onToolUse,
+            programmaticToolCalling: true,
+        });
+        const codeExecutor = definitions.find((tool) => tool.name === "code_executor");
+        if (!codeExecutor) {
+            throw new Error("Expected code_executor to be registered");
+        }
+        const result = await codeExecutor.execute("code-mode", {
+            code: [
+                "const readResult = await tools.read({ path: 'note.txt' });",
+                "await callTool('write', { path: 'copy.txt', content: readResult });",
+                "console.log('read bytes', String(readResult).length);",
+                "return { readResult, copied: await tools.read({ path: 'copy.txt' }) };",
+            ].join("\n"),
+        });
+        const resultText = getText(result);
+        if (resultText.startsWith("Error:")) {
+            throw new Error(resultText);
+        }
+        const payload = JSON.parse(resultText);
+        (0, vitest_1.expect)(payload.result.readResult).toContain("alpha");
+        (0, vitest_1.expect)(payload.result.copied).toContain("alpha");
+        (0, vitest_1.expect)(payload.logs).toEqual(["read bytes 17"]);
+        (0, vitest_1.expect)(payload.toolCalls.map((call) => call.tool)).toEqual(["read", "write", "read"]);
+        (0, vitest_1.expect)(onToolUse).toHaveBeenCalledWith("code_executor", vitest_1.expect.objectContaining({ code: vitest_1.expect.any(String) }));
+        (0, vitest_1.expect)(onToolUse).toHaveBeenCalledWith("read", { path: "note.txt" });
+        (0, vitest_1.expect)(onToolUse).toHaveBeenCalledWith("write", {
+            path: "copy.txt",
+            content: vitest_1.expect.stringContaining("alpha"),
+        });
+    });
+    (0, vitest_1.it)("enforces code_executor nested tool call limits", async () => {
+        const workspace = (0, node_fs_1.mkdtempSync)(path.join(os.tmpdir(), "agent-core-code-mode-limit-"));
+        const codeExecutor = getToolDefinitions(workspace, {
+            programmaticToolCalling: { maxToolCalls: 1 },
+        }).find((tool) => tool.name === "code_executor");
+        if (!codeExecutor) {
+            throw new Error("Expected code_executor to be registered");
+        }
+        const result = await codeExecutor.execute("code-mode-limit", {
+            code: [
+                "await tools.tool_search({ query: 'read' });",
+                "await tools.tool_search({ query: 'write' });",
+                "return 'unreachable';",
+            ].join("\n"),
+        });
+        (0, vitest_1.expect)(getText(result)).toBe("Error: code_executor exceeded max_tool_calls (1)");
+    });
+    (0, vitest_1.it)("does not allow code_executor invocations to raise configured limits", async () => {
+        const workspace = (0, node_fs_1.mkdtempSync)(path.join(os.tmpdir(), "agent-core-code-mode-limit-cap-"));
+        const codeExecutor = getToolDefinitions(workspace, {
+            programmaticToolCalling: { maxToolCalls: 1 },
+        }).find((tool) => tool.name === "code_executor");
+        if (!codeExecutor) {
+            throw new Error("Expected code_executor to be registered");
+        }
+        const result = await codeExecutor.execute("code-mode-limit-cap", {
+            max_tool_calls: 10,
+            code: [
+                "await tools.tool_search({ query: 'read' });",
+                "await tools.tool_search({ query: 'write' });",
+                "return 'unreachable';",
+            ].join("\n"),
+        });
+        (0, vitest_1.expect)(getText(result)).toBe("Error: code_executor exceeded max_tool_calls (1)");
+    });
     (0, vitest_1.it)("processes fetched html content and exposes helper exports directly", async () => {
         const workspace = (0, node_fs_1.mkdtempSync)(path.join(os.tmpdir(), "agent-core-web-"));
         const fetchMock = vitest_1.vi.fn(async () => ({

package/dist/types.d.ts

@@ -105,6 +105,18 @@ export interface AgentCoreToolOptions {
     /** Optional externally managed registry. When provided, the caller owns disposal. */
     backgroundRegistry?: BackgroundProcessRegistry;
     deferredToolRegistry?: DeferredToolRegistry;
+    /**
+     * Opt-in Programmatic Tool Calling / Code Mode surface. When enabled,
+     * agent-core exposes a single `code_executor` tool that can execute a
+     * JavaScript tool chain against the already configured agent-core tools.
+     */
+    programmaticToolCalling?: boolean | ProgrammaticToolCallingOptions;
+}
+export interface ProgrammaticToolCallingOptions {
+    /** Maximum wall-clock time for one code_executor invocation. Default: 120000. */
+    timeout?: number;
+    /** Maximum nested tool calls allowed from one code_executor invocation. Default: 25. */
+    maxToolCalls?: number;
 }
 export declare const AGENT_CORE_TOOL_NAMES: string[];
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -25,6 +25,7 @@ exports.AGENT_CORE_TOOL_NAMES = [
     "background_list",
     "tool_search",
     "tool_fetch",
+    "code_executor",
     "web_search",
     "fetch_process",
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5c-ai/agent-core",
-  "version": "5.0.1-staging.ee42097a6d34",
+  "version": "5.0.1-staging.ee474eb45",
   "description": "Built-in agent-core runtime and tool surface for Babysitter.",
   "license": "MIT",
   "type": "commonjs",
@@ -27,8 +27,8 @@
     "test": "vitest run --config vitest.config.ts"
   },
   "dependencies": {
-    "@a5c-ai/agent-mux": "5.0.1-staging.ee42097a6d34",
-    "@a5c-ai/babysitter-sdk": "5.0.1-staging.ee42097a6d34",
+    "@a5c-ai/agent-mux": "5.0.1-staging.ee474eb45",
+    "@a5c-ai/babysitter-sdk": "5.0.1-staging.ee474eb45",
     "@sinclair/typebox": "^0.34.48"
   },
   "devDependencies": {