@a5c-ai/agent-core 5.0.1-staging.ac4f12d9

package/README.md

@@ -0,0 +1,217 @@
+# @a5c-ai/agent-core
+
+Built-in programmatic session wrapper and agentic tool surface for Babysitter runtime consumers.
+
+<!-- docs-status:start -->
+> Status: Public advanced/runtime package.
+> Canonical docs home: [Package and Plugin Docs Map](../../docs/package-and-plugin-map.md).
+> This README defines the package contract for runtime consumers and published dependents such as `@a5c-ai/babysitter-agent`.
+<!-- docs-status:end -->
+
+## Package role
+
+`@a5c-ai/agent-core` sits between `@a5c-ai/babysitter-agent`, `@a5c-ai/agent-mux`, and `@a5c-ai/babysitter-sdk`:
+
+- `createAgentCoreSession()` wraps an `@a5c-ai/agent-mux` client for in-process prompt execution.
+- `createAgentCoreToolDefinitions()` assembles the built-in Babysitter-flavored tool surface that host runtimes can inject into planning, resume, or delegated-task flows.
+- `@a5c-ai/babysitter-agent` re-exports these APIs from `src/harness/index.ts`, uses `createAgentCoreSession()` for direct `agent-core` harness invocation in `src/harness/invoker.ts`, and injects tool definitions into plan-process and resume-run flows.
+- `@a5c-ai/babysitter-sdk` still owns run directories, journals, task/effect lifecycle, and config defaults. `agent-core` does not replace the SDK orchestration layer.
+
+This package is published as a runtime dependency surface for higher-level Babysitter runtimes. It is still an advanced/operator-facing building block rather than the primary entrypoint for new users.
+
+## Root exports
+
+The package root exports the runtime surface assembled from `src/index.ts` and `src/tools.ts`:
+
+```ts
+import {
+  AGENT_CORE_TOOL_NAMES,
+  AgentCoreSessionHandle,
+  DeferredToolRegistry,
+  createAgentCoreSession,
+  createAgentCoreToolDefinitions,
+  disposeAgentCoreToolDefinitions,
+  extractTextFromHtml,
+  filterByRelevance,
+  parseSearchResults,
+  resetRunScopedConfig,
+  stripHtmlTags,
+  type AgentCoreEventListener,
+  type AgentCorePromptResult,
+  type AgentCoreSessionEvent,
+  type AgentCoreSessionOptions,
+  type AgentCoreToolOptions,
+  type CustomToolDefinition,
+  type ToolResult,
+} from "@a5c-ai/agent-core";
+```
+
+Key exports:
+
+- `createAgentCoreSession(options)` / `AgentCoreSessionHandle`: programmatic session API backed by `@a5c-ai/agent-mux`.
+- `createAgentCoreToolDefinitions(options)` / `disposeAgentCoreToolDefinitions(definitions)`: built-in tool-definition assembly and teardown.
+- `DeferredToolRegistry`: lazy registry for searchable/fetchable external tool schemas.
+- `AGENT_CORE_TOOL_NAMES`: canonical bundled tool name list.
+- `AgenticToolOptions` and `AGENTIC_TOOL_NAMES`: compatibility aliases for older host integrations.
+- `resetRunScopedConfig()`: clears run-scoped state used by the `config` tool.
+- `parseSearchResults()`, `stripHtmlTags()`, `extractTextFromHtml()`, `filterByRelevance()`: helper exports used by web/search integrations.
+
+## Session API
+
+`createAgentCoreSession()` returns an `AgentCoreSessionHandle` that wraps a shared `@a5c-ai/agent-mux` client with built-in adapters registered once per process.
+
+Core handle methods:
+
+- `initialize()`: currently a no-op placeholder for compatibility.
+- `prompt(text, timeout?)`: starts a run, streams events to subscribers, and returns `{ output, duration, success, exitCode }`.
+- `steer(text)`: sends immediate steering text while a prompt is active, or queues it for the next prompt.
+- `followUp(text)`: queues a post-response follow-up when streaming, or appends it to the next prompt when idle.
+- `subscribe(listener)`: receives normalized `AgentCoreSessionEvent` payloads, including `session_start`.
+- `abort()`: aborts the active run if one is in progress.
+- `dispose()`: aborts the active run, clears listeners, and drops queued follow-ups.
+- `executeCommand()` / `executeBash()`: local shell helpers scoped to `options.workspace`.
+- `sessionId` / `isStreaming`: getters for the active continued session id and current streaming state.
+
+Session behavior that matters to host integrations:
+
+- Agent-core reuses the `sessionId` learned from prior runs, so later prompts continue the same agent-mux session when the backend supports it.
+- Concurrent `prompt()` calls on the same handle are rejected.
+- Event payloads are normalized before subscribers see them. Non-object payloads become `{ type: "unknown", value }`.
+- Approval mode is `prompt` only when `uiContext` is present; otherwise agent-core uses `yolo`.
+
+### Supported runtime options
+
+| Option | Runtime effect |
+| --- | --- |
+| `workspace` | Forwarded to agent-mux as `cwd`. |
+| `model` | Forwarded to agent-mux as `model`. |
+| `timeout` | Forwarded to agent-mux as `timeout`. |
+| `thinkingLevel` | Translated to agent-mux `thinkingEffort` (`minimal`/`low` -> `low`, `medium` -> `medium`, `high` -> `high`, `xhigh` -> `max`). |
+| `systemPrompt` | Used as the base `systemPrompt`. |
+| `appendSystemPrompt` | Appended to the final `systemPrompt` before dispatch. |
+| `uiContext` | Switches run approval mode to `prompt`; when omitted, agent-core uses `yolo`. |
+| `backend` | Selects the agent-mux adapter/backend forwarded as `agent`. |
+
+### Deprecated compatibility fields
+
+These fields remain on `AgentCoreSessionOptions` for compatibility, but the current runtime ignores them:
+
+| Option | Status | Migration note |
+| --- | --- | --- |
+| `toolsMode` | Deprecated, ignored by agent-core | Use backend-native configuration, or the PI wrapper in `@a5c-ai/babysitter-agent`, if you still need tool-surface control. |
+| `customTools` | Deprecated, ignored by agent-core | Register host-side tools with `createAgentCoreToolDefinitions()` or use the PI wrapper for runtime custom-tool injection. |
+| `isolated` | Deprecated, ignored by agent-core | Use the PI wrapper if you still need extension/skills isolation controls. |
+| `ephemeral` | Deprecated, ignored by agent-core | Session persistence is determined by the selected agent-mux backend. |
+| `bashSandbox` | Deprecated, ignored by agent-core | Sandbox behavior belongs to the selected backend. |
+| `enableCompaction` | Deprecated, ignored by agent-core | Compaction behavior belongs to the selected backend/runtime. |
+| `agentDir` | Deprecated, ignored by agent-core | Configure agent directories through the target backend instead. |
+
+If you still need the PI-era controls above, use the PI wrapper exposed from `@a5c-ai/babysitter-agent` rather than `@a5c-ai/agent-core`.
+
+## Tool-definition API
+
+`createAgentCoreToolDefinitions(options)` returns a wrapped `CustomToolDefinition[]` assembled from:
+
+- file-system tools: `read`, `write`, `edit`, `grep`, `find`
+- execution tools: `bash`, `python`, `ssh`, `fetch`
+- browser/config tools: `browser`, `config`
+- 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`
+
+`AgentCoreToolOptions` controls how those definitions are wired into a host runtime:
+
+- `workspace`: base directory for filesystem and execution tools.
+- `interactive`: gates interactive tool behavior.
+- `askUserQuestionHandler`, `taskHandler`, `skillHandler`: host-owned handlers for delegated tool calls.
+- `onToolUse`: observer callback fired after tool wrapping.
+- `onBackgroundComplete`, `maxBackgroundProcesses`, `backgroundRegistry`: background-process lifecycle hooks and limits.
+- `deferredToolRegistry`: enables `tool_search` and `tool_fetch`.
+
+### Interactive and cancellation contract
+
+- `interactive: false` disables `AskUserQuestion` even if `askUserQuestionHandler` is supplied. Both simple and structured calls return `Error: AskUserQuestion is unavailable when interactive=false.` and the handler is never invoked.
+- `CustomToolDefinition.execute()` does not receive a shared `AbortSignal`. Long-running tools must own their own timeout/cancellation behavior.
+- Synchronous throws and rejected promises are normalized into `Error: ...` tool results.
+- Timeout-driven aborts are normalized to `Error: Tool execution was cancelled.`
+
+### Background-task lifecycle caveats
+
+Background tasks are scoped to the returned tool-definition array, not to a module-global singleton.
+
+- `background_list` and `background_status` only expose tasks started by that same definition set.
+- `maxBackgroundProcesses` is enforced per scoped registry.
+- `disposeAgentCoreToolDefinitions(definitions)` kills still-running background tasks and clears retained stdout/stderr/task records for that definition set.
+- If you inject a custom `backgroundRegistry`, ownership moves to the caller and you must dispose it yourself.
+
+### Config tool state
+
+The `config` tool reads Babysitter defaults from `@a5c-ai/babysitter-sdk` and also supports run-scoped in-memory overrides plus selected global env-var writes.
+
+Call `resetRunScopedConfig()` between independent runs if your host process reuses the same agent-core module instance and you do not want config overrides to leak across runs.
+
+## DeferredToolRegistry API
+
+`DeferredToolRegistry` is the package's lazy schema registry for non-bundled tools.
+
+Typical flow:
+
+1. Register tier-1 entries with `registerTools()`.
+2. Register per-source loaders with `registerLoader()`.
+3. Use `tool_search` or `searchTools()` for lightweight discovery by name/description.
+4. Use `tool_fetch` or `fetchSchema()` to lazily load and cache a full schema.
+
+Useful methods:
+
+- `registerTools(entries)`
+- `registerLoader(source, loader)`
+- `getAllEntries()`
+- `getEntriesBySource(source, sourceQualifier?)`
+- `searchTools(query, maxResults?)`
+- `fetchSchema(toolName, source?, sourceQualifier?)`
+- `removeToolsBySource(source, sourceQualifier?)`
+- `clear()`
+- `size` / `loadedSchemaCount`
+
+Source disambiguation uses `(source, sourceQualifier, name)`, so duplicate tool names from different MCP servers or plugins can coexist safely.
+
+## Integration points
+
+Current downstream integration boundaries in this repo:
+
+- `@a5c-ai/babysitter-agent`
+  - re-exports the session/tool APIs from `src/harness/index.ts`
+  - uses `createAgentCoreSession()` for the direct `agent-core` harness path in `src/harness/invoker.ts`
+  - injects `createAgentCoreToolDefinitions()` into plan-process and delegated-task flows in `src/harness/internal/createRun/planProcess/*`
+  - uses both session and tool-definition APIs in `src/cli/commands/harness/resumeRun.ts` to inspect and resume existing runs
+- `@a5c-ai/agent-mux`
+  - provides the actual client, built-in adapters, session continuation, approval mode, and backend selection that agent-core forwards into
+- `@a5c-ai/babysitter-sdk`
+  - provides config defaults/env wiring used by the `config` tool and remains the owner of orchestration/run-state semantics outside this package
+
+In practice, use `agent-core` when you need an in-process runtime wrapper or bundled tool surface. Use `babysitter-agent` when you need the higher-level harness CLI/runtime entrypoints.
+
+## Build, test, and CI
+
+From the repo root:
+
+```bash
+npm run build --workspace=@a5c-ai/agent-core
+npm run test --workspace=@a5c-ai/agent-core
+```
+
+The package `build` script invokes the root `build:runtime:agent-core-deps` entrypoint before `tsc --build`, so fresh-checkout builds do not depend on prebuilt upstream `dist/` output.
+
+Package-local `test` runs `vitest` against:
+
+- `src/session.test.ts` for session option/event/continuation behavior
+- `src/tools.test.ts` for tool-surface behavior, background-task scoping, AskUserQuestion gating, and helper exports
+- `src/deferredToolRegistry.test.ts` for registry search, fetch, cache, and removal behavior
+
+For the shared runtime chain used by release-oriented workflows, run:
+
+```bash
+npm run build:runtime
+```
+
+Per [Workspace Validation Map](../../docs/workspace-validation.md), `packages/agent-core` is a public advanced/runtime package validated by `.github/workflows/ci.yml` job `test` and by the release/staging workflows. Keep README claims aligned with those validation paths rather than inventing package-specific CI jobs that do not exist.

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"}