@nuvin/agent-core 0.0.0-rc.0 → 0.0.0-rc.10

package/dist/tools/index.d.ts

@@ -1,4 +1,94 @@
-import { aZ as ToolDefinition, aq as ToolOutputEnvelope, a_ as AnyToolDefinition, aT as ToolRuntimeEventHandler, aS as ToolRuntimeToolCallHandler, aV as ToolRuntime, b8 as AgentDefinitionFactoryContext, A as AgentOptions, aX as ToolOutputValue, ap as ToolResultChunk, H as JsonObject, V as JsonSchemaObject, aW as InferJsonSchema, av as ToolExecutionContext, af as ToolSchema, I as JsonValue } from '../types-BueDJWnx.js';
+import { Diagnostic, Location, Hover, DocumentSymbol, SymbolInformation, CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from 'vscode-languageserver-types';
+import { b8 as ToolDefinition, ax as ToolOutputEnvelope, b9 as AnyToolDefinition, b2 as ToolRuntimeEventHandler, b1 as ToolRuntimeToolCallHandler, b4 as ToolRuntime, K as JsonObject, X as JsonSchemaObject, Y as JsonSchema, bk as AgentDefinitionFactoryContext, a as AgentOptions, q as ToolResult, b6 as ToolOutputValue, aw as ToolResultChunk, a0 as ToolResultContent, b5 as InferJsonSchema, aG as ToolExecutionContext, al as ToolSchema, L as JsonValue } from '../types-Df0vlfj-.js';
+import { CommandDefinitionReference, SerializedCommandDefinition, MCPAuthConfig, MCPServerConfig } from '@nuvin/config';
+import { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import { CallToolResult, ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
+
+interface LspPosition {
+    file: string;
+    line: number;
+    character: number;
+}
+interface LspServiceConfig {
+    enabled?: boolean;
+}
+
+interface LspService {
+    isEnabled(): boolean;
+    hasClients(file: string): Promise<boolean>;
+    touchFile(filePath: string, waitDiagnostics?: boolean): Promise<void>;
+    diagnostics(): Promise<Record<string, Diagnostic[]>>;
+    diagnosticsForFile(filePath: string): Promise<Diagnostic[]>;
+    definition(pos: LspPosition): Promise<Location[]>;
+    references(pos: LspPosition): Promise<Location[]>;
+    hover(pos: LspPosition): Promise<Hover[]>;
+    documentSymbol(filePath: string): Promise<(DocumentSymbol | SymbolInformation)[]>;
+    workspaceSymbol(query: string): Promise<SymbolInformation[]>;
+    implementation(pos: LspPosition): Promise<Location[]>;
+    prepareCallHierarchy(pos: LspPosition): Promise<CallHierarchyItem[]>;
+    incomingCalls(pos: LspPosition): Promise<CallHierarchyIncomingCall[]>;
+    outgoingCalls(pos: LspPosition): Promise<CallHierarchyOutgoingCall[]>;
+    shutdown(): Promise<void>;
+    status(): {
+        connectedClients: number;
+    };
+}
+declare function createLspService(config?: LspServiceConfig): LspService;
+
+declare function createAskUserTool(): ToolDefinition<{
+    answers: {};
+    questions: {
+        question: string;
+        header: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        multiSelect: boolean;
+    }[];
+}, ToolOutputEnvelope, ToolOutputEnvelope | undefined, {
+    type: "object";
+    properties: {
+        questions: {
+            type: "array";
+            items: {
+                type: "object";
+                properties: {
+                    question: {
+                        type: "string";
+                    };
+                    header: {
+                        type: "string";
+                    };
+                    options: {
+                        type: "array";
+                        items: {
+                            type: "object";
+                            properties: {
+                                label: {
+                                    type: "string";
+                                };
+                                description: {
+                                    type: "string";
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                    multiSelect: {
+                        type: "boolean";
+                    };
+                };
+                required: string[];
+            };
+        };
+        answers: {
+            type: "object";
+            properties: {};
+        };
+    };
+    required: string[];
+}>;
 
 interface BashToolInput {
     command: string;
@@ -7,6 +97,7 @@ interface BashToolInput {
     ignoreOutput?: boolean;
 }
 interface BashToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     defaultTimeoutMs?: number;
     description?: string;
@@ -17,8 +108,8 @@ interface BashToolOptions {
 }
 declare function createBashTool(options?: BashToolOptions): ToolDefinition<{
     command: string;
-    cwd?: string | undefined;
     timeoutMs?: number | undefined;
+    cwd?: string | undefined;
     ignoreOutput?: boolean | undefined;
 }, string, ToolOutputEnvelope, {
     type: "object";
@@ -40,8 +131,8 @@ declare function createBashTool(options?: BashToolOptions): ToolDefinition<{
 }>;
 declare function createShellExecTool(options?: BashToolOptions): ToolDefinition<{
     command: string;
-    cwd?: string | undefined;
     timeoutMs?: number | undefined;
+    cwd?: string | undefined;
     ignoreOutput?: boolean | undefined;
 }, string, ToolOutputEnvelope, {
     type: "object";
@@ -62,7 +153,30 @@ declare function createShellExecTool(options?: BashToolOptions): ToolDefinition<
     required: readonly ["command"];
 }>;
 
+type CommandReference = CommandDefinitionReference;
+type LoadedCommand = SerializedCommandDefinition;
+interface CommandToolOptions<TRef extends CommandReference = CommandReference> {
+    commands: TRef[];
+    loadCommand: (reference: TRef) => Promise<LoadedCommand>;
+}
+declare function createInvokeCommandTool<TRef extends CommandReference>(options: CommandToolOptions<TRef>): ToolDefinition<{
+    name: string;
+    args?: string | undefined;
+}, ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        name: {
+            type: "string";
+        };
+        args: {
+            type: "string";
+        };
+    };
+    required: readonly ["name"];
+}>;
+
 interface FileEditToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     name?: string;
 }
@@ -91,12 +205,13 @@ declare function createFileEditTool(options?: FileEditToolOptions): ToolDefiniti
 }>;
 
 interface FileNewToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     name?: string;
 }
 declare function createFileNewTool(options?: FileNewToolOptions): ToolDefinition<{
-    filePath: string;
     content: string;
+    filePath: string;
 }, ToolOutputEnvelope, undefined, {
     type: "object";
     properties: {
@@ -111,6 +226,7 @@ declare function createFileNewTool(options?: FileNewToolOptions): ToolDefinition
 }>;
 
 interface FileReadToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     name?: string;
 }
@@ -135,6 +251,7 @@ declare function createFileReadTool(options?: FileReadToolOptions): ToolDefiniti
 }>;
 
 interface GlobToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     limit?: number;
     name?: string;
@@ -160,6 +277,7 @@ declare function createGlobTool(options?: GlobToolOptions): ToolDefinition<{
 }>;
 
 interface GrepToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     limit?: number;
     name?: string;
@@ -199,6 +317,7 @@ interface InternalToolRuntimeOptions {
 declare function createInternalToolRuntime(tools?: AnyToolDefinition[], options?: InternalToolRuntimeOptions): ToolRuntime;
 
 interface LsToolOptions {
+    allowedDirs?: readonly string[];
     defaultCwd?: string;
     name?: string;
 }
@@ -217,6 +336,133 @@ declare function createLsTool(options?: LsToolOptions): ToolDefinition<{
     };
 }>;
 
+interface LspToolOptions {
+    defaultCwd?: string;
+    allowedDirs?: readonly string[];
+    lspService?: LspService;
+    name?: string;
+}
+declare function createLspTool(options?: LspToolOptions): ToolDefinition<{
+    filePath: string;
+    line: number;
+    character: number;
+    operation: string;
+    query?: string | undefined;
+}, ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        operation: {
+            type: "string";
+            enum: string[];
+        };
+        filePath: {
+            type: "string";
+        };
+        line: {
+            type: "number";
+        };
+        character: {
+            type: "number";
+        };
+        query: {
+            type: "string";
+        };
+    };
+    required: readonly ["operation", "filePath", "line", "character"];
+}>;
+
+interface McpOAuthProviderOptions {
+    serverName: string;
+    callbackUrl: string;
+    storageDir: string;
+    config: MCPAuthConfig;
+    onRedirect(url: URL): void | Promise<void>;
+}
+declare function createMcpOAuthProvider(options: McpOAuthProviderOptions): OAuthClientProvider;
+
+interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}
+interface McpToolClient {
+    callTool(input: {
+        name: string;
+        arguments?: JsonObject;
+    }): Promise<CallToolResult>;
+}
+declare function createMcpToolName(serverName: string, toolName: string): string;
+declare function toNuvinToolSchema(inputSchema: unknown): JsonSchemaObject;
+declare function createMcpTool(options: {
+    serverName: string;
+    tool: McpToolDescriptor;
+    client: McpToolClient;
+}): ToolDefinition<{
+    [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
+        [x: string]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*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]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*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;
+    };
+}, ToolOutputEnvelope, undefined, JsonSchemaObject<Record<string, JsonSchema>, readonly string[] | undefined>>;
+
+interface ConnectedMcpClient extends McpToolClient {
+    listTools(): Promise<ListToolsResult>;
+    close(): Promise<void>;
+}
+type McpServerConnectionStatus = {
+    status: "connected";
+    toolCount: number;
+} | {
+    status: "disabled";
+} | {
+    status: "authRequired";
+    message: string;
+} | {
+    status: "error";
+    message: string;
+};
+interface McpToolBundle {
+    tools: AnyToolDefinition[];
+    servers: Record<string, McpServerConnectionStatus>;
+    close(): Promise<void>;
+}
+interface McpConnectionOptions {
+    oauth?: {
+        storageDir: string;
+        callbackUrl: string;
+        onRedirect(serverName: string, url: URL): void | Promise<void>;
+    };
+}
+type McpConnector = (serverName: string, config: MCPServerConfig, options?: McpConnectionOptions) => Promise<ConnectedMcpClient>;
+declare function buildMcpHttpHeaders(config: MCPServerConfig): Record<string, string> | undefined;
+declare function connectMcpServer(serverName: string, config: MCPServerConfig, options?: McpConnectionOptions): Promise<ConnectedMcpClient>;
+declare function createMcpToolsFromServers(options: {
+    servers?: Record<string, MCPServerConfig>;
+    allowedTools?: Record<string, Record<string, boolean>>;
+    connection?: McpConnectionOptions;
+    connect?: McpConnector;
+}): Promise<McpToolBundle>;
+
 declare function createMockToolRuntime(): ToolRuntime;
 
 type RipgrepMatch = {
@@ -248,14 +494,22 @@ interface CreateDelegationToolsOptions {
     agents?: Record<string, DelegatedAgentDefinition>;
 }
 declare function createAssignTaskTool(options: CreateDelegationToolsOptions): ToolDefinition<{
-    agentId: string;
+    description: string;
     task: string;
+    agentId: string;
+    nickname: string;
 }, ToolOutputEnvelope, ToolOutputEnvelope, {
     type: "object";
     properties: {
         agentId: {
             type: "string";
         };
+        description: {
+            type: "string";
+        };
+        nickname: {
+            type: "string";
+        };
         task: {
             type: "string";
         };
@@ -264,14 +518,22 @@ declare function createAssignTaskTool(options: CreateDelegationToolsOptions): To
 }>;
 declare const createDelegateToAgentTool: typeof createAssignTaskTool;
 declare function createDelegationTools(options: CreateDelegationToolsOptions): ToolDefinition<{
-    agentId: string;
+    description: string;
     task: string;
+    agentId: string;
+    nickname: string;
 }, ToolOutputEnvelope, ToolOutputEnvelope, {
     type: "object";
     properties: {
         agentId: {
             type: "string";
         };
+        description: {
+            type: "string";
+        };
+        nickname: {
+            type: "string";
+        };
         task: {
             type: "string";
         };
@@ -279,8 +541,117 @@ declare function createDelegationTools(options: CreateDelegationToolsOptions): T
     required: string[];
 }>[];
 
+/** Minimal shape of a skill source reference — matches @nuvin/config SkillDefinitionSource */
+interface SkillSource {
+    path: string;
+    directory?: string;
+    scope?: string;
+}
+/** Minimal shape of a skill reference — matches @nuvin/config SkillDefinitionReference */
+interface SkillReference {
+    id: string;
+    name: string;
+    description: string;
+    source: SkillSource;
+}
+/** Minimal shape of a loaded skill — matches @nuvin/config SerializedSkillDefinition */
+interface LoadedSkill extends SkillReference {
+    instructions: string;
+}
+interface SkillToolOptions<TRef extends SkillReference = SkillReference> {
+    skills: TRef[];
+    loadSkill: (reference: TRef) => Promise<LoadedSkill>;
+}
+declare function createLoadSkillTool<TRef extends SkillReference>(options: SkillToolOptions<TRef>): ToolDefinition<{
+    name: string;
+}, ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        name: {
+            type: "string";
+        };
+    };
+    required: readonly ["name"];
+}>;
+
+type TodoStatus = "pending" | "in_progress" | "completed";
+type TodoPriority = "high" | "medium" | "low";
+type TodoInputItem = {
+    id: string;
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+    createdAt?: string;
+};
+type TodoItem = TodoInputItem & {
+    sessionId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type TodoStats = {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+};
+declare class TodoStore {
+    private readonly todosBySession;
+    getTodos(sessionId: string): TodoItem[];
+    setTodos(sessionId: string, todos: TodoItem[]): void;
+    getStats(sessionId: string): TodoStats;
+}
+declare function createTodoWriteTool(store?: TodoStore): ToolDefinition<{
+    todos: {
+        content: string;
+        id: string;
+        priority: string;
+        status: string;
+        createdAt: string;
+    }[];
+}, never, ToolOutputEnvelope, {
+    type: "object";
+    properties: {
+        todos: {
+            type: "array";
+            items: {
+                type: "object";
+                properties: {
+                    content: {
+                        type: "string";
+                    };
+                    status: {
+                        type: "string";
+                    };
+                    priority: {
+                        type: "string";
+                    };
+                    id: {
+                        type: "string";
+                    };
+                    createdAt: {
+                        type: "string";
+                    };
+                };
+                required: string[];
+            };
+        };
+    };
+    required: string[];
+}>;
+
+interface ToolOutputOffloadOptions {
+    maxBytes: number;
+    sessionDir?: string;
+}
+/**
+ * Truncate a tool result's output if it exceeds `maxBytes`.
+ * Full output is written to `{sessionDir}/{toolName}_{sanitizedCallId}.log`.
+ * Returns the (possibly truncated) result. Mutates nothing.
+ */
+declare function truncateToolOutput(result: ToolResult, options: ToolOutputOffloadOptions): Promise<ToolResult>;
+
 declare function normalizeToolOutputValue(output: ToolOutputValue): ToolResultChunk;
-declare function createToolOutput(output: string, structured?: JsonObject): ToolOutputEnvelope;
+declare function createToolOutput(output: string, structured?: JsonObject, content?: ToolResultContent): ToolOutputEnvelope;
 declare class ToolExecutionError extends Error {
     readonly structured: JsonObject;
     constructor(message: string, structured?: JsonObject);
@@ -302,8 +673,111 @@ declare class ToolRegistry {
 declare function validateToolInput<TSchema extends JsonSchemaObject>(input: JsonValue, schema: TSchema): InferJsonSchema<TSchema>;
 declare function deriveFinalToolOutput(chunks: ToolResultChunk[]): ToolResultChunk;
 
+interface ViewFileToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    maxBytes?: number;
+    name?: string;
+}
+declare function createViewFileTool(options?: ViewFileToolOptions): ToolDefinition<{
+    path: string;
+    detail?: string | undefined;
+}, ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        path: {
+            type: "string";
+        };
+        detail: {
+            type: "string";
+        };
+    };
+    required: readonly ["path"];
+}>;
+
+interface WebFetchToolOptions {
+    timeoutMs?: number;
+    name?: string;
+}
+declare function createWebFetchTool(options?: WebFetchToolOptions): ToolDefinition<{
+    url: string;
+    description?: string | undefined;
+}, ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        description: {
+            type: "string";
+        };
+        url: {
+            type: "string";
+        };
+    };
+    required: readonly ["url"];
+}>;
+
+interface WebSearchToolOptions {
+    googleCseKey: string;
+    googleCseCx: string;
+    name?: string;
+}
+declare function createWebSearchTool(options: WebSearchToolOptions): ToolDefinition<{
+    query: string;
+    type?: string | undefined;
+    description?: string | undefined;
+    count?: number | undefined;
+    offset?: number | undefined;
+    safe?: boolean | undefined;
+    domains?: string[] | undefined;
+    recencyDays?: number | undefined;
+    lang?: string | undefined;
+    region?: string | undefined;
+    hydrateMeta?: boolean | undefined;
+}, ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        description: {
+            type: "string";
+        };
+        query: {
+            type: "string";
+        };
+        count: {
+            type: "number";
+        };
+        offset: {
+            type: "number";
+        };
+        domains: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        recencyDays: {
+            type: "number";
+        };
+        lang: {
+            type: "string";
+        };
+        region: {
+            type: "string";
+        };
+        safe: {
+            type: "boolean";
+        };
+        type: {
+            type: "string";
+        };
+        hydrateMeta: {
+            type: "boolean";
+        };
+    };
+    required: readonly ["query"];
+}>;
+
 declare function resolveWorkspacePath(rootDir: string, inputPath: string): string;
+declare function resolveAllowedPath(rootDir: string, allowedDirs: readonly string[], inputPath: string): string;
 declare function assertWorkspaceFile(filePath: string): Promise<void>;
 declare function isProbablyBinary(buffer: Buffer): boolean;
 
-export { type BashToolInput, type BashToolOptions, type CreateDelegationToolsOptions, type DelegatedAgentDefinition, type DelegatedAgentFactoryContext, type FileEditToolOptions, type FileNewToolOptions, type FileReadToolOptions, type GlobToolOptions, type GrepToolOptions, type LsToolOptions, type RipgrepMatch, ToolExecutionError, ToolRegistry, assertWorkspaceFile, createAssignTaskTool, createBashTool, createDelegateToAgentTool, createDelegationTools, createFileEditTool, createFileNewTool, createFileReadTool, createGlobTool, createGrepTool, createInternalToolRuntime, createLsTool, createMockToolRuntime, createShellExecTool, createToolOutput, defineTool, deriveFinalToolOutput, filepath, files, isProbablyBinary, normalizeToolOutputValue, resolveWorkspacePath, search, validateToolInput };
+export { type BashToolInput, type BashToolOptions, type CommandReference, type CommandToolOptions, type CreateDelegationToolsOptions, type DelegatedAgentDefinition, type DelegatedAgentFactoryContext, type FileEditToolOptions, type FileNewToolOptions, type FileReadToolOptions, type GlobToolOptions, type GrepToolOptions, type LoadedCommand, type LoadedSkill, type LsToolOptions, type LspService, type LspServiceConfig, type LspToolOptions, type McpConnectionOptions, type McpConnector, type McpOAuthProviderOptions, type McpServerConnectionStatus, type McpToolBundle, type McpToolClient, type McpToolDescriptor, type RipgrepMatch, type SkillReference, type SkillSource, type SkillToolOptions, ToolExecutionError, type ToolOutputOffloadOptions, ToolRegistry, type ViewFileToolOptions, type WebFetchToolOptions, type WebSearchToolOptions, assertWorkspaceFile, buildMcpHttpHeaders, connectMcpServer, createAskUserTool, createAssignTaskTool, createBashTool, createDelegateToAgentTool, createDelegationTools, createFileEditTool, createFileNewTool, createFileReadTool, createGlobTool, createGrepTool, createInternalToolRuntime, createInvokeCommandTool, createLoadSkillTool, createLsTool, createLspService, createLspTool, createMcpOAuthProvider, createMcpTool, createMcpToolName, createMcpToolsFromServers, createMockToolRuntime, createShellExecTool, createTodoWriteTool, createToolOutput, createViewFileTool, createWebFetchTool, createWebSearchTool, defineTool, deriveFinalToolOutput, filepath, files, isProbablyBinary, normalizeToolOutputValue, resolveAllowedPath, resolveWorkspacePath, search, toNuvinToolSchema, truncateToolOutput, validateToolInput };