zidane 1.8.0 → 2.0.1

package/dist/skills.d.ts

@@ -1,55 +1,231 @@
-import { S as SkillConfig, b as SkillsConfig } from './types-CDI8Kmve.js';
-export { a as SkillResource } from './types-CDI8Kmve.js';
+import { d as AgentHooks, al as SkillActivationState, N as SkillConfig, ao as SkillSource, an as SkillDiagnostic, T as SkillsConfig } from './agent-D-ZFMbSd.js';
+export { ad as ActivationVia, ae as ActiveSkill, af as DeactivationReason, am as SkillActivationStateOptions, Q as SkillResource, az as createSkillActivationState } from './agent-D-ZFMbSd.js';
+import { Hookable } from 'hookable';
 import { b as ExecutionContext, c as ExecutionHandle } from './types-BpvTmawk.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+
+/**
+ * `allowed-tools` enforcement middleware.
+ *
+ * Installed by the agent on `tool:gate` and `mcp:tool:gate`. Computes the
+ * union of `allowedTools` patterns across currently-active skills; blocks any
+ * tool call whose `displayName` is not in that union. The three injected
+ * skills tools (`skills_use` / `skills_read` / `skills_run_script`) are
+ * implicitly allowed so a skill declaring an allow-list cannot lock out the
+ * scaffolding that lets it run at all.
+ *
+ * The match target is `displayName` (wire / LLM-facing name), not the
+ * canonical name, because skill authors write allow-list entries to match
+ * what the model sees.
+ */
+
+/** Tools that are always allowed regardless of the active skills' allow-list. */
+declare const IMPLICITLY_ALLOWED_SKILL_TOOLS: readonly string[];
+/**
+ * Register `tool:gate` / `mcp:tool:gate` handlers that enforce the union of
+ * `allowedTools` across active skills.
+ *
+ * No-op when no active skill declares an allow-list (permissive default —
+ * matches the spec's "experimental" note for `allowed-tools`).
+ *
+ * Returns an `uninstall` fn. The agent calls this at run end to detach the
+ * handlers and prevent cross-run hook leaks.
+ */
+declare function installAllowedToolsGate(hooks: Hookable<AgentHooks>, state: SkillActivationState): () => void;
 
 /**
  * Skill catalog generation.
  *
- * Builds the system prompt section that discloses available skills
- * to the agent, following progressive disclosure (tier 1: name + description only).
+ * Builds the system prompt section that discloses available skills to the
+ * agent — tier 1 of progressive disclosure per the Agent Skills spec.
+ *
+ * The catalog's behavioral prose branches on which activation mechanism is
+ * active for the run:
+ *
+ * - When the `skills_use` tool is auto-injected (the default for a non-empty
+ *   catalog), the prose tells the model to call `skills_use` with the skill's
+ *   name. The agent returns a structured `<skill_content>` block.
+ * - When the skills tool is opted out (`SkillsConfig.tool: false`), the prose
+ *   falls back to the file-read pattern — the model reads `SKILL.md` itself
+ *   via its file-read tool.
  */
 
+interface BuildCatalogOptions {
+    /**
+     * When true (the default), the prose instructs the model to call
+     * `skills_use`. Set to false when `SkillsConfig.tool === false` so the
+     * system prompt matches the active activation mechanism.
+     */
+    skillsToolRegistered?: boolean;
+    /**
+     * Name of the tool the model should use to read `SKILL.md` files when
+     * `skillsToolRegistered` is false. Defaults to `'read_file'`.
+     */
+    readToolName?: string;
+}
 /**
  * Build the skill catalog XML and behavioral instructions for the system prompt.
+ */
+declare function buildCatalog(skills: SkillConfig[], optionsOrReadToolName?: BuildCatalogOptions | string): string;
+
+/**
+ * Strict validators for Agent Skills.
  *
- * @param skills - Resolved skills to include (already filtered for excluded)
- * @param readToolName - Tool name the agent should use to read skill files (default: 'read_file')
+ * Applied on the authoring path (`defineSkill`, `writeSkillToDisk`). Parser-time
+ * validation is intentionally lenient — see `parseSkillFile` for diagnostic collection.
  */
-declare function buildCatalog(skills: SkillConfig[], readToolName?: string): string;
+
+/**
+ * A single issue surfaced by skill-authoring validation.
+ * Distinct from `ValidationResult` in `tools/validation.ts` (tool-input JSON
+ * schema validation) — different domain, different module.
+ */
+interface SkillValidationIssue {
+    /** Stable machine-readable code for consumer matching. */
+    code: string;
+    /** Human-readable description. */
+    message: string;
+    /** Frontmatter field name the issue relates to, when applicable. */
+    field?: string;
+}
+interface SkillValidationResult {
+    valid: boolean;
+    errors: SkillValidationIssue[];
+}
+/**
+ * Validate a skill name per the spec:
+ * - 1–64 characters
+ * - Lowercase alphanumeric + hyphens only
+ * - Must not start or end with a hyphen
+ * - Must not contain consecutive hyphens
+ *
+ * The parent-directory match is validated separately (it requires knowing the
+ * skill's `location`, which this function does not).
+ */
+declare function validateSkillName(name: string): boolean;
+/**
+ * Strict validation for a skill that is about to be authored / written to disk.
+ * Rejects anything that would violate the spec. Use the lenient parser path
+ * (`parseSkillFile`) for loading third-party skills.
+ */
+declare function validateSkillForWrite(skill: SkillConfig): SkillValidationResult;
+/**
+ * Validate that `relPath` stays inside `baseDir` when resolved.
+ *
+ * Rejects:
+ * - Absolute paths (`/etc/passwd`, `C:\…`)
+ * - Parent traversal (`..` segments that escape baseDir)
+ * - Null-byte tricks
+ *
+ * Returns `{ valid: true, absolutePath }` on success or `{ valid: false, error }`
+ * with a human-readable reason.
+ */
+declare function validateResourcePath(relPath: string, baseDir: string): {
+    valid: true;
+    absolutePath: string;
+} | {
+    valid: false;
+    error: string;
+};
+/**
+ * Parse a single `allowed-tools` entry into its tool name + optional argument pattern.
+ *
+ * Examples:
+ * - `Read` → `{ tool: 'Read' }`
+ * - `Bash(git:*)` → `{ tool: 'Bash', argPrefix: 'git' }`
+ */
+declare function parseAllowedToolPattern(entry: string): {
+    tool: string;
+    argPrefix?: string;
+} | null;
+/**
+ * Check whether a tool call (identified by its wire/displayName and argument input)
+ * matches a skill's allow-list entry.
+ *
+ * Matching rules (Zidane's interpretation of the spec's unspecified syntax):
+ * - Exact match: displayName === pattern (no parens).
+ * - Prefix match: for `Tool(arg:*)`, displayName === 'Tool' AND **any** string
+ *   value in the input object starts with `arg`. This is intentionally
+ *   permissive: it doesn't depend on a convention about which property carries
+ *   the "command" (schemas vary across tools), and for the common
+ *   `shell({ command: 'git …' })` shape it behaves identically to a "primary
+ *   string" rule.
+ * - For tools whose inputs carry no string values, the arg-match returns false.
+ */
+declare function matchesAllowedTool(displayName: string, input: Record<string, unknown>, pattern: string): boolean;
+/**
+ * Test whether a tool call is allowed by the union of `allowedTools` across a set
+ * of active skills. Returns `true` when the union is empty (permissive default)
+ * OR when any entry matches.
+ */
+declare function isToolAllowedByUnion(displayName: string, input: Record<string, unknown>, union: readonly string[]): boolean;
 
 /**
  * Skill discovery and parsing.
  *
  * Scans filesystem directories for SKILL.md files following the
  * Agent Skills specification (agentskills.io/specification).
+ *
+ * Parsing is intentionally **lenient** — per the spec's client-implementation
+ * guide: warn, don't block. Diagnostics are attached to the returned
+ * SkillConfig for host UIs to surface; only unrecoverable errors (missing
+ * description, unparseable YAML) skip the skill entirely.
  */
 
-/**
- * Validate a skill name per the Agent Skills spec:
- * 1-64 chars, lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens.
- */
-declare function validateSkillName(name: string): boolean;
 interface ParsedSkillFile {
     frontmatter: Record<string, unknown>;
     body: string;
+    diagnostics: SkillDiagnostic[];
 }
 /**
  * Parse a SKILL.md file into frontmatter + body.
- * Uses simple regex-based extraction (no external YAML lib needed for simple cases).
+ *
+ * Uses a simple regex-based YAML extractor that handles:
+ * - Flat key: value pairs
+ * - Quoted values
+ * - One-level nested maps (for `metadata:`)
+ * - Lenient recovery from unquoted-colon values (e.g.
+ *   `description: Use when: the user asks …`) via a quote-wrap retry.
  */
 declare function parseFrontmatter(content: string): ParsedSkillFile;
+interface ParseSkillOptions {
+    /** Source tag to attach to the returned SkillConfig. */
+    source?: SkillSource;
+}
 /**
- * Parse a SKILL.md file into a SkillConfig.
- * Returns null if the file is invalid (missing description).
+ * Parse a SKILL.md file into a SkillConfig (lenient).
+ *
+ * Returns `null` only when the skill is fundamentally unusable:
+ * - The file is missing
+ * - The description is absent (required by spec for disclosure)
+ *
+ * All other issues are surfaced as `SkillConfig.diagnostics` with severity
+ * `warning`. Deprecated top-level fields (`paths`, `model`, `thinking`) are
+ * auto-migrated into `metadata['zidane.*']`.
  */
-declare function parseSkillFile(filePath: string): Promise<SkillConfig | null>;
-declare function getDefaultScanPaths(): string[];
+declare function parseSkillFile(filePath: string, options?: ParseSkillOptions): Promise<SkillConfig | null>;
+/** A scan path paired with the source tag that should be attached to any skills found in it. */
+interface SourcedScanPath {
+    path: string;
+    source: SkillSource;
+}
 /**
- * Discover skills from filesystem paths.
+ * Return the default scan paths tagged by source. Project-scope paths come
+ * first; their skills therefore win on name collisions against user-scope
+ * skills (first-found wins in discovery).
+ */
+declare function getDefaultScanPaths(): SourcedScanPath[];
+/**
+ * Infer a source tag for a user-provided scan path.
+ * Paths under `$HOME` are treated as 'user'; everything else as 'project'.
+ */
+declare function inferSource(path: string): SkillSource;
+/**
+ * Discover skills from sourced filesystem paths.
  * Each path is scanned for subdirectories containing SKILL.md.
- * Later paths have lower priority (earlier skill with same name wins).
+ * Earlier paths have higher priority (first-found wins on name collision).
  */
-declare function discoverSkills(paths: string[]): Promise<SkillConfig[]>;
+declare function discoverSkills(paths: SourcedScanPath[]): Promise<SkillConfig[]>;
 
 /**
  * Shell interpolation for skill instructions.
@@ -84,12 +260,11 @@ declare function interpolateShellCommands(instructions: string, execution: Execu
 
 /**
  * Resolve all skills from a SkillsConfig:
- * 1. Write dynamic skills (config.write) to a temp directory
- * 2. Discover skills from scan paths (defaults + config.scan + written dir)
- * 3. Filter out exclude skills
  *
- * Written skills are materialized as proper SKILL.md files on disk,
- * so they participate in discovery like any other filesystem skill.
+ * 1. Materialize `config.write` entries to a temp directory, tagged as `inline`
+ * 2. Combine with default + user-provided scan paths (project-first, user-next)
+ * 3. Run lenient discovery
+ * 4. Apply filters: `exclude`, `enabled` allowlist, optional project-skill trust gate
  */
 declare function resolveSkills(config: SkillsConfig): Promise<SkillConfig[]>;
 /**
@@ -102,15 +277,21 @@ declare function mergeSkillsConfig(harness?: SkillsConfig, agent?: SkillsConfig)
 /**
  * Skill writer — materializes inline SkillConfig objects to disk as proper
  * SKILL.md files so they participate fully in the filesystem-based skill system.
+ *
+ * Strict-validates each skill before writing (see `validateSkillForWrite`).
  */
 
 /**
- * Write a SkillConfig to disk as a proper skill directory with SKILL.md.
+ * Write a `SkillConfig` to disk as a proper skill directory with SKILL.md.
  * Returns the path to the written SKILL.md file.
+ *
+ * Throws if the skill fails `validateSkillForWrite` — the authoring path is
+ * strict on purpose. For loading third-party skills, use `parseSkillFile`
+ * directly (lenient).
  */
 declare function writeSkillToDisk(skill: SkillConfig, targetDir: string): string;
 /**
- * Write multiple SkillConfig objects to a target directory.
+ * Write multiple `SkillConfig` objects to a target directory.
  * Each skill gets its own subdirectory with a SKILL.md file.
  * Returns the target directory path (for use as a scan path).
  */
@@ -118,8 +299,12 @@ declare function writeSkillsToDisk(skills: SkillConfig[], targetDir: string): st
 
 /**
  * Define an inline skill configuration.
- * Convenience wrapper for type safety — returns the config as-is.
+ *
+ * Strict-validates at author-time — throws if the config would be rejected by
+ * `writeSkillToDisk` or the spec. Source defaults to `'inline'`.
  */
-declare function defineSkill(config: SkillConfig): SkillConfig;
+declare function defineSkill(config: Omit<SkillConfig, 'source'> & {
+    source?: SkillConfig['source'];
+}): SkillConfig;
 
-export { SkillConfig, SkillsConfig, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, interpolateShellCommands, mergeSkillsConfig, parseFrontmatter, parseSkillFile, resolveSkills, validateSkillName, writeSkillToDisk, writeSkillsToDisk };
+export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillConfig, SkillDiagnostic, SkillSource, type SkillValidationIssue, type SkillValidationResult, SkillsConfig, type SourcedScanPath, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, mergeSkillsConfig, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };

package/dist/skills.js

@@ -1,29 +1,48 @@
 import {
   defineSkill
-} from "./chunk-CFLC2I7D.js";
+} from "./chunk-LVC7NQUZ.js";
 import {
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
+  createSkillActivationState,
   discoverSkills,
   getDefaultScanPaths,
+  inferSource,
+  installAllowedToolsGate,
   interpolateShellCommands,
+  isToolAllowedByUnion,
+  matchesAllowedTool,
   mergeSkillsConfig,
+  parseAllowedToolPattern,
   parseFrontmatter,
   parseSkillFile,
   resolveSkills,
+  validateResourcePath,
+  validateSkillForWrite,
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk
-} from "./chunk-4C6Y56CC.js";
+} from "./chunk-BCXXXJ3G.js";
+import "./chunk-7JTBBZ2U.js";
 export {
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
+  createSkillActivationState,
   defineSkill,
   discoverSkills,
   getDefaultScanPaths,
+  inferSource,
+  installAllowedToolsGate,
   interpolateShellCommands,
+  isToolAllowedByUnion,
+  matchesAllowedTool,
   mergeSkillsConfig,
+  parseAllowedToolPattern,
   parseFrontmatter,
   parseSkillFile,
   resolveSkills,
+  validateResourcePath,
+  validateSkillForWrite,
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk

package/dist/{spawn-EEv1Johs.d.ts → spawn-RoqpjYLZ.d.ts}

@@ -1,4 +1,4 @@
-import { W as ToolContext, X as ToolDef, o as HarnessConfig, h as AgentStats } from './agent-CWQ5XOw6.js';
+import { _ as ToolContext, $ as ToolDef, p as HarnessConfig, h as AgentStats } from './agent-D-ZFMbSd.js';
 
 /**
  * Interaction tool — lets the agent request structured input from the outside world.

package/dist/tools.d.ts

@@ -1,11 +1,10 @@
-export { g as glob } from './glob-j9gbk6xm.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-EEv1Johs.js';
-import { X as ToolDef } from './agent-CWQ5XOw6.js';
+export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-C4KFVla0.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-RoqpjYLZ.js';
+import { $ as ToolDef } from './agent-D-ZFMbSd.js';
 export { V as ValidationResult, v as validateToolArgs } from './validation-DOY_k7lW.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
-import './types-CDI8Kmve.js';
 
 declare const listFiles: ToolDef;
 

package/dist/tools.js

@@ -1,5 +1,8 @@
 import {
   createInteractionTool,
+  createSkillsReadTool,
+  createSkillsRunScriptTool,
+  createSkillsUseTool,
   createSpawnTool,
   glob,
   listFiles,
@@ -8,13 +11,16 @@ import {
   spawn,
   validateToolArgs,
   writeFile
-} from "./chunk-4N5ADW7A.js";
-import "./chunk-4C6Y56CC.js";
+} from "./chunk-PASFWG7S.js";
+import "./chunk-BCXXXJ3G.js";
 import "./chunk-SZA4FKW5.js";
-import "./chunk-TBC6MSVK.js";
-import "./chunk-FFFDQHMA.js";
+import "./chunk-PJUUYBKF.js";
+import "./chunk-7JTBBZ2U.js";
 export {
   createInteractionTool,
+  createSkillsReadTool,
+  createSkillsRunScriptTool,
+  createSkillsUseTool,
   createSpawnTool,
   glob,
   listFiles,

package/dist/types.d.ts

@@ -1,8 +1,7 @@
-export { A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, d as AgentHooks, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, j as CerebrasParams, k as ChildRunStats, l as ClassifiedError, m as ClassifiedErrorKind, n as CreateSessionOptions, H as Harness, o as HarnessConfig, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, R as RemoteStoreOptions, x as RunHookMap, S as Session, y as SessionContentBlock, z as SessionData, B as SessionEndStatus, D as SessionHookContext, E as SessionMessage, F as SessionRun, G as SessionStore, J as SessionTurn, K as SpawnHookContext, L as SqliteStoreOptions, N as StreamCallbacks, Q as StreamHookContext, T as StreamOptions, U as ThinkingLevel, V as ToolCall, W as ToolContext, X as ToolDef, Y as ToolExecutionMode, Z as ToolHookContext, _ as ToolMap, $ as ToolResult, a0 as ToolSpec, a1 as TurnFinishReason, a2 as TurnResult, a3 as TurnUsage, a4 as matchesContextExceeded } from './agent-CWQ5XOw6.js';
+export { A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, d as AgentHooks, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, l as ChildRunStats, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, H as Harness, p as HarnessConfig, I as ImageContent, M as McpConnection, q as McpServerConfig, r as McpToolHookContext, O as OAuthRefreshHookContext, s as OpenAIParams, t as OpenRouterParams, P as PromptDocumentPart, u as PromptImagePart, v as PromptPart, w as PromptTextPart, x as Provider, y as ProviderCapabilities, R as RemoteStoreOptions, z as RunHookMap, S as Session, B as SessionContentBlock, D as SessionData, E as SessionEndStatus, F as SessionHookContext, G as SessionMessage, J as SessionRun, K as SessionStore, L as SessionTurn, N as SkillConfig, Q as SkillResource, T as SkillsConfig, U as SpawnHookContext, V as StreamCallbacks, W as StreamHookContext, X as StreamOptions, Y as ThinkingLevel, Z as ToolCall, _ as ToolContext, $ as ToolDef, a0 as ToolExecutionMode, a1 as ToolHookContext, a2 as ToolMap, a3 as ToolResult, a4 as ToolResultContent, a5 as ToolResultImageContent, a6 as ToolResultTextContent, a7 as ToolSpec, a8 as TurnFinishReason, a9 as TurnResult, aa as TurnUsage, ab as matchesContextExceeded, ac as toolResultToText } from './agent-D-ZFMbSd.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, b as ExecutionContext, c as ExecutionHandle, S as SpawnConfig } from './types-BpvTmawk.js';
 export { S as SandboxProvider } from './sandbox-CW72eLDP.js';
-export { S as SkillConfig, a as SkillResource, b as SkillsConfig } from './types-CDI8Kmve.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-EEv1Johs.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-RoqpjYLZ.js';
 export { V as ValidationResult } from './validation-DOY_k7lW.js';
 import 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/types.js

@@ -1,14 +1,20 @@
+import {
+  toolResultToText
+} from "./chunk-MYWDHD7C.js";
 import {
   AgentAbortedError,
   AgentContextExceededError,
   AgentProviderError,
+  AgentToolNotAllowedError,
   CONTEXT_EXCEEDED_MESSAGE_PATTERNS,
   matchesContextExceeded
-} from "./chunk-FFFDQHMA.js";
+} from "./chunk-7JTBBZ2U.js";
 export {
   AgentAbortedError,
   AgentContextExceededError,
   AgentProviderError,
+  AgentToolNotAllowedError,
   CONTEXT_EXCEEDED_MESSAGE_PATTERNS,
-  matchesContextExceeded
+  matchesContextExceeded,
+  toolResultToText
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "1.8.0",
+  "version": "2.0.1",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,
@@ -46,6 +46,10 @@
       "import": "./dist/session.js",
       "types": "./dist/session.d.ts"
     },
+    "./session/sqlite": {
+      "import": "./dist/session/sqlite.js",
+      "types": "./dist/session/sqlite.d.ts"
+    },
     "./skills": {
       "import": "./dist/skills.js",
       "types": "./dist/skills.d.ts"
@@ -67,23 +71,28 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.88.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
     "@yaelg/pi-ai": "^0.66.1",
     "chalk": "^5.6.2",
     "hookable": "^6.1.0",
     "md4x": "^0.0.25"
   },
   "peerDependencies": {
+    "@anthropic-ai/sdk": "^0.88.0",
+    "@modelcontextprotocol/sdk": ">=1.11.0",
     "zod": ">=4.0.0"
   },
   "peerDependenciesMeta": {
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
     "zod": {
       "optional": true
     }
   },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.88.0",
     "@antfu/eslint-config": "^8.1.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@types/bun": "^1.3.12",
     "@types/dockerode": "^4.0.1",
     "bumpp": "^11.0.1",