zidane 4.0.2 → 4.1.3

package/dist/sandbox-D7v6Wy62.d.ts

@@ -1,28 +0,0 @@
-import { S as SpawnConfig, E as ExecResult, a as ExecutionContext } from './types-Bai5rKpa.js';
-
-/**
- * Remote sandbox execution context.
- *
- * Offloads execution to a remote sandbox API (e.g. Rivet, E2B).
- * Specific providers implement the SandboxProvider interface.
- */
-
-interface SandboxProvider {
-    name: string;
-    spawn: (config: SpawnConfig) => Promise<{
-        id: string;
-        cwd: string;
-    }>;
-    exec: (sandboxId: string, command: string, options?: {
-        cwd?: string;
-        env?: Record<string, string>;
-        timeout?: number;
-    }) => Promise<ExecResult>;
-    readFile: (sandboxId: string, path: string) => Promise<string>;
-    writeFile: (sandboxId: string, path: string, content: string) => Promise<void>;
-    listFiles: (sandboxId: string, path: string) => Promise<string[]>;
-    destroy: (sandboxId: string) => Promise<void>;
-}
-declare function createSandboxContext(provider: SandboxProvider): ExecutionContext;
-
-export { type SandboxProvider as S, createSandboxContext as c };

package/dist/skills-use-DwZrNmcw.d.ts

@@ -1,80 +0,0 @@
-import { a7 as ToolDef, X as SkillConfig, V as SkillActivationState, A as AgentHooks } from './agent-BAHrGtqu.js';
-import { Hookable } from 'hookable';
-
-/**
- * Surgical edit — replace `old_string` with `new_string` in a single file.
- *
- * Mirrors Claude Code's `Edit` semantics so models post-trained on Anthropic's
- * tool surface need no relearning. Fails clearly when `old_string` isn't unique
- * (unless `replace_all: true`) and when not found, with a nearest-match preview
- * so the model can recover without a separate `read_file` round-trip.
- */
-declare const edit: ToolDef;
-
-declare const glob: ToolDef;
-
-declare const grep: ToolDef;
-
-declare const multiEdit: ToolDef;
-
-/**
- * `skills_read` tool — reads a bundled resource file from an active skill.
- *
- * Requires the skill to be active (model must have called `skills_use` first).
- * Paths are validated against the skill's `baseDir` to prevent directory
- * traversal. File I/O goes through `ctx.execution.readFile` so docker/sandbox
- * execution contexts work identically to in-process.
- */
-
-interface SkillsReadToolOptions {
-    catalog: readonly SkillConfig[];
-    state: SkillActivationState;
-}
-declare function createSkillsReadTool(options: SkillsReadToolOptions): ToolDef;
-
-/**
- * `skills_run_script` tool — executes a script from an active skill's
- * `scripts/` directory via the agent's execution context.
- *
- * Path is validated against the skill's `baseDir` and constrained to the
- * `scripts/` subdirectory. Timeout is configurable via
- * `SkillsConfig.scriptTimeoutMs` (default 60 s).
- */
-
-interface SkillsRunScriptToolOptions {
-    catalog: readonly SkillConfig[];
-    state: SkillActivationState;
-    /** Script timeout in milliseconds. Default 60000. */
-    scriptTimeoutMs?: number;
-}
-declare function createSkillsRunScriptTool(options: SkillsRunScriptToolOptions): ToolDef;
-
-/**
- * `skills_use` tool — activates a skill and returns its full instructions.
- *
- * Implements tier 2 of progressive disclosure per the Agent Skills spec.
- * Body is frontmatter-stripped (the model gets the markdown only, wrapped in
- * `<skill_content>` tags so downstream context management can identify it).
- * Shell-interpolation (`!` `` `cmd` ``) runs per-activation rather than once
- * per agent, so values like `gh pr diff` reflect the current state.
- */
-
-interface SkillsUseToolOptions {
-    /** Resolved skills catalog for this run. */
-    catalog: readonly SkillConfig[];
-    /** Per-agent activation state the tool mutates. */
-    state: SkillActivationState;
-    /** Agent hooks — used to fire `skills:activate` on first activation. */
-    hooks: Hookable<AgentHooks>;
-}
-/**
- * Factory for `skills_use`. Auto-injected into the agent's tool set by the
- * agent runtime when a non-empty skills catalog is available (unless
- * `SkillsConfig.tool === false`).
- *
- * The tool schema's `name` property is `enum`-constrained to the resolved
- * catalog so the LLM cannot hallucinate a skill that doesn't exist.
- */
-declare function createSkillsUseTool(options: SkillsUseToolOptions): ToolDef;
-
-export { type SkillsReadToolOptions as S, type SkillsRunScriptToolOptions as a, type SkillsUseToolOptions as b, createSkillsReadTool as c, createSkillsRunScriptTool as d, createSkillsUseTool as e, edit as f, glob as g, grep as h, multiEdit as m };

package/dist/types-Bai5rKpa.d.ts

@@ -1,89 +0,0 @@
-/**
- * Execution context types.
- *
- * An execution context defines *where* and *how* an agent's tools run.
- * The agent loop and tools interact through this interface without knowing
- * whether they're running in-process, in a Docker container, or in a
- * remote sandbox.
- */
-interface ContextCapabilities {
-    /** Can execute shell commands */
-    shell: boolean;
-    /** Can read/write files in a workspace */
-    filesystem: boolean;
-    /** Can make outbound network requests */
-    network: boolean;
-    /** Has GPU access */
-    gpu: boolean;
-}
-/** Opaque handle to a running execution context instance */
-interface ExecutionHandle {
-    id: string;
-    type: ContextType;
-    /** Working directory within the context */
-    cwd: string;
-}
-interface ExecResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-interface SpawnConfig {
-    /** Working directory (created if it doesn't exist) */
-    cwd?: string;
-    /** Environment variables */
-    env?: Record<string, string>;
-    /** Docker image (only for 'docker' context) */
-    image?: string;
-    /** Resource limits */
-    limits?: {
-        /** Memory limit in MB */
-        memory?: number;
-        /** CPU limit (e.g. '1.0' = 1 core) */
-        cpu?: string;
-        /** Timeout in seconds for the entire context lifetime */
-        timeout?: number;
-    };
-    /** Sandbox provider config (only for 'sandbox' context) */
-    sandbox?: {
-        provider: string;
-        apiKey?: string;
-        [key: string]: unknown;
-    };
-}
-type ContextType = 'process' | 'docker' | 'sandbox';
-interface ExecutionContext {
-    /** Context type identifier */
-    readonly type: ContextType;
-    /** What this context supports */
-    readonly capabilities: ContextCapabilities;
-    /** Spawn a new execution environment */
-    spawn: (config?: SpawnConfig) => Promise<ExecutionHandle>;
-    /** Execute a shell command in the context */
-    exec: (handle: ExecutionHandle, command: string, options?: {
-        cwd?: string;
-        env?: Record<string, string>;
-        timeout?: number;
-    }) => Promise<ExecResult>;
-    /** Read a file from the context's filesystem */
-    readFile: (handle: ExecutionHandle, path: string) => Promise<string>;
-    /**
-     * Read a file from the context's filesystem as raw bytes.
-     *
-     * Used by `read_file` to dispatch image / binary files into the multimodal
-     * `ToolResultContent[]` route. Optional — when not implemented, the tool
-     * falls back to `base64 < path` via the `exec` seam, which works in any
-     * shell-capable context. Implementations that already have a native
-     * binary read (in-process `fs.readFile` without encoding, container API,
-     * sandbox SDK) should override for the latency win.
-     */
-    readFileBinary?: (handle: ExecutionHandle, path: string) => Promise<Uint8Array>;
-    /** Write a file to the context's filesystem */
-    writeFile: (handle: ExecutionHandle, path: string, content: string) => Promise<void>;
-    /** List files in a directory */
-    listFiles: (handle: ExecutionHandle, path: string) => Promise<string[]>;
-    /** Destroy the execution environment and clean up resources */
-    destroy: (handle: ExecutionHandle) => Promise<void>;
-}
-
-export type { ContextCapabilities as C, ExecResult as E, SpawnConfig as S, ExecutionContext as a, ContextType as b, ExecutionHandle as c };

package/dist/validation-Pm--dQEU.d.ts

@@ -1,185 +0,0 @@
-import { a6 as ToolContext, a7 as ToolDef, j as AgentStats, aK as ChildRunStats } from './agent-BAHrGtqu.js';
-import { Preset } from './presets.js';
-
-/**
- * Interaction tool — lets the agent request structured input from the outside world.
- *
- * Not included in any preset by default. Add it explicitly:
- *
- *   import { createInteractionTool } from 'zidane'
- *
- *   const askUser = createInteractionTool({
- *     schema: { type: 'object', properties: { question: { type: 'string' } }, required: ['question'] },
- *     onRequest: async (payload) => {
- *       const answer = await promptUser(payload.question)
- *       return { answer }
- *     },
- *   })
- *
- *   const preset = definePreset({ name: 'interactive', tools: { ...basicTools, ask_user: askUser } })
- */
-
-interface InteractionToolOptions {
-    /** JSON Schema for the request payload the model sends */
-    schema: Record<string, unknown>;
-    /** Tool name (default: 'interaction') */
-    name?: string;
-    /** Tool description shown to the model */
-    description?: string;
-    /** Called when the model invokes this tool. Receives the validated payload and tool context, returns data for the model. */
-    onRequest: (payload: Record<string, unknown>, ctx: ToolContext) => Promise<Record<string, unknown> | string>;
-}
-/**
- * Create an interaction tool that lets the agent request structured input.
- *
- * The model calls this tool with a payload matching the schema.
- * `onRequest` is called with the payload and should return the response
- * (string or object) that gets sent back to the model as the tool result.
- */
-declare function createInteractionTool(options: InteractionToolOptions): ToolDef;
-
-/**
- * Spawn tool — create sub-agents from a parent agent.
- *
- * A configurable factory that reads the parent's preset-y fields from ToolContext.
- *
- * Usage:
- * ```ts
- * import { createSpawnTool } from 'zidane'
- * import { definePreset, basicTools } from 'zidane/presets'
- *
- * const preset = definePreset({
- *   name: 'orchestrator',
- *   tools: { ...basicTools, spawn: createSpawnTool({ maxConcurrent: 5 }) },
- * })
- * ```
- *
- * Each `createSpawnTool()` call returns a fresh instance with its own
- * concurrency counter, depth cap, and child-stats accumulator — never
- * share an instance across unrelated parent agents.
- *
- * Key guarantees:
- * - **Depth-capped** to `maxDepth` (default 3) to prevent infinite recursion.
- * - **Concurrency slot is reserved synchronously** before any `await`, so a
- *   parent running tools in parallel cannot exceed `maxConcurrent`.
- * - **Pre-aborted signals short-circuit** without paying agent-spawn cost.
- * - **Abort / timeout / error are surfaced distinctly** in the returned text
- *   and via `ChildRunStats.status` on `spawn:complete`.
- * - **`agent.destroy()` errors never mask the original run error** (captured
- *   and emitted via `spawn:error` but the primary error wins).
- * - **Child hooks bubble** to the parent as `child:*` events when
- *   `forwardHooks` is set (default `true`).
- * - **Persistence** via `persist: true` — child runs get appended to the
- *   parent's session with `parentRunId` wired, so the run tree is
- *   reconstructible from a stored `SessionData`.
- */
-
-interface ChildAgent {
-    id: string;
-    task: string;
-    startedAt: number;
-    /** Subagent depth — 1 for a direct child of a top-level agent. */
-    depth: number;
-}
-interface SpawnToolState {
-    /** Currently running children. */
-    readonly children: ReadonlyMap<string, ChildAgent>;
-    /**
-     * Cumulative stats across every completed direct child of this spawn-tool
-     * instance (returns a copy). Each child's contribution is the cumulative
-     * `AgentStats` returned by its `agent.run()` — so
-     * `totalIn`/`totalOut`/`totalCacheRead`/`totalCacheCreation` cover the
-     * entire subtree (children + grandchildren + …), while `turns` and
-     * `elapsed` stay parent-loop-only per child and are summed across direct
-     * children. `elapsed` over-counts when children ran in parallel.
-     *
-     * Lives across multiple parent runs that share this instance.
-     */
-    readonly totalChildStats: Readonly<AgentStats>;
-}
-interface SpawnToolOptions {
-    /** Maximum concurrent sub-agents (default: 3). */
-    maxConcurrent?: number;
-    /**
-     * Maximum subagent depth. 0 disables spawning entirely; 1 allows top-level
-     * spawns but forbids grandchildren; 3 (default) allows three levels of
-     * recursion — enough for most orchestration patterns, a sharp ceiling
-     * against runaway loops.
-     */
-    maxDepth?: number;
-    /** Child model override. */
-    model?: string;
-    /** Child system prompt override. Per-spawn `input.system` takes precedence. */
-    system?: string;
-    /** Child thinking level. */
-    thinking?: 'off' | 'minimal' | 'low' | 'medium' | 'high';
-    /** Preset override for children. Shallow-merged over the parent's preset (parent fields still win for anything left unset). */
-    preset?: Preset;
-    /**
-     * Per-child timeout, in milliseconds. When the child exceeds it the spawn
-     * tool returns a timeout marker, fires `spawn:error`, and destroys the
-     * child agent. Default: none.
-     */
-    timeoutMs?: number;
-    /**
-     * When `true` and the parent has a session, the child reuses the parent's
-     * session — child turns are appended with the child's own `runId`, and the
-     * resulting `SessionRun` carries `parentRunId` so the tree is
-     * reconstructible. Default: `false` (child is in-memory only).
-     */
-    persist?: boolean;
-    /**
-     * Forward a curated subset of child hook events (`stream:*`, `tool:*`,
-     * `turn:after`) onto the parent's hook bus as `child:*` events. Default:
-     * `true`. Grandchildren bubble through their child transparently.
-     */
-    forwardHooks?: boolean;
-    /** Called when a child agent starts. */
-    onSpawn?: (child: ChildAgent) => void;
-    /** Called when a child agent completes (success, abort, timeout, or error). */
-    onComplete?: (child: ChildAgent, stats: AgentStats, status: NonNullable<ChildRunStats['status']>) => void;
-}
-/**
- * Create a configured spawn tool.
- *
- * State (`children`, `totalChildStats`, counters, active count) is scoped to
- * the returned instance. Multiple parent agents using the same instance will
- * share counters + stats + concurrency slots — call `createSpawnTool()` per
- * agent (or use the stateless default `spawn`) to keep them isolated.
- */
-declare function createSpawnTool(options?: SpawnToolOptions): ToolDef & SpawnToolState;
-
-/**
- * Tool argument validation against JSON Schema-style inputSchema.
- *
- * Two passes:
- *   1. Required-field presence. Missing or null/undefined required fields fail.
- *   2. Top-level type checks with **best-effort coercion**. Small/OSS models
- *      routinely send `"true"` for a `boolean` field or `"42"` for a `number`,
- *      and rejecting outright forces a confusing retry. Instead, we auto-heal
- *      coerce when the conversion is unambiguous, fail only when the value
- *      cannot be reasonably normalized to any of the declared types.
- *
- * Nested validation is intentionally out of scope — keep it cheap and let the
- * tool's `execute` body assert deeper invariants.
- */
-interface ValidationResult {
-    valid: boolean;
-    /** Human-readable reason. Present on failure only. */
-    error?: string;
-    /**
-     * Possibly-coerced input. Present iff `valid: true`. Tools should call
-     * `execute(coercedInput, ctx)` so auto-healed values reach the tool body.
-     * When no coercion was applied, this is reference-equal to the input.
-     */
-    coercedInput?: Record<string, unknown>;
-    /**
-     * Names of fields whose values were coerced. Empty when nothing changed.
-     * Useful for telemetry (`validation:reject` on failure already carries the
-     * reason; this is the success-path equivalent).
-     */
-    coercions?: readonly string[];
-}
-declare function validateToolArgs(input: Record<string, unknown>, schema: Record<string, unknown>): ValidationResult;
-
-export { type ChildAgent as C, type InteractionToolOptions as I, type SpawnToolOptions as S, type ValidationResult as V, type SpawnToolState as a, createSpawnTool as b, createInteractionTool as c, validateToolArgs as v };