@nuvin/agent-core 0.0.0-rc.9 → 0.0.0

package/dist/tools/internal-tool-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { AnyToolDefinition, ToolRuntime, ToolRuntimeEventHandler, ToolRuntimeToolCallHandler } from "../shared/types.ts";
+interface InternalToolRuntimeOptions {
+    onEvent?: ToolRuntimeEventHandler;
+    onToolCall?: ToolRuntimeToolCallHandler;
+}
+export declare function createInternalToolRuntime(tools?: AnyToolDefinition[], options?: InternalToolRuntimeOptions): ToolRuntime;
+export {};
+//# sourceMappingURL=internal-tool-runtime.d.ts.map

package/dist/tools/ls-tool.d.ts

@@ -0,0 +1,20 @@
+export interface LsToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    name?: string;
+}
+export declare function createLsTool(options?: LsToolOptions): import("../shared/types.ts").ToolDefinition<{
+    path: string;
+    limit: number;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        path: {
+            type: "string";
+        };
+        limit: {
+            type: "number";
+        };
+    };
+}>;
+//# sourceMappingURL=ls-tool.d.ts.map

package/dist/tools/lsp-tool.d.ts

@@ -0,0 +1,36 @@
+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;
+    line: number;
+    character: number;
+    operation: string;
+    query?: string | undefined;
+}, import("../shared/types.ts").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"];
+}>;
+//# sourceMappingURL=lsp-tool.d.ts.map

package/dist/tools/mcp-oauth-provider.d.ts

@@ -0,0 +1,11 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { MCPAuthConfig } from "@nuvin/config";
+export interface McpOAuthProviderOptions {
+    serverName: string;
+    callbackUrl: string;
+    storageDir: string;
+    config: MCPAuthConfig;
+    onRedirect(url: URL): void | Promise<void>;
+}
+export declare function createMcpOAuthProvider(options: McpOAuthProviderOptions): OAuthClientProvider;
+//# sourceMappingURL=mcp-oauth-provider.d.ts.map

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

@@ -0,0 +1,43 @@
+import type { ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
+import type { MCPServerConfig } from "@nuvin/config";
+import type { AnyToolDefinition } from "../shared/types.ts";
+import { type McpToolClient } from "./mcp-tool-adapter.ts";
+interface ConnectedMcpClient extends McpToolClient {
+    listTools(): Promise<ListToolsResult>;
+    close(): Promise<void>;
+}
+export type McpServerConnectionStatus = {
+    status: "connected";
+    toolCount: number;
+} | {
+    status: "disabled";
+} | {
+    status: "authRequired";
+    message: string;
+} | {
+    status: "error";
+    message: string;
+};
+export interface McpToolBundle {
+    tools: AnyToolDefinition[];
+    servers: Record<string, McpServerConnectionStatus>;
+    close(): Promise<void>;
+}
+export interface McpConnectionOptions {
+    oauth?: {
+        storageDir: string;
+        callbackUrl: string;
+        onRedirect(serverName: string, url: URL): void | Promise<void>;
+    };
+}
+export type McpConnector = (serverName: string, config: MCPServerConfig, options?: McpConnectionOptions) => Promise<ConnectedMcpClient>;
+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 createMcpToolsFromServers(options: {
+    servers?: Record<string, MCPServerConfig>;
+    allowedTools?: Record<string, Record<string, boolean>>;
+    connection?: McpConnectionOptions;
+    connect?: McpConnector;
+}): Promise<McpToolBundle>;
+export {};
+//# sourceMappingURL=mcp-server-manager.d.ts.map

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

@@ -0,0 +1,47 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { JsonObject, JsonSchema, JsonSchemaObject } from "../shared/types.ts";
+export interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}
+export interface McpToolClient {
+    callTool(input: {
+        name: string;
+        arguments?: JsonObject;
+    }): Promise<CallToolResult>;
+}
+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;
+}): import("../shared/types.ts").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;
+    };
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, JsonSchemaObject<Record<string, JsonSchema>, readonly string[] | undefined>>;
+//# sourceMappingURL=mcp-tool-adapter.d.ts.map

package/dist/tools/mock-tool-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { ToolRuntime } from "../shared/types.ts";
+export declare function createMockToolRuntime(): ToolRuntime;
+//# sourceMappingURL=mock-tool-runtime.d.ts.map

package/dist/tools/ripgrep.d.ts

@@ -0,0 +1,20 @@
+export type RipgrepMatch = {
+    filePath: string;
+    isContext?: boolean;
+    lineNum: number;
+    lineText: string;
+};
+export declare function filepath(): Promise<string>;
+export declare function files(opts: {
+    cwd: string;
+    glob?: string[];
+}): AsyncGenerator<string>;
+export declare function search(opts: {
+    context?: number;
+    cwd: string;
+    file?: string;
+    glob?: string;
+    limit?: number;
+    pattern: string;
+}): Promise<RipgrepMatch[]>;
+//# sourceMappingURL=ripgrep.d.ts.map

package/dist/tools/runtime-manager-tools.d.ts

@@ -0,0 +1,58 @@
+import type { AgentDefinitionFactoryContext, AgentOptions } from "../shared/types.ts";
+export interface DelegatedAgentFactoryContext extends AgentDefinitionFactoryContext {
+    parentSessionId: string;
+    runId: string;
+}
+export type DelegatedAgentDefinition = AgentOptions | ((ctx: DelegatedAgentFactoryContext) => AgentOptions | Promise<AgentOptions>);
+export interface CreateDelegationToolsOptions {
+    agents?: Record<string, DelegatedAgentDefinition>;
+}
+export declare function resolveDelegatedAgentOptions(definition: DelegatedAgentDefinition, ctx: DelegatedAgentFactoryContext): Promise<AgentOptions>;
+export declare function createAssignTaskTool(options: CreateDelegationToolsOptions): import("../shared/types.ts").ToolDefinition<{
+    description: string;
+    task: string;
+    agentId: string;
+    nickname: string;
+}, import("../shared/types.ts").ToolOutputEnvelope, import("../shared/types.ts").ToolOutputEnvelope, {
+    type: "object";
+    properties: {
+        agentId: {
+            type: "string";
+        };
+        description: {
+            type: "string";
+        };
+        nickname: {
+            type: "string";
+        };
+        task: {
+            type: "string";
+        };
+    };
+    required: string[];
+}>;
+export declare const createDelegateToAgentTool: typeof createAssignTaskTool;
+export declare function createDelegationTools(options: CreateDelegationToolsOptions): import("../shared/types.ts").ToolDefinition<{
+    description: string;
+    task: string;
+    agentId: string;
+    nickname: string;
+}, import("../shared/types.ts").ToolOutputEnvelope, import("../shared/types.ts").ToolOutputEnvelope, {
+    type: "object";
+    properties: {
+        agentId: {
+            type: "string";
+        };
+        description: {
+            type: "string";
+        };
+        nickname: {
+            type: "string";
+        };
+        task: {
+            type: "string";
+        };
+    };
+    required: string[];
+}>[];
+//# sourceMappingURL=runtime-manager-tools.d.ts.map

package/dist/tools/safe-fetch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Resolves a hostname to its IP addresses. Mirrors the shape of
+ * `node:dns/promises` `lookup(host, { all: true })` but is injectable so the
+ * SSRF guard can be tested without real DNS.
+ */
+export type SafeFetchLookup = (hostname: string) => Promise<Array<{
+    address: string;
+    family: number;
+}>>;
+export interface SafeFetchOptions {
+    lookup?: SafeFetchLookup;
+    fetchImpl?: typeof fetch;
+    maxRedirects?: number;
+}
+export declare const defaultLookup: SafeFetchLookup;
+/**
+ * True when an IP literal points at a non-public destination (loopback,
+ * private, link-local, CGNAT, multicast, reserved). Fails closed on anything
+ * unparseable so a bypass cannot slip through as "not blocked".
+ */
+export declare function isBlockedAddress(ip: string): boolean;
+/**
+ * Validate that a URL is safe for the server to fetch: http(s) only, no
+ * embedded credentials, and a destination that does not resolve to a private
+ * or otherwise non-public address. Literal IPs are range-checked directly;
+ * hostnames are resolved and rejected if ANY resolved address is non-public.
+ * Throws ToolExecutionError on rejection; returns the parsed URL on success.
+ */
+export declare function assertPublicUrl(value: string, options?: SafeFetchOptions): Promise<URL>;
+/**
+ * SSRF-hardened fetch: validates the target (and every redirect hop) against
+ * {@link assertPublicUrl} before connecting, following redirects manually so a
+ * 30x into a private/metadata address cannot be transparently followed.
+ */
+export declare function safeFetch(value: string, init?: RequestInit, options?: SafeFetchOptions): Promise<Response>;
+//# sourceMappingURL=safe-fetch.d.ts.map

package/dist/tools/skill-tool.d.ts

@@ -0,0 +1,33 @@
+/** Minimal shape of a skill source reference — matches @nuvin/config SkillDefinitionSource */
+export interface SkillSource {
+    path: string;
+    directory?: string;
+    scope?: string;
+}
+/** Minimal shape of a skill reference — matches @nuvin/config SkillDefinitionReference */
+export interface SkillReference {
+    id: string;
+    name: string;
+    description: string;
+    source: SkillSource;
+}
+/** Minimal shape of a loaded skill — matches @nuvin/config SerializedSkillDefinition */
+export interface LoadedSkill extends SkillReference {
+    instructions: string;
+}
+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<{
+    name: string;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        name: {
+            type: "string";
+        };
+    };
+    required: readonly ["name"];
+}>;
+//# sourceMappingURL=skill-tool.d.ts.map

package/dist/tools/todo-write-tool.d.ts

@@ -0,0 +1,66 @@
+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;
+}
+export declare function createTodoWriteTool(store?: TodoStore): import("../shared/types.ts").ToolDefinition<{
+    todos: {
+        id: string;
+        content: string;
+        status: string;
+        priority: string;
+        createdAt: string;
+    }[];
+}, never, import("../shared/types.ts").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[];
+}>;
+export {};
+//# sourceMappingURL=todo-write-tool.d.ts.map

package/dist/tools/tool-output-offload.d.ts

@@ -0,0 +1,12 @@
+import type { ToolResult } from "../shared/types.ts";
+export 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.
+ */
+export declare function truncateToolOutput(result: ToolResult, options: ToolOutputOffloadOptions): Promise<ToolResult>;
+//# sourceMappingURL=tool-output-offload.d.ts.map

package/dist/tools/tools.d.ts

@@ -0,0 +1,24 @@
+import type { AnyToolDefinition, InferJsonSchema, JsonObject, JsonSchemaObject, JsonValue, ToolDefinition, ToolExecutionContext, ToolOutputEnvelope, ToolOutputValue, ToolResultChunk, ToolResultContent, ToolSchema } from "../shared/types.ts";
+export declare function normalizeToolOutputValue(output: ToolOutputValue): ToolResultChunk;
+export declare function createToolOutput(output: string, structured?: JsonObject, content?: ToolResultContent): ToolOutputEnvelope;
+export declare class ToolExecutionError extends Error {
+    readonly structured: JsonObject;
+    constructor(message: string, structured?: JsonObject);
+}
+export declare function defineTool<TSchema extends JsonSchemaObject, TYield extends ToolOutputValue = ToolOutputValue, TReturn extends ToolOutputValue | undefined = ToolOutputValue | undefined>(definition: {
+    name: string;
+    description: string;
+    inputSchema: TSchema;
+    execute(input: InferJsonSchema<TSchema>, ctx: ToolExecutionContext): AsyncGenerator<TYield, TReturn, void>;
+}): ToolDefinition<InferJsonSchema<TSchema>, TYield, TReturn, TSchema>;
+export declare class ToolRegistry {
+    private readonly toolsByName;
+    constructor(tools?: AnyToolDefinition[]);
+    register(tool: AnyToolDefinition): void;
+    get(name: string): AnyToolDefinition | undefined;
+    list(): AnyToolDefinition[];
+    listToolSchemas(): ToolSchema[];
+}
+export declare function validateToolInput<TSchema extends JsonSchemaObject>(input: JsonValue, schema: TSchema): InferJsonSchema<TSchema>;
+export declare function deriveFinalToolOutput(chunks: ToolResultChunk[]): ToolResultChunk;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools/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/view-file-tool.d.ts

@@ -0,0 +1,22 @@
+export interface ViewFileToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    maxBytes?: number;
+    name?: string;
+}
+export declare function createViewFileTool(options?: ViewFileToolOptions): import("../shared/types.ts").ToolDefinition<{
+    path: string;
+    detail?: string | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        path: {
+            type: "string";
+        };
+        detail: {
+            type: "string";
+        };
+    };
+    required: readonly ["path"];
+}>;
+//# sourceMappingURL=view-file-tool.d.ts.map

package/dist/tools/web-fetch-tool.d.ts

@@ -0,0 +1,23 @@
+import { type SafeFetchLookup } from "./safe-fetch.ts";
+export interface WebFetchToolOptions {
+    timeoutMs?: number;
+    name?: string;
+    /** DNS resolver used by the SSRF guard. Injectable for tests. */
+    lookup?: SafeFetchLookup;
+}
+export declare function createWebFetchTool(options?: WebFetchToolOptions): import("../shared/types.ts").ToolDefinition<{
+    url: string;
+    description?: string | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        description: {
+            type: "string";
+        };
+        url: {
+            type: "string";
+        };
+    };
+    required: readonly ["url"];
+}>;
+//# sourceMappingURL=web-fetch-tool.d.ts.map

package/dist/tools/web-search-tool.d.ts

@@ -0,0 +1,75 @@
+import { type SafeFetchLookup } from "./safe-fetch.ts";
+export interface GoogleCseEngineOptions {
+    googleCseKey: string;
+    googleCseCx: string;
+}
+export interface OllamaEngineOptions {
+    apiKey: string;
+}
+export interface TavilyEngineOptions {
+    tavilyApiKey: string;
+    searchDepth?: "basic" | "advanced";
+    topic?: "general" | "news" | "finance";
+}
+export type WebSearchEngine = GoogleCseEngineOptions | OllamaEngineOptions | TavilyEngineOptions;
+export interface WebSearchToolOptions {
+    engines: WebSearchEngine[];
+    name?: string;
+    /** 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<{
+    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;
+}, import("../shared/types.ts").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"];
+}>;
+//# sourceMappingURL=web-search-tool.d.ts.map

package/dist/tools/workspace-paths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveWorkspacePath(rootDir: string, inputPath: string): string;
+export declare function resolveAllowedPath(rootDir: string, allowedDirs: readonly string[], inputPath: string): string;
+export declare function assertWorkspaceFile(filePath: string): Promise<void>;
+export declare function isProbablyBinary(buffer: Buffer): boolean;
+//# sourceMappingURL=workspace-paths.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuvin/agent-core",
-  "version": "0.0.0-rc.9",
+  "version": "0.0.0",
   "private": false,
   "description": "Core agent, model, format, and tool primitives for Nuvin",
   "license": "Apache-2.0",
@@ -37,6 +37,10 @@
     "./tools": {
       "types": "./dist/tools/index.d.ts",
       "import": "./dist/tools/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
     }
   },
   "devDependencies": {
@@ -48,7 +52,7 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.2",
     "vitest": "^4.1.2",
-    "@nuvin/config": "0.1.0-rc.4"
+    "@nuvin/config": "0.1.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.82.0",