@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/scope/index.d.ts

@@ -0,0 +1,10 @@
+import { e as ScopeOptions, a as Scope, S as ScopeSnapshot } from '../types-CQL-SvTn.js';
+export { b as ScopeAttributeValue, c as ScopeAttributes, d as ScopeKind } from '../types-CQL-SvTn.js';
+
+declare function currentScope(): Scope | undefined;
+declare function snapshotScope(scope?: Scope | undefined): ScopeSnapshot | undefined;
+declare function createScope(options: ScopeOptions): Scope;
+declare function withinScope<T>(options: ScopeOptions, fn: () => T | Promise<T>): Promise<T>;
+declare function restoreScope<T>(snapshot: ScopeSnapshot | undefined, fn: () => T | Promise<T>): Promise<T>;
+
+export { Scope, ScopeOptions, ScopeSnapshot, createScope, currentScope, restoreScope, snapshotScope, withinScope };

package/dist/scope/index.js

@@ -0,0 +1,14 @@
+import {
+  createScope,
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  withinScope
+} from "../chunk-N7P4PN3O.js";
+export {
+  createScope,
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  withinScope
+};

package/dist/{session-manager-Uawm2Le7.d.ts → session-manager-B_CWGTsl.d.ts}

@@ -271,4 +271,4 @@ declare class SessionManager {
     getStorage(): SessionStorage;
 }
 
-export { type BranchEntry as B, type CompactionEntry as C, type EntryBase as E, type FileEntry as F, type MessageEntry as M, STORAGE_VERSION as S, type CreateSessionOptions as a, type MetadataEntry as b, type SessionContext as c, type SessionEntry as d, type SessionHeader as e, type SessionInfo as f, SessionManager as g, type SessionStorage as h, type SerializedMessage as i, type ConfigChangeEntry as j };
+export { type BranchEntry as B, type CompactionEntry as C, type EntryBase as E, type FileEntry as F, type MessageEntry as M, SessionManager as S, type ConfigChangeEntry as a, type CreateSessionOptions as b, type MetadataEntry as c, STORAGE_VERSION as d, type SerializedMessage as e, type SessionContext as f, type SessionEntry as g, type SessionHeader as h, type SessionInfo as i, type SessionStorage as j };

package/dist/signal/index.d.ts

@@ -0,0 +1,28 @@
+import { A as AgentSignal, T as TypedHandler, U as Unsubscribe, W as WildcardHandler } from '../types-YuWV4ag7.js';
+export { E as EventOf } from '../types-YuWV4ag7.js';
+import { A as AgentEvent } from '../events-CE72w8W4.js';
+import 'ai';
+import '../messages-BYWGn8TY.js';
+
+/**
+ * LocalSignal — in-process event dispatch.
+ *
+ * Dispatches events synchronously via direct function calls.
+ * Zero dependencies, zero serialization, zero network.
+ *
+ * Handler errors are caught silently — a broken listener must never
+ * interrupt the agent's streaming pipeline.
+ */
+
+declare class LocalSignal implements AgentSignal {
+    /** type → Set<handler> for typed subscriptions */
+    private readonly typed;
+    /** handlers that receive every event */
+    private readonly wildcard;
+    on<T extends AgentEvent["type"]>(type: T, handler: TypedHandler<T>): Unsubscribe;
+    onAny(handler: WildcardHandler): Unsubscribe;
+    emit(event: AgentEvent): void;
+    clear(): void;
+}
+
+export { AgentSignal, LocalSignal, TypedHandler, Unsubscribe, WildcardHandler };

package/dist/signal/index.js

@@ -0,0 +1,6 @@
+import {
+  LocalSignal
+} from "../chunk-KUVSERLJ.js";
+export {
+  LocalSignal
+};

package/dist/skill/index.d.ts

@@ -1,9 +1,12 @@
-import { h as SkillScope, i as SkillSource, a as SkillMetadata, g as SkillResourceType, c as SkillResource, b as SkillContent, d as SkillConfig, S as SkillDiscoveryResult, T as Tool } from '../tool-pFAnJc5Y.js';
-export { R as RemoteSkillEntry, e as RemoteSkillIndex, f as SkillDiscoveryError, j as SkillSourceType } from '../tool-pFAnJc5Y.js';
-import { S as SkillRegistry } from '../registry-CuRWWtcT.js';
-export { c as createSkillRegistry, e as emptySkillRegistry } from '../registry-CuRWWtcT.js';
+import { h as SkillScope, i as SkillSource, a as SkillMetadata, g as SkillResourceType, c as SkillResource, b as SkillContent, d as SkillConfig, S as SkillDiscoveryResult } from '../types-BfNpU8NS.js';
+export { R as RemoteSkillEntry, e as RemoteSkillIndex, f as SkillDiscoveryError, j as SkillSourceType } from '../types-BfNpU8NS.js';
+import { S as SkillRegistry } from '../registry-DwYqsQkX.js';
+export { c as createSkillRegistry, e as emptySkillRegistry } from '../registry-DwYqsQkX.js';
+import { T as Tool } from '../tool-BHbyUAy3.js';
 import 'zod';
-import '../tool-DYp6-cC3.js';
+import '../tool-DLXAR9Ce.js';
+import '../types-CHiPh8U2.js';
+import '../types-CQL-SvTn.js';
 
 declare const SKILL_FILENAME = "SKILL.md";
 declare const DEFAULT_SKILL_MAX_SIZE = 102400;

package/dist/storage/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FileEntry, i as SerializedMessage, d as SessionEntry, M as MessageEntry, b as MetadataEntry, f as SessionInfo, h as SessionStorage, e as SessionHeader, g as SessionManager } from '../session-manager-Uawm2Le7.js';
-export { B as BranchEntry, C as CompactionEntry, j as ConfigChangeEntry, a as CreateSessionOptions, E as EntryBase, S as STORAGE_VERSION, c as SessionContext } from '../session-manager-Uawm2Le7.js';
+import { F as FileEntry, g as SessionEntry, M as MessageEntry, c as MetadataEntry, e as SerializedMessage, i as SessionInfo, j as SessionStorage, h as SessionHeader, S as SessionManager } from '../session-manager-B_CWGTsl.js';
+export { B as BranchEntry, C as CompactionEntry, a as ConfigChangeEntry, b as CreateSessionOptions, E as EntryBase, d as STORAGE_VERSION, f as SessionContext } from '../session-manager-B_CWGTsl.js';
 import { M as Message } from '../messages-BYWGn8TY.js';
 
 /**

package/dist/sub-agent/index.d.ts

@@ -1,14 +1,23 @@
-export { c as AgentProfile, D as DEFAULT_MAX_CONCURRENT, d as DEFAULT_MAX_SPAWN_DEPTH, e as DEFAULT_SESSION_TITLE_PREFIX, S as SubAgentCompletedResult, f as SubAgentHandle, g as SubAgentStatus, h as SubAgentToolConfig, i as SubAgentTracker, j as SubAgentUsage, l as createSubAgentTools } from '../index-DZQJD_hp.js';
+export { b as AgentProfile, D as DEFAULT_MAX_CONCURRENT, c as DEFAULT_MAX_SPAWN_DEPTH, d as DEFAULT_SESSION_TITLE_PREFIX, S as SubAgentCompletedResult, e as SubAgentHandle, f as SubAgentStatus, g as SubAgentToolConfig, h as SubAgentTracker, i as SubAgentUsage, k as createSubAgentTools } from '../index-CWSchSql.js';
 import 'ai';
+import '../types-BnpEOYV-.js';
 import '../types-CQaXbRsS.js';
-import '../tool-pFAnJc5Y.js';
+import '../tool-BHbyUAy3.js';
 import 'zod';
-import '../tool-DYp6-cC3.js';
-import '../runner-G1wxEgac.js';
+import '../tool-DLXAR9Ce.js';
+import '../types-CHiPh8U2.js';
+import '../types-CQL-SvTn.js';
+import '../runner-e2YRcUoX.js';
+import '@ai-sdk/provider-utils';
+import '../events-CE72w8W4.js';
 import '../messages-BYWGn8TY.js';
-import '../session-manager-Uawm2Le7.js';
+import '../types-BfNpU8NS.js';
+import '../session-manager-B_CWGTsl.js';
 import '../types-VQgymC1N.js';
+import '../types-YuWV4ag7.js';
 import '../tracker-DClqYqTj.js';
-import '../builder-BKkipazh.js';
-import '../registry-CuRWWtcT.js';
-import '../types-BWo810L_.js';
+import '../builder-UpOWQMW3.js';
+import '../registry-DwYqsQkX.js';
+import '../types-KKDrdU9Y.js';
+import '../llm-error-D93FNNLY.js';
+import '../types-QKHHQLLq.js';

package/dist/tool/index.d.ts

@@ -1,10 +1,15 @@
-import { T as Tool } from '../tool-pFAnJc5Y.js';
-export { C as CompatibleSchema, I as InferSchemaOutput, k as defineTool } from '../tool-pFAnJc5Y.js';
-import { a as ToolReplayPolicy, F as FileOperationMeta, N as NormalizedToolReplayPolicy, d as ToolHost, e as TurnTrackerContext } from '../tool-DYp6-cC3.js';
-import { M as MiddlewareRunner } from '../runner-G1wxEgac.js';
+import { T as Tool } from '../tool-BHbyUAy3.js';
+export { C as CompatibleSchema, I as InferSchemaOutput, d as defineTool } from '../tool-BHbyUAy3.js';
+import { a as ToolReplayPolicy, F as FileOperationMeta, N as NormalizedToolReplayPolicy, d as TurnTrackerContext } from '../tool-DLXAR9Ce.js';
+import { T as ToolHost } from '../types-CHiPh8U2.js';
+import { M as MiddlewareRunner } from '../runner-e2YRcUoX.js';
 import 'zod';
+import '../types-CQL-SvTn.js';
 import 'ai';
+import '@ai-sdk/provider-utils';
+import '../events-CE72w8W4.js';
 import '../messages-BYWGn8TY.js';
+import '../types-BfNpU8NS.js';
 import '../types-CQaXbRsS.js';
 
 /**

package/dist/tool/index.js

@@ -2,9 +2,6 @@ import {
   ToolRegistry,
   defaultRegistry
 } from "../chunk-SDSBEQXG.js";
-import {
-  executeAgentToolCall
-} from "../chunk-FG4MD5MU.js";
 import {
   MAX_BYTES,
   MAX_LINES,
@@ -16,7 +13,11 @@ import {
   normalizeToolReplayPolicy,
   truncateOutput
 } from "../chunk-P6YF7USR.js";
+import {
+  executeAgentToolCall
+} from "../chunk-7VKQ4WPB.js";
 import "../chunk-VEKUXUVF.js";
+import "../chunk-N7P4PN3O.js";
 export {
   MAX_BYTES,
   MAX_LINES,

package/dist/tool-BHbyUAy3.d.ts

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+import { T as ToolMetadata, a as ToolReplayPolicy, b as ToolContext, F as FileOperationMeta, c as ToolResult } from './tool-DLXAR9Ce.js';
+
+/**
+ * Tool definition namespace for @cuylabs/agent-core
+ *
+ * Provides consistent tool creation via Tool.define.
+ */
+
+/**
+ * A schema type compatible with both Zod 3 and Zod 4.
+ *
+ * Uses structural typing so that schemas from either Zod version satisfy
+ * the constraint. This avoids the problem where Zod 3's `ZodType` class
+ * and Zod 4's `ZodType` class have incompatible internal shapes, causing
+ * type errors when a library compiled against one version is consumed with
+ * the other.
+ *
+ * Both Zod 3 and Zod 4 (classic API) schemas have `parse()` and `_output`.
+ */
+interface CompatibleSchema<T = any> {
+    /** Parse and validate input data. Present in both Zod 3 and Zod 4. */
+    parse(data: unknown): T;
+    /**
+     * Type-level output marker used by both Zod versions:
+     * - Zod 3: `readonly _output!: T` (definite assignment assertion)
+     * - Zod 4 classic: `get _output(): T` (getter)
+     */
+    readonly _output: T;
+}
+/**
+ * Infer the output type from a compatible schema.
+ * Equivalent to `z.infer<T>` but works with both Zod 3 and Zod 4 schemas.
+ */
+type InferSchemaOutput<T extends CompatibleSchema> = T["_output"];
+/**
+ * Tool namespace - tool definition utilities
+ */
+declare namespace Tool {
+    /**
+     * Tool info interface - the shape of a defined tool
+     */
+    interface Info<TParams extends CompatibleSchema = any, TMeta extends ToolMetadata = ToolMetadata> {
+        /** Unique tool identifier */
+        id: string;
+        /** Recovery semantics for resume-capable runtimes. */
+        replayPolicy?: ToolReplayPolicy;
+        /** Initialize the tool (can be async for dynamic descriptions) */
+        init: (ctx?: InitContext) => Promise<InitResult<TParams, TMeta>> | InitResult<TParams, TMeta>;
+    }
+    /**
+     * Any tool info - for use in arrays and collections where generic types vary
+     */
+    type AnyInfo = Info<any, any>;
+    /**
+     * Context passed during tool initialization
+     */
+    interface InitContext {
+        /** Working directory */
+        cwd?: string;
+        /** Agent name (if known) */
+        agent?: string;
+    }
+    /**
+     * Result of tool initialization
+     */
+    interface InitResult<TParams extends CompatibleSchema = any, TMeta extends ToolMetadata = ToolMetadata> {
+        /** Tool description for the LLM */
+        description: string;
+        /** Zod schema for parameters */
+        parameters: TParams;
+        /** Execute the tool */
+        execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ExecuteResult<TMeta>>;
+        /** Optional custom validation error formatter */
+        formatValidationError?: (error: z.ZodError) => string;
+        /**
+         * File operation metadata for automatic turn tracking.
+         * When set, the agent will automatically capture file baselines
+         * before tool execution for undo/diff capabilities.
+         *
+         * @example
+         * ```typescript
+         * // For a write tool
+         * fileOps: {
+         *   pathArgs: ['path'],
+         *   operationType: 'write'
+         * }
+         * ```
+         */
+        fileOps?: FileOperationMeta;
+        /** Optional replay metadata for resume-capable runtimes. */
+        replayPolicy?: ToolReplayPolicy;
+    }
+    /**
+     * Result of tool execution
+     */
+    interface ExecuteResult<TMeta extends ToolMetadata = ToolMetadata> {
+        /** Short title for display */
+        title: string;
+        /** Main output text */
+        output: string;
+        /** Metadata */
+        metadata: TMeta;
+    }
+    interface DefineOptions {
+        /** Static replay metadata exposed to higher-level runtimes. */
+        replayPolicy?: ToolReplayPolicy;
+    }
+    /**
+     * Define a tool with standard patterns
+     *
+     * @example
+     * ```typescript
+     * const myTool = Tool.define("my_tool", {
+     *   description: "Does something useful",
+     *   parameters: z.object({
+     *     input: z.string().describe("The input to process"),
+     *   }),
+     *   execute: async (params, ctx) => ({
+     *     title: "Processed",
+     *     output: `Result: ${params.input}`,
+     *     metadata: {},
+     *   }),
+     * });
+     * ```
+     */
+    function define<TParams extends CompatibleSchema, TMeta extends ToolMetadata = ToolMetadata>(id: string, init: Info<TParams, TMeta>["init"] | Awaited<ReturnType<Info<TParams, TMeta>["init"]>>, options?: DefineOptions): Info<TParams, TMeta>;
+    /**
+     * Simple define for static tools (no async init)
+     */
+    function defineSimple<TParams extends CompatibleSchema, TMeta extends ToolMetadata = ToolMetadata>(id: string, config: {
+        description: string;
+        parameters: TParams;
+        execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ExecuteResult<TMeta>>;
+        replayPolicy?: ToolReplayPolicy;
+    }): Info<TParams, TMeta>;
+}
+/**
+ * Legacy helper - wraps to Tool.Info format
+ *
+ * @deprecated Use Tool.define instead
+ */
+declare function defineTool<TParams extends CompatibleSchema>(definition: {
+    id: string;
+    description: string;
+    parameters: TParams;
+    execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ToolResult>;
+}): Tool.Info<TParams>;
+
+export { type CompatibleSchema as C, type InferSchemaOutput as I, Tool as T, defineTool as d };

package/dist/{tool-DYp6-cC3.d.ts → tool-DLXAR9Ce.d.ts}

@@ -1,101 +1,5 @@
-/**
- * ToolHost — execution environment abstraction for agent tools.
- *
- * A ToolHost defines *where* tools execute: local machine, Docker container,
- * SSH remote, etc. Every host provides two surfaces:
- *
- * 1. **File system** — read, write, stat, list, check existence
- * 2. **Process execution** — spawn commands, kill processes
- *
- * Tools call `ctx.host.readFile()` / `ctx.host.exec()` instead of importing
- * `fs` and `child_process` directly. The host implementation handles the rest.
- *
- * @example
- * ```typescript
- * // Default: runs everything locally
- * const agent = createAgent({ host: localHost() });
- *
- * // Future: run tools inside a Docker container
- * const agent = createAgent({ host: dockerHost("my-container") });
- * ```
- */
-/** Options for spawning a process. */
-interface ExecOptions {
-    /** Working directory for the command. */
-    cwd?: string;
-    /** Environment variables (merged with host defaults). */
-    env?: Record<string, string | undefined>;
-    /** Abort signal for cancellation. */
-    signal?: AbortSignal;
-    /** Timeout in milliseconds. 0 = no timeout. */
-    timeout?: number;
-    /** Callback for stdout data as it arrives. */
-    onStdout?: (data: Buffer) => void;
-    /** Callback for stderr data as it arrives. */
-    onStderr?: (data: Buffer) => void;
-}
-/** Result of a process execution. */
-interface ExecResult {
-    /** Combined stdout output. */
-    stdout: string;
-    /** Combined stderr output. */
-    stderr: string;
-    /** Exit code (null if killed by signal). */
-    exitCode: number | null;
-    /** Whether the process was killed due to timeout. */
-    timedOut: boolean;
-}
-/** Minimal stat result — only the fields tools actually need. */
-interface FileStat {
-    /** File size in bytes. */
-    size: number;
-    /** Last modification time. */
-    mtime: Date;
-    /** Whether this entry is a directory. */
-    isDirectory: boolean;
-    /** Whether this entry is a regular file. */
-    isFile: boolean;
-}
-/** A directory entry returned by `readdir`. */
-interface DirEntry {
-    /** Entry name (not full path). */
-    name: string;
-    /** Whether this entry is a directory. */
-    isDirectory: boolean;
-    /** Whether this entry is a regular file. */
-    isFile: boolean;
-}
-/**
- * The execution environment for agent tools.
- *
- * Abstracts filesystem and process operations so tools work identically
- * whether running locally, in Docker, over SSH, or in any other environment.
- */
-interface ToolHost {
-    /** Human-readable host identifier (e.g. "local", "docker:my-container"). */
-    readonly name: string;
-    /** Read a file as a UTF-8 string. Throws if the file doesn't exist. */
-    readFile(path: string): Promise<string>;
-    /** Read raw bytes from a file. Throws if the file doesn't exist. */
-    readBytes(path: string, offset: number, length: number): Promise<Buffer>;
-    /** Write a UTF-8 string to a file. Creates parent directories as needed. */
-    writeFile(path: string, content: string): Promise<void>;
-    /** Check if a path exists. Never throws. */
-    exists(path: string): Promise<boolean>;
-    /** Get file metadata. Throws if the path doesn't exist. */
-    stat(path: string): Promise<FileStat>;
-    /** List directory entries. Throws if the path is not a directory. */
-    readdir(path: string): Promise<DirEntry[]>;
-    /** Create directories recursively. No-op if they already exist. */
-    mkdir(path: string): Promise<void>;
-    /**
-     * Execute a shell command.
-     *
-     * The host decides which shell to use (e.g. local host uses the user's
-     * `$SHELL`, Docker host uses `docker exec`, SSH host uses remote shell).
-     */
-    exec(command: string, options?: ExecOptions): Promise<ExecResult>;
-}
+import { T as ToolHost } from './types-CHiPh8U2.js';
+import { S as ScopeSnapshot } from './types-CQL-SvTn.js';
 
 /**
  * Tool-related types for @cuylabs/agent-core
@@ -128,6 +32,8 @@ interface ToolContext {
     messageID: string;
     /** Agent name */
     agent: string;
+    /** Active execution scope snapshot for this tool call. */
+    scope?: ScopeSnapshot;
     /**
      * Execution environment for file and process operations.
      *
@@ -236,4 +142,4 @@ interface ToolMetadata {
     [key: string]: unknown;
 }
 
-export type { DirEntry as D, ExecOptions as E, FileOperationMeta as F, NormalizedToolReplayPolicy as N, ToolMetadata as T, ToolReplayPolicy as a, ToolContext as b, ToolResult as c, ToolHost as d, TurnTrackerContext as e, ExecResult as f, FileStat as g, ToolReplayMode as h, ToolSideEffectLevel as i };
+export type { FileOperationMeta as F, NormalizedToolReplayPolicy as N, ToolMetadata as T, ToolReplayPolicy as a, ToolContext as b, ToolResult as c, TurnTrackerContext as d, ToolReplayMode as e, ToolSideEffectLevel as f };

package/dist/tracking/index.d.ts

@@ -1,6 +1,8 @@
 import { T as TurnChangeTracker } from '../tracker-DClqYqTj.js';
 export { F as FileBaseline, a as TurnFileChange, b as TurnSummary, c as TurnTrackerConfig, U as UndoResult, d as createTurnTracker } from '../tracker-DClqYqTj.js';
-import { F as FileOperationMeta } from '../tool-DYp6-cC3.js';
+import { F as FileOperationMeta } from '../tool-DLXAR9Ce.js';
+import '../types-CHiPh8U2.js';
+import '../types-CQL-SvTn.js';
 
 /**
  * Checkpoint system contracts for @cuylabs/agent-core.

package/dist/{tool-pFAnJc5Y.d.ts → types-BfNpU8NS.d.ts}

@@ -1,6 +1,3 @@
-import { z } from 'zod';
-import { T as ToolMetadata, a as ToolReplayPolicy, b as ToolContext, F as FileOperationMeta, c as ToolResult } from './tool-DYp6-cC3.js';
-
 /**
  * Skill System Types
  *
@@ -270,150 +267,4 @@ interface SkillDiscoveryError {
     reason: string;
 }
 
-/**
- * Tool definition namespace for @cuylabs/agent-core
- *
- * Provides consistent tool creation via Tool.define.
- */
-
-/**
- * A schema type compatible with both Zod 3 and Zod 4.
- *
- * Uses structural typing so that schemas from either Zod version satisfy
- * the constraint. This avoids the problem where Zod 3's `ZodType` class
- * and Zod 4's `ZodType` class have incompatible internal shapes, causing
- * type errors when a library compiled against one version is consumed with
- * the other.
- *
- * Both Zod 3 and Zod 4 (classic API) schemas have `parse()` and `_output`.
- */
-interface CompatibleSchema<T = any> {
-    /** Parse and validate input data. Present in both Zod 3 and Zod 4. */
-    parse(data: unknown): T;
-    /**
-     * Type-level output marker used by both Zod versions:
-     * - Zod 3: `readonly _output!: T` (definite assignment assertion)
-     * - Zod 4 classic: `get _output(): T` (getter)
-     */
-    readonly _output: T;
-}
-/**
- * Infer the output type from a compatible schema.
- * Equivalent to `z.infer<T>` but works with both Zod 3 and Zod 4 schemas.
- */
-type InferSchemaOutput<T extends CompatibleSchema> = T["_output"];
-/**
- * Tool namespace - tool definition utilities
- */
-declare namespace Tool {
-    /**
-     * Tool info interface - the shape of a defined tool
-     */
-    interface Info<TParams extends CompatibleSchema = any, TMeta extends ToolMetadata = ToolMetadata> {
-        /** Unique tool identifier */
-        id: string;
-        /** Recovery semantics for resume-capable runtimes. */
-        replayPolicy?: ToolReplayPolicy;
-        /** Initialize the tool (can be async for dynamic descriptions) */
-        init: (ctx?: InitContext) => Promise<InitResult<TParams, TMeta>> | InitResult<TParams, TMeta>;
-    }
-    /**
-     * Any tool info - for use in arrays and collections where generic types vary
-     */
-    type AnyInfo = Info<any, any>;
-    /**
-     * Context passed during tool initialization
-     */
-    interface InitContext {
-        /** Working directory */
-        cwd?: string;
-        /** Agent name (if known) */
-        agent?: string;
-    }
-    /**
-     * Result of tool initialization
-     */
-    interface InitResult<TParams extends CompatibleSchema = any, TMeta extends ToolMetadata = ToolMetadata> {
-        /** Tool description for the LLM */
-        description: string;
-        /** Zod schema for parameters */
-        parameters: TParams;
-        /** Execute the tool */
-        execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ExecuteResult<TMeta>>;
-        /** Optional custom validation error formatter */
-        formatValidationError?: (error: z.ZodError) => string;
-        /**
-         * File operation metadata for automatic turn tracking.
-         * When set, the agent will automatically capture file baselines
-         * before tool execution for undo/diff capabilities.
-         *
-         * @example
-         * ```typescript
-         * // For a write tool
-         * fileOps: {
-         *   pathArgs: ['path'],
-         *   operationType: 'write'
-         * }
-         * ```
-         */
-        fileOps?: FileOperationMeta;
-        /** Optional replay metadata for resume-capable runtimes. */
-        replayPolicy?: ToolReplayPolicy;
-    }
-    /**
-     * Result of tool execution
-     */
-    interface ExecuteResult<TMeta extends ToolMetadata = ToolMetadata> {
-        /** Short title for display */
-        title: string;
-        /** Main output text */
-        output: string;
-        /** Metadata */
-        metadata: TMeta;
-    }
-    interface DefineOptions {
-        /** Static replay metadata exposed to higher-level runtimes. */
-        replayPolicy?: ToolReplayPolicy;
-    }
-    /**
-     * Define a tool with standard patterns
-     *
-     * @example
-     * ```typescript
-     * const myTool = Tool.define("my_tool", {
-     *   description: "Does something useful",
-     *   parameters: z.object({
-     *     input: z.string().describe("The input to process"),
-     *   }),
-     *   execute: async (params, ctx) => ({
-     *     title: "Processed",
-     *     output: `Result: ${params.input}`,
-     *     metadata: {},
-     *   }),
-     * });
-     * ```
-     */
-    function define<TParams extends CompatibleSchema, TMeta extends ToolMetadata = ToolMetadata>(id: string, init: Info<TParams, TMeta>["init"] | Awaited<ReturnType<Info<TParams, TMeta>["init"]>>, options?: DefineOptions): Info<TParams, TMeta>;
-    /**
-     * Simple define for static tools (no async init)
-     */
-    function defineSimple<TParams extends CompatibleSchema, TMeta extends ToolMetadata = ToolMetadata>(id: string, config: {
-        description: string;
-        parameters: TParams;
-        execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ExecuteResult<TMeta>>;
-        replayPolicy?: ToolReplayPolicy;
-    }): Info<TParams, TMeta>;
-}
-/**
- * Legacy helper - wraps to Tool.Info format
- *
- * @deprecated Use Tool.define instead
- */
-declare function defineTool<TParams extends CompatibleSchema>(definition: {
-    id: string;
-    description: string;
-    parameters: TParams;
-    execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ToolResult>;
-}): Tool.Info<TParams>;
-
-export { type CompatibleSchema as C, type InferSchemaOutput as I, type RemoteSkillEntry as R, type SkillDiscoveryResult as S, Tool as T, type SkillMetadata as a, type SkillContent as b, type SkillResource as c, type SkillConfig as d, type RemoteSkillIndex as e, type SkillDiscoveryError as f, type SkillResourceType as g, type SkillScope as h, type SkillSource as i, type SkillSourceType as j, defineTool as k };
+export type { RemoteSkillEntry as R, SkillDiscoveryResult as S, SkillMetadata as a, SkillContent as b, SkillResource as c, SkillConfig as d, RemoteSkillIndex as e, SkillDiscoveryError as f, SkillResourceType as g, SkillScope as h, SkillSource as i, SkillSourceType as j };

package/dist/types-BnpEOYV-.d.ts

@@ -0,0 +1,50 @@
+import { LanguageModel } from 'ai';
+import { R as ReasoningLevel } from './types-CQaXbRsS.js';
+import { T as Tool } from './tool-BHbyUAy3.js';
+
+/**
+ * Agent preset - a reusable configuration profile.
+ */
+interface Preset {
+    /** Unique identifier for this preset */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /**
+     * Tool allow patterns (glob-like).
+     * If provided, only tools matching these patterns are candidates.
+     */
+    allowTools?: string[];
+    /**
+     * Tool deny patterns (glob-like).
+     * Deny patterns apply only after allow matching, so explicit allows win.
+     */
+    denyTools?: string[];
+    /**
+     * Override system prompt.
+     * Use `{basePrompt}` to include the parent's system prompt.
+     */
+    systemPrompt?: string;
+    /** Override temperature (0-1). */
+    temperature?: number;
+    /** Override max steps. */
+    maxSteps?: number;
+    /** Override reasoning level. */
+    reasoningLevel?: ReasoningLevel;
+    /** Override model. */
+    model?: LanguageModel;
+}
+/**
+ * Result of applying a preset - ready for `fork()`.
+ */
+interface AppliedPreset {
+    name: string;
+    systemPrompt?: string;
+    tools?: Tool.AnyInfo[];
+    temperature?: number;
+    maxSteps?: number;
+    reasoningLevel?: ReasoningLevel;
+    model?: LanguageModel;
+}
+
+export type { AppliedPreset as A, Preset as P };