@a5c-ai/genty-core 5.1.1-staging.5e92128884d3

package/README.md

@@ -0,0 +1,306 @@
+# @a5c-ai/genty-core
+
+genty core 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/genty-platform`.
+<!-- docs-status:end -->
+
+## Package role
+
+`@a5c-ai/genty-core` sits between `@a5c-ai/genty-platform`, `@a5c-ai/adapters`, and `@a5c-ai/babysitter-sdk`:
+
+- `createAgentCoreSession()` wraps an `@a5c-ai/adapters` 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/genty-platform` re-exports these APIs from `src/harness/index.ts`, uses `createAgentCoreSession()` for direct `genty-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. `genty-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 AgentCoreImageBase64PromptPart,
+  type AgentCoreImageUrlPromptPart,
+  type AgentCoreJsonSchema,
+  type AgentCoreOutputFormat,
+  type AgentCorePromptInput,
+  type AgentCorePromptOptions,
+  type AgentCorePromptPart,
+  type AgentCorePromptResult,
+  type AgentCoreSessionEvent,
+  type AgentCoreSessionOptions,
+  type AgentCoreStructuredOutputOptions,
+  type AgentCoreTextPromptPart,
+  type AgentCoreToolOptions,
+  type CustomToolDefinition,
+  type ToolResult,
+} from "@a5c-ai/genty-core";
+```
+
+Key exports:
+
+- `createAgentCoreSession(options)` / `AgentCoreSessionHandle`: programmatic session API backed by `@a5c-ai/adapters`.
+- `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/adapters` 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 }`.
+- `prompt(input, options?)`: accepts text or multimodal prompt parts and optional structured-output settings.
+- `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.
+- `getHistory()`: returns a defensive copy of persisted user/assistant turns for the session handle.
+- `clearHistory()`: clears persisted user/assistant turns without changing listeners, options, or the current session id.
+- `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 adapters session when the backend supports it.
+- Agent-core also keeps successful user/assistant turns on the session handle and includes bounded prior history in later direct provider prompts. System prompts are rebuilt from options for each request and are not stored in mutable history.
+- Failed prompts, timed-out requests, aborted requests, and malformed streams do not append partial assistant output to history.
+- 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 genty-core uses `yolo`.
+
+### Supported runtime options
+
+| Option | Runtime effect |
+| --- | --- |
+| `workspace` | Forwarded to adapters as `cwd`. |
+| `model` | Forwarded to adapters as `model`. |
+| `timeout` | Forwarded to adapters as `timeout`. |
+| `maxHistoryTurns` | Maximum persisted user/assistant history entries retained on the session handle. Defaults to 20. |
+| `maxHistoryTokens` | Maximum estimated tokens from prior history sent with a prompt. Uses the package's provider/model-aware rough token estimator and drops oldest entries first. |
+| `thinkingLevel` | Translated to adapters `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, genty-core uses `yolo`. |
+| `backend` | Selects the adapters adapter/backend forwarded as `agent`. |
+| `outputFormat` | Optional structured-output mode: `text`, `json_object`, or `json_schema`. |
+| `outputSchema` | JSON Schema used when `outputFormat` is `json_schema`. |
+| `outputSchemaName` | Provider-visible schema name. Defaults to `agent_core_response`. |
+| `outputSchemaStrict` | Provider strictness flag for schema-capable APIs. Defaults to `true` for `json_schema`. |
+
+### Structured Output
+
+Structured output is opt-in. Plain `prompt(text, timeout?)` remains the default and returns only the text output fields used by existing callers.
+
+```ts
+const session = createAgentCoreSession({
+  model: "gpt-5.5",
+  outputFormat: "json_schema",
+  outputSchemaName: "answer_payload",
+  outputSchema: {
+    type: "object",
+    required: ["answer"],
+    properties: {
+      answer: { type: "string" },
+    },
+  },
+});
+
+const result = await session.prompt<{ answer: string }>("Answer as JSON");
+if (result.success) {
+  console.log(result.parsed?.answer);
+} else {
+  console.error(result.validationError ?? result.output);
+}
+```
+
+OpenAI-compatible and Azure endpoints receive `response_format` with either `{ type: "json_object" }` or a `json_schema` payload. Anthropic does not expose the same response-format field through this direct Messages API path, so genty-core injects a system instruction that requires JSON-only output and still parses/validates the returned text locally.
+
+`json_object` requires the model to return a JSON object. `json_schema` requires `outputSchema` and validates the parsed object for common JSON Schema constraints used by this package contract (`type`, `required`, `properties`, `items`, and `enum`). Parse or schema failures return `success: false`, `exitCode: 1`, the raw `output`, and `validationError`.
+
+Prompt-level options can override session defaults:
+
+```ts
+const result = await session.prompt<{ ok: boolean }>("Return status", {
+  outputFormat: "json_object",
+});
+```
+
+### Multimodal Input
+
+`prompt()` accepts an array of prompt parts for text plus image URL/base64 input:
+
+```ts
+await session.prompt([
+  { type: "text", text: "Describe the relevant details in these images." },
+  { type: "image_url", imageUrl: "https://example.com/screenshot.png" },
+  { type: "image_base64", mediaType: "image/png", data: rawBase64Png },
+]);
+```
+
+OpenAI-compatible and Azure endpoints receive Chat Completions content parts using `text` and `image_url`. Base64 images are converted to `data:<mediaType>;base64,...` URLs for those providers. Anthropic receives Messages API content blocks with `image` sources using either `url` or `base64`.
+
+Agent-core validates image URLs before dispatch (`http`/`https` only), requires `image/*` media types for base64 images, rejects data URLs in the base64 field, and caps raw base64 image payloads at 20 MiB. Image-bearing `ToolResult` support remains owned by #588; this API only covers direct session prompt input.
+
+### Deprecated compatibility fields
+
+These fields remain on `AgentCoreSessionOptions` for compatibility, but the current runtime ignores them:
+
+| Option | Status | Migration note |
+| --- | --- | --- |
+| `toolsMode` | Deprecated, ignored by genty-core | Use backend-native configuration, or the PI wrapper in `@a5c-ai/genty-platform`, if you still need tool-surface control. |
+| `customTools` | Deprecated, ignored by genty-core | Register host-side tools with `createAgentCoreToolDefinitions()` or use the PI wrapper for runtime custom-tool injection. |
+| `isolated` | Deprecated, ignored by genty-core | Use the PI wrapper if you still need extension/skills isolation controls. |
+| `ephemeral` | Deprecated, ignored by genty-core | Session persistence is determined by the selected adapters backend. |
+| `bashSandbox` | Deprecated, ignored by genty-core | Sandbox behavior belongs to the selected backend. |
+| `enableCompaction` | Deprecated, ignored by genty-core | Compaction behavior belongs to the selected backend/runtime. |
+| `agentDir` | Deprecated, ignored by genty-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/genty-platform` rather than `@a5c-ai/genty-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`
+- optional programmatic tool calling: `code_executor` when `programmaticToolCalling` is enabled
+
+The `calc` tool evaluates a constrained arithmetic language only: numeric literals, parentheses, unary `+`/`-`, and `+`, `-`, `*`, `/`, `%`, and `**`. It rejects identifiers, function calls, property access, assignment, malformed expressions, overlong input, and non-finite results. It does not use `eval`, `Function`, shell execution, or external processes.
+
+`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`.
+- `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 genty-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
+
+- `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 genty-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/genty-platform`
+  - re-exports the session/tool APIs from `src/harness/index.ts`
+  - uses `createAgentCoreSession()` for the direct `genty-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/adapters`
+  - provides the actual client, built-in adapters, session continuation, approval mode, and backend selection that genty-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 `genty-core` when you need an in-process runtime wrapper or bundled tool surface. Use `agent-platform` 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/genty-core
+npm run test --workspace=@a5c-ai/genty-core
+```
+
+The package `build` script invokes the root `build:runtime:genty-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/genty/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,7 @@
+/**
+ * Backwards-compatibility shim -- the canonical implementation now lives in
+ * `@a5c-ai/genty-runtime`.  This re-export keeps internal agent-core consumers
+ * working without changes.
+ */
+export { getBackgroundRegistry, disposeBackgroundRegistry, } from "@a5c-ai/genty-runtime";
+//# 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;;;;GAIG;AACH,OAAO,EACL,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAC"}

package/dist/agenticTools/background/state.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disposeBackgroundRegistry = exports.getBackgroundRegistry = void 0;
+/**
+ * Backwards-compatibility shim -- the canonical implementation now lives in
+ * `@a5c-ai/genty-runtime`.  This re-export keeps internal agent-core consumers
+ * working without changes.
+ */
+var genty_runtime_1 = require("@a5c-ai/genty-runtime");
+Object.defineProperty(exports, "getBackgroundRegistry", { enumerable: true, get: function () { return genty_runtime_1.getBackgroundRegistry; } });
+Object.defineProperty(exports, "disposeBackgroundRegistry", { enumerable: true, get: function () { return genty_runtime_1.disposeBackgroundRegistry; } });

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 (error) {
+                return (0, results_1.errorResult)(`puppeteer import failed: ${error instanceof Error ? error.message : String(error)}. Install 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 const resetRunScopedConfig: () => void;
+export declare const isValidConfigKey: (key: string) => boolean;
+export declare const validateConfigValue: (key: string, value: unknown) => string | null;
+export declare const getConfigValue: (key: string) => unknown;
+export declare const getConfigDefault: (key: string) => unknown;
+export declare const listConfigKeys: () => string[];
+export declare const getRunScopedConfigEntries: () => IterableIterator<[string, unknown]>;
+export declare const setConfigValue: (key: string, value: unknown, scope: string) => void;
+export declare const 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":"AA+BA,eAAO,MAAM,oBAAoB,YAA6B,CAAC;AAC/D,eAAO,MAAM,gBAAgB,0BAAyB,CAAC;AACvD,eAAO,MAAM,mBAAmB,gDAA4B,CAAC;AAC7D,eAAO,MAAM,cAAc,0BAAuB,CAAC;AACnD,eAAO,MAAM,gBAAgB,0BAAyB,CAAC;AACvD,eAAO,MAAM,cAAc,gBAAuB,CAAC;AACnD,eAAO,MAAM,yBAAyB,2CAAkC,CAAC;AACzE,eAAO,MAAM,cAAc,sDAAuB,CAAC;AACnD,eAAO,MAAM,gBAAgB,wBAAyB,CAAC"}

package/dist/agenticTools/config/state.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetConfigValue = exports.setConfigValue = exports.getRunScopedConfigEntries = exports.listConfigKeys = exports.getConfigDefault = exports.getConfigValue = exports.validateConfigValue = exports.isValidConfigKey = exports.resetRunScopedConfig = void 0;
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const EXTENDED_CONFIG_KEYS = new Set([
+    "model",
+    "provider",
+    "breakpoint.autoApproveAfterN",
+    "breakpoint.presentAlwaysApprove",
+]);
+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 state = (0, babysitter_sdk_1.createScopedRuntimeConfigState)({
+    configKeyTypes: CONFIG_KEY_TYPES,
+    extendedConfigKeys: EXTENDED_CONFIG_KEYS,
+});
+exports.resetRunScopedConfig = state.resetRunScopedConfig;
+exports.isValidConfigKey = state.isValidConfigKey;
+exports.validateConfigValue = state.validateConfigValue;
+exports.getConfigValue = state.getConfigValue;
+exports.getConfigDefault = state.getConfigDefault;
+exports.listConfigKeys = state.listConfigKeys;
+exports.getRunScopedConfigEntries = state.getRunScopedConfigEntries;
+exports.setConfigValue = state.setConfigValue;
+exports.resetConfigValue = state.resetConfigValue;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.test.d.ts","sourceRoot":"","sources":["../../../src/agenticTools/config/state.test.ts"],"names":[],"mappings":""}

package/dist/agenticTools/config/state.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const state_1 = require("./state");
+(0, vitest_1.describe)("agent-core config state", () => {
+    (0, vitest_1.it)("does not write global config scope into process.env", () => {
+        const previous = process.env.BABYSITTER_LOG_LEVEL;
+        delete process.env.BABYSITTER_LOG_LEVEL;
+        try {
+            (0, state_1.resetConfigValue)();
+            (0, state_1.setConfigValue)("logLevel", "debug", "global");
+            (0, vitest_1.expect)(process.env.BABYSITTER_LOG_LEVEL).toBeUndefined();
+            (0, vitest_1.expect)((0, state_1.getConfigValue)("logLevel")).toBe("debug");
+        }
+        finally {
+            (0, state_1.resetConfigValue)();
+            if (previous === undefined)
+                delete process.env.BABYSITTER_LOG_LEVEL;
+            else
+                process.env.BABYSITTER_LOG_LEVEL = previous;
+        }
+    });
+});

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) or 'global' process-scoped config",
+            })),
+        }),
+        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,CA4ExF"}