@nuvin/agent-core 0.2.0-rc.1 → 0.2.0-rc.11

package/dist/tools/mcp/mcp-connection-generation.d.ts

@@ -0,0 +1,59 @@
+import type { MCPServerConfig } from "@nuvin/config";
+import type { AnyToolDefinition, ToolDefinitionLifecycle, ToolPermissionClass } from "../../shared/types.ts";
+import { type McpServerToolInfo, type McpToolClient, type McpToolDescriptor } from "./mcp-tool-adapter.ts";
+export interface McpTimeoutSource {
+    get(): number;
+    set(timeoutMs: number): void;
+}
+export declare function createMcpTimeoutSource(initialTimeoutMs: number): McpTimeoutSource;
+export declare function resolveMcpTimeoutMs(server: MCPServerConfig, defaultTimeoutMs: number | undefined): number;
+export type McpTerminalTransportError = {
+    readonly code: "mcp-transport-error";
+    readonly cause: unknown;
+};
+export interface ConnectedMcpClient extends McpToolClient {
+    listTools(options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        tools: McpToolDescriptor[];
+    }>;
+    onTerminalError?(listener: (event: McpTerminalTransportError) => void): () => void;
+    close(): Promise<void>;
+}
+export interface McpConnectionOptions {
+    signal?: AbortSignal;
+    oauth?: {
+        storageDir: string;
+        callbackUrl: string;
+        onRedirect(serverName: string, url: URL): void | Promise<void>;
+    };
+    timeoutSource?: McpTimeoutSource;
+}
+export type McpConnector = (serverName: string, config: MCPServerConfig, options?: McpConnectionOptions) => Promise<ConnectedMcpClient>;
+export interface McpConnectionGeneration {
+    readonly client: ConnectedMcpClient;
+    readonly descriptors: readonly McpToolDescriptor[];
+    readonly lifecycle: ToolDefinitionLifecycle;
+    projectTools(input: {
+        serverName: string;
+        prefix?: string;
+        allowedTools?: Record<string, boolean>;
+        toolPermissions?: Record<string, ToolPermissionClass>;
+    }): {
+        tools: AnyToolDefinition[];
+        descriptors: McpServerToolInfo[];
+    };
+    onTerminalError(listener: (event: McpTerminalTransportError) => void): () => void;
+    retire(): Promise<void>;
+}
+export declare function buildMcpHttpHeaders(config: MCPServerConfig): Record<string, string> | undefined;
+export declare function connectMcpServer(serverName: string, config: MCPServerConfig, options?: McpConnectionOptions): Promise<ConnectedMcpClient>;
+export declare function createMcpConnectionGeneration(input: {
+    serverName: string;
+    config: MCPServerConfig;
+    timeoutSource: McpTimeoutSource;
+    signal?: AbortSignal;
+    connection?: McpConnectionOptions;
+    connect?: McpConnector;
+}): Promise<McpConnectionGeneration>;
+//# sourceMappingURL=mcp-connection-generation.d.ts.map

package/dist/tools/mcp/mcp-safe-error-provenance.d.ts

@@ -0,0 +1,4 @@
+import { type McpSafeError, toMcpSafeError } from "./mcp-safe-error.ts";
+export declare function createOwnedMcpSafeError(input: Parameters<typeof toMcpSafeError>[0]): McpSafeError;
+export declare function extractOwnedMcpSafeError(error: unknown): McpSafeError | undefined;
+//# sourceMappingURL=mcp-safe-error-provenance.d.ts.map

package/dist/tools/mcp/mcp-safe-error.d.ts

@@ -0,0 +1,14 @@
+export type McpSafeErrorCode = "mcp-auth-required" | "mcp-close-failed" | "mcp-connect-failed" | "mcp-discovery-failed" | "mcp-request-timeout" | "mcp-tool-call-failed";
+export type McpSafeError = {
+    code: McpSafeErrorCode;
+    message: string;
+};
+type McpOperation = "close" | "connect" | "discover" | "toolCall";
+export declare function toMcpSafeError(input: {
+    serverName: string;
+    operation: McpOperation;
+    error: unknown;
+}): McpSafeError;
+export declare function redactMcpDiagnostic(text: string, secrets: readonly string[]): string;
+export {};
+//# sourceMappingURL=mcp-safe-error.d.ts.map

package/dist/tools/mcp/mcp-server-manager.d.ts

@@ -0,0 +1,16 @@
+export type { ConnectedMcpClient, McpConnectionOptions, McpConnector, } from "./mcp-connection-generation.ts";
+export { buildMcpHttpHeaders, connectMcpServer, } from "./mcp-connection-generation.ts";
+export type { McpServerToolInfo } from "./mcp-tool-adapter.ts";
+export type McpServerConnectionStatus = {
+    status: "connected";
+    toolCount: number;
+} | {
+    status: "disabled";
+} | {
+    status: "authRequired";
+    message: string;
+} | {
+    status: "error";
+    message: string;
+};
+//# sourceMappingURL=mcp-server-manager.d.ts.map

package/dist/tools/mcp/mcp-tool-adapter.d.ts

@@ -0,0 +1,72 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AnyToolDefinition, JsonObject, JsonSchema, JsonSchemaObject, JsonValue, ToolDefinitionLifecycle, ToolPermissionClass } from "../../shared/types.ts";
+export interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+    annotations?: {
+        readOnlyHint?: unknown;
+    };
+}
+export interface McpToolClient {
+    callTool(input: {
+        name: string;
+        arguments?: JsonObject;
+    }): Promise<CallToolResult>;
+}
+export interface McpServerToolInfo {
+    name: string;
+    description?: string;
+    inputSchema?: JsonValue;
+    permissionClass: ToolPermissionClass;
+    permissionConfigured: boolean;
+    suggestedPermissionClass?: "read" | "write";
+}
+export declare function projectMcpTools(input: {
+    serverName: string;
+    prefix?: string;
+    descriptors: readonly McpToolDescriptor[];
+    client: McpToolClient;
+    lifecycle: ToolDefinitionLifecycle;
+    allowedTools?: Record<string, boolean>;
+    toolPermissions?: Record<string, ToolPermissionClass>;
+}): {
+    tools: AnyToolDefinition[];
+    descriptors: McpServerToolInfo[];
+};
+export declare function createMcpToolName(serverName: string, toolName: string): string;
+export declare function toNuvinToolSchema(inputSchema: unknown): JsonSchemaObject;
+export declare function createMcpTool(options: {
+    serverName: string;
+    tool: McpToolDescriptor;
+    client: McpToolClient;
+    permissionClass: ToolPermissionClass;
+    internalLifecycle?: ToolDefinitionLifecycle;
+}): import("../../shared/types.ts").ToolDefinition<{
+    [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | {
+        [x: string]: JsonValue | /*elided*/ any | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | (JsonValue | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    };
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, JsonSchemaObject<Record<string, JsonSchema>, readonly string[] | undefined>>;
+//# sourceMappingURL=mcp-tool-adapter.d.ts.map

package/dist/tools/{glob-tool.d.ts → search/glob-tool.d.ts}

@@ -4,11 +4,11 @@ export interface GlobToolOptions {
     limit?: number;
     name?: string;
 }
-export declare function createGlobTool(options?: GlobToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createGlobTool(options?: GlobToolOptions): import("../../shared/types.ts").ToolDefinition<{
     pattern: string;
     path?: string | undefined;
     limit?: number | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         pattern: {

package/dist/tools/search/grep-engine.d.ts

@@ -0,0 +1,22 @@
+import * as Ripgrep from "./ripgrep.ts";
+export declare const GREP_DEFAULT_LIMIT = 100;
+export declare const GREP_MAX_PATTERN_LENGTH = 1024;
+export declare const GREP_MAX_SNIPPET_LENGTH = 2000;
+export interface RegexSearchOptions {
+    cwd: string;
+    pattern: string;
+    files?: readonly string[];
+    glob?: string;
+    context?: number;
+    limit?: number;
+}
+export interface RegexSearchResult {
+    matches: Ripgrep.RipgrepMatch[];
+    matchCount: number;
+    fileCount: number;
+    truncated: boolean;
+}
+export declare function validateGrepPattern(pattern: string): void;
+export declare function boundedGrepSnippet(line: string): string;
+export declare function searchRegex(options: RegexSearchOptions): Promise<RegexSearchResult>;
+//# sourceMappingURL=grep-engine.d.ts.map

package/dist/tools/{grep-tool.d.ts → search/grep-tool.d.ts}

@@ -4,13 +4,13 @@ export interface GrepToolOptions {
     limit?: number;
     name?: string;
 }
-export declare function createGrepTool(options?: GrepToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createGrepTool(options?: GrepToolOptions): import("../../shared/types.ts").ToolDefinition<{
     pattern: string;
     include?: string | undefined;
     path?: string | undefined;
-    limit?: number | undefined;
     context?: number | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    limit?: number | undefined;
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         pattern: {

package/dist/tools/{ls-tool.d.ts → search/ls-tool.d.ts}

@@ -3,10 +3,10 @@ export interface LsToolOptions {
     defaultCwd?: string;
     name?: string;
 }
-export declare function createLsTool(options?: LsToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createLsTool(options?: LsToolOptions): import("../../shared/types.ts").ToolDefinition<{
     path: string;
     limit: number;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         path: {

package/dist/tools/{ripgrep.d.ts → search/ripgrep.d.ts}

@@ -13,6 +13,7 @@ export declare function search(opts: {
     context?: number;
     cwd: string;
     file?: string;
+    files?: readonly string[];
     glob?: string;
     limit?: number;
     pattern: string;

package/dist/tools/{view-file-tool.d.ts → search/view-file-tool.d.ts}

@@ -4,10 +4,10 @@ export interface ViewFileToolOptions {
     maxBytes?: number;
     name?: string;
 }
-export declare function createViewFileTool(options?: ViewFileToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createViewFileTool(options?: ViewFileToolOptions): import("../../shared/types.ts").ToolDefinition<{
     path: string;
     detail?: string | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         path: {

package/dist/tools/{ask-user-tool.d.ts → session/ask-user-tool.d.ts}

@@ -1,4 +1,4 @@
-export declare function createAskUserTool(): import("../shared/types.ts").ToolDefinition<{
+export declare function createAskUserTool(): import("../../shared/types.ts").ToolDefinition<{
     answers: {};
     questions: {
         question: string;
@@ -9,7 +9,7 @@ export declare function createAskUserTool(): import("../shared/types.ts").ToolDe
         }[];
         multiSelect: boolean;
     }[];
-}, import("../shared/types.ts").ToolOutputEnvelope, import("../shared/types.ts").ToolOutputEnvelope | undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, import("../../shared/types.ts").ToolOutputEnvelope | undefined, {
     type: "object";
     properties: {
         questions: {

package/dist/tools/{lsp-tool.d.ts → session/lsp-tool.d.ts}

@@ -1,17 +1,17 @@
-import type { LspService } from "../lsp/index.ts";
+import type { LspService } from "../../lsp/index.ts";
 export interface LspToolOptions {
     defaultCwd?: string;
     allowedDirs?: readonly string[];
     lspService?: LspService;
     name?: string;
 }
-export declare function createLspTool(options?: LspToolOptions): import("../shared/types.ts").ToolDefinition<{
-    filePath: string;
+export declare function createLspTool(options?: LspToolOptions): import("../../shared/types.ts").ToolDefinition<{
     line: number;
-    character: number;
     operation: string;
+    filePath: string;
+    character: number;
     query?: string | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         operation: {

package/dist/tools/{skill-tool.d.ts → session/skill-tool.d.ts}

@@ -19,9 +19,9 @@ export interface SkillToolOptions<TRef extends SkillReference = SkillReference>
     skills: TRef[];
     loadSkill: (reference: TRef) => Promise<LoadedSkill>;
 }
-export declare function createLoadSkillTool<TRef extends SkillReference>(options: SkillToolOptions<TRef>): import("../shared/types.ts").ToolDefinition<{
+export declare function createLoadSkillTool<TRef extends SkillReference>(options: SkillToolOptions<TRef>): import("../../shared/types.ts").ToolDefinition<{
     name: string;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         name: {

package/dist/tools/{todo-write-tool.d.ts → session/todo-write-tool.d.ts}

@@ -24,7 +24,7 @@ declare class TodoStore {
     setTodos(sessionId: string, todos: TodoItem[]): void;
     getStats(sessionId: string): TodoStats;
 }
-export declare function createTodoWriteTool(store?: TodoStore): import("../shared/types.ts").ToolDefinition<{
+export declare function createTodoWriteTool(store?: TodoStore): import("../../shared/types.ts").ToolDefinition<{
     todos: {
         id: string;
         content: string;
@@ -32,7 +32,7 @@ export declare function createTodoWriteTool(store?: TodoStore): import("../share
         priority: string;
         createdAt: string;
     }[];
-}, never, import("../shared/types.ts").ToolOutputEnvelope, {
+}, never, import("../../shared/types.ts").ToolOutputEnvelope, {
     type: "object";
     properties: {
         todos: {

package/dist/tools/session/update-topic-tool.d.ts

@@ -0,0 +1,12 @@
+export declare function createUpdateTopicTool(): import("../../shared/types.ts").ToolDefinition<{
+    topic: string;
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
+    readonly type: "object";
+    readonly properties: {
+        readonly topic: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["topic"];
+}>;
+//# sourceMappingURL=update-topic-tool.d.ts.map

package/dist/tools/shell/background-process-registry.d.ts

@@ -0,0 +1,116 @@
+import type { ChildProcess } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { type ProcessTreeSignalAdapter } from "./process-tree-termination.ts";
+import { type TerminalOutputNormalizer } from "./terminal-output-normalizer.ts";
+export type BackgroundProcessStatus = "running" | "terminating" | "exited" | "killed" | "error";
+export interface BackgroundProcessReservation {
+    readonly id: string;
+}
+export interface BackgroundProcessTerminationResult {
+    shellId: string;
+    outcome: "killed" | "already-terminal" | "failed";
+    status: BackgroundProcessStatus;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    error: string | null;
+    gracefulRequested: boolean;
+    forceRequested: boolean;
+}
+export interface BackgroundProcessEntry {
+    shellId: string;
+    command: string;
+    cwd: string;
+    pid: number | undefined;
+    processGroupId: number | undefined;
+    status: BackgroundProcessStatus;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    startedAt: number;
+    error: string | null;
+    gracefulRequested: boolean;
+    forceRequested: boolean;
+    child: ChildProcess | null;
+    buffer: string[];
+    bufferChars: number;
+    totalProduced: number;
+    totalDropped: number;
+    readCursor: number;
+    stdoutDecoder: StringDecoder;
+    stderrDecoder: StringDecoder;
+    stdoutNormalizer: TerminalOutputNormalizer;
+    stderrNormalizer: TerminalOutputNormalizer;
+    stripAnsi: boolean;
+    killRequested: boolean;
+    processExited: boolean;
+    streamsFlushed: boolean;
+    terminalSettled: boolean;
+    terminalPromise: Promise<void>;
+    resolveTerminal: () => void;
+    terminationPromise?: Promise<BackgroundProcessTerminationResult>;
+    terminationSettled: boolean;
+}
+export interface BackgroundProcessReadResult {
+    output: string;
+    status: BackgroundProcessStatus;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    error: string | null;
+    truncated: boolean;
+}
+export interface BackgroundProcessRegistryOptions {
+    maxConcurrent?: number;
+    maxEntries?: number;
+    capChars?: number;
+    platform?: NodeJS.Platform;
+    signalAdapter?: ProcessTreeSignalAdapter;
+}
+export declare class BackgroundProcessCleanupError extends Error {
+    readonly results: BackgroundProcessTerminationResult[];
+    constructor(results: BackgroundProcessTerminationResult[]);
+}
+export declare function isTerminalStatus(status: BackgroundProcessStatus): boolean;
+export declare class BackgroundProcessRegistry {
+    private readonly entries;
+    private readonly reservations;
+    private readonly maxConcurrent;
+    private readonly maxEntries;
+    private readonly capChars;
+    private readonly platform;
+    private readonly signalAdapter;
+    private counter;
+    constructor(opts?: BackgroundProcessRegistryOptions);
+    reserve(): BackgroundProcessReservation;
+    release(reservation: BackgroundProcessReservation): void;
+    attach(reservation: BackgroundProcessReservation, opts: {
+        child: ChildProcess;
+        command: string;
+        cwd: string;
+        stripAnsi: boolean;
+        processGroupId?: number;
+    }): BackgroundProcessEntry;
+    /** Compatibility adapter for callers being migrated to reserve/attach. */
+    spawn(opts: {
+        child: ChildProcess;
+        command: string;
+        cwd: string;
+        stripAnsi: boolean;
+    }): BackgroundProcessEntry;
+    read(shellId: string, opts?: {
+        regex?: string;
+    }): BackgroundProcessReadResult;
+    list(): BackgroundProcessEntry[];
+    kill(shellId: string): Promise<BackgroundProcessTerminationResult>;
+    closeAll(): Promise<BackgroundProcessTerminationResult[]>;
+    reset(): Promise<BackgroundProcessTerminationResult[]>;
+    private terminate;
+    private confirmed;
+    private failed;
+    private result;
+    private waitForTerminal;
+    private appendDecoded;
+    private settleTerminal;
+    private flushStreams;
+    private append;
+    private evictIfNeeded;
+}
+//# sourceMappingURL=background-process-registry.d.ts.map

package/dist/tools/{bash-output-tool.d.ts → shell/bash-output-tool.d.ts}

@@ -2,10 +2,10 @@ import type { BackgroundProcessRegistry } from "./background-process-registry.ts
 export interface BashOutputToolOptions {
     registry: BackgroundProcessRegistry;
 }
-export declare function createBashOutputTool(options: BashOutputToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createBashOutputTool(options: BashOutputToolOptions): import("../../shared/types.ts").ToolDefinition<{
     shellId: string;
     regex?: string | undefined;
-}, never, import("../shared/types.ts").ToolOutputEnvelope, {
+}, never, import("../../shared/types.ts").ToolOutputEnvelope, {
     type: "object";
     properties: {
         shellId: {

package/dist/tools/{bash-tool.d.ts → shell/bash-tool.d.ts}

@@ -1,3 +1,4 @@
+import type { BashExecutionTarget, ToolExecutionContext } from "../../shared/types.ts";
 import type { BackgroundProcessRegistry } from "./background-process-registry.ts";
 export interface BashToolInput {
     command: string;
@@ -18,17 +19,20 @@ export interface BashToolOptions {
     shellPath?: string;
     stripAnsi?: boolean;
     scrubEnvKeys?: readonly string[];
+    scrubEnvPrefixes?: readonly string[];
     backgroundRegistry?: BackgroundProcessRegistry;
+    verifyExecution?: (target: BashExecutionTarget, authorization: unknown, ctx: ToolExecutionContext) => Promise<void> | void;
 }
-export declare function createBashTool(options?: BashToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function resolveBashExecutionTarget(input: Pick<BashToolInput, "command" | "cwd" | "runInBackground">, options?: Pick<BashToolOptions, "allowedDirs" | "defaultCwd" | "shellPath">): BashExecutionTarget;
+export declare function createBashTool(options?: BashToolOptions): import("../../shared/types.ts").ToolDefinition<{
     description: string;
     command: string;
     timeoutMs?: number | undefined;
     cwd?: string | undefined;
+    runInBackground?: boolean | undefined;
     ignoreOutput?: boolean | undefined;
     outputRegex?: string | undefined;
-    runInBackground?: boolean | undefined;
-}, string, import("../shared/types.ts").ToolOutputEnvelope, {
+}, string, import("../../shared/types.ts").ToolOutputEnvelope, {
     type: "object";
     properties: {
         command: {
@@ -57,15 +61,15 @@ export declare function createBashTool(options?: BashToolOptions): import("../sh
     };
     required: readonly ["command", "description"];
 }>;
-export declare function createShellExecTool(options?: BashToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createShellExecTool(options?: BashToolOptions): import("../../shared/types.ts").ToolDefinition<{
     description: string;
     command: string;
     timeoutMs?: number | undefined;
     cwd?: string | undefined;
+    runInBackground?: boolean | undefined;
     ignoreOutput?: boolean | undefined;
     outputRegex?: string | undefined;
-    runInBackground?: boolean | undefined;
-}, string, import("../shared/types.ts").ToolOutputEnvelope, {
+}, string, import("../../shared/types.ts").ToolOutputEnvelope, {
     type: "object";
     properties: {
         command: {

package/dist/tools/{command-tool.d.ts → shell/command-tool.d.ts}

@@ -5,10 +5,10 @@ export interface CommandToolOptions<TRef extends CommandReference = CommandRefer
     commands: TRef[];
     loadCommand: (reference: TRef) => Promise<LoadedCommand>;
 }
-export declare function createInvokeCommandTool<TRef extends CommandReference>(options: CommandToolOptions<TRef>): import("../shared/types.ts").ToolDefinition<{
+export declare function createInvokeCommandTool<TRef extends CommandReference>(options: CommandToolOptions<TRef>): import("../../shared/types.ts").ToolDefinition<{
     name: string;
     args?: string | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         name: {

package/dist/tools/{kill-shell-tool.d.ts → shell/kill-shell-tool.d.ts}

@@ -2,9 +2,9 @@ import type { BackgroundProcessRegistry } from "./background-process-registry.ts
 export interface KillShellToolOptions {
     registry: BackgroundProcessRegistry;
 }
-export declare function createKillShellTool(options: KillShellToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createKillShellTool(options: KillShellToolOptions): import("../../shared/types.ts").ToolDefinition<{
     shellId: string;
-}, never, import("../shared/types.ts").ToolOutputEnvelope, {
+}, never, import("../../shared/types.ts").ToolOutputEnvelope, {
     type: "object";
     properties: {
         shellId: {

package/dist/tools/shell/process-tree-termination.d.ts

@@ -0,0 +1,25 @@
+import { spawn as nodeSpawn } from "node:child_process";
+export type ProcessTreeTerminationPhase = "graceful" | "force";
+export interface ProcessTreeTarget {
+    rootPid: number | undefined;
+    processGroupId: number | undefined;
+}
+export type ProcessTreeSignalResult = {
+    outcome: "delivered";
+} | {
+    outcome: "not-found";
+    error: string;
+} | {
+    outcome: "failed";
+    error: string;
+};
+export interface ProcessTreeSignalAdapter {
+    signal(target: ProcessTreeTarget, phase: ProcessTreeTerminationPhase): Promise<ProcessTreeSignalResult>;
+}
+export interface ProcessTreeSignalAdapterOptions {
+    platform?: NodeJS.Platform;
+    kill?: typeof process.kill;
+    spawn?: typeof nodeSpawn;
+}
+export declare function createProcessTreeSignalAdapter(options?: ProcessTreeSignalAdapterOptions): ProcessTreeSignalAdapter;
+//# sourceMappingURL=process-tree-termination.d.ts.map

package/dist/tools/shell/terminal-output-normalizer.d.ts

@@ -0,0 +1,6 @@
+export interface TerminalOutputNormalizer {
+    write(decoded: string): string;
+    end(): string;
+}
+export declare function createTerminalOutputNormalizer(): TerminalOutputNormalizer;
+//# sourceMappingURL=terminal-output-normalizer.d.ts.map

package/dist/tools/{web-fetch-tool.d.ts → web/web-fetch-tool.d.ts}

@@ -5,10 +5,10 @@ export interface WebFetchToolOptions {
     /** DNS resolver used by the SSRF guard. Injectable for tests. */
     lookup?: SafeFetchLookup;
 }
-export declare function createWebFetchTool(options?: WebFetchToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createWebFetchTool(options?: WebFetchToolOptions): import("../../shared/types.ts").ToolDefinition<{
     url: string;
     description?: string | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         description: {

package/dist/tools/{web-search-tool.d.ts → web/web-search-tool.d.ts}

@@ -18,7 +18,7 @@ export interface WebSearchToolOptions {
     /** DNS resolver used by the SSRF guard when hydrating result pages. Injectable for tests. */
     lookup?: SafeFetchLookup;
 }
-export declare function createWebSearchTool(options: WebSearchToolOptions): import("../shared/types.ts").ToolDefinition<{
+export declare function createWebSearchTool(options: WebSearchToolOptions): import("../../shared/types.ts").ToolDefinition<{
     query: string;
     type?: string | undefined;
     description?: string | undefined;
@@ -30,7 +30,7 @@ export declare function createWebSearchTool(options: WebSearchToolOptions): impo
     lang?: string | undefined;
     region?: string | undefined;
     hydrateMeta?: boolean | undefined;
-}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+}, import("../../shared/types.ts").ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
         description: {