zidane 4.0.2 → 4.1.4

package/dist/index-DPsd0qwm.d.ts

@@ -0,0 +1,254 @@
+import { c as ExecutionContext, l as ExecutionHandle } from "./index-BfSdALzk.js";
+import { C as SkillsConfig, S as SkillSource, b as SkillDiagnostic, c as SkillActivationState, n as AgentHooks, y as SkillConfig } from "./agent-BoV5Twdl.js";
+import { Hookable } from "hookable";
+
+//#region src/skills/allowed-tools.d.ts
+/** 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;
+//#endregion
+//#region src/skills/catalog.d.ts
+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[], options?: BuildCatalogOptions): string;
+//#endregion
+//#region src/skills/discovery.d.ts
+interface ParsedSkillFile {
+  frontmatter: Record<string, unknown>;
+  body: string;
+  diagnostics: SkillDiagnostic[];
+}
+/**
+ * Parse a SKILL.md file into frontmatter + body.
+ *
+ * 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 (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, 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;
+}
+/**
+ * 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.
+ * Earlier paths have higher priority (first-found wins on name collision).
+ */
+declare function discoverSkills(paths: SourcedScanPath[]): Promise<SkillConfig[]>;
+//#endregion
+//#region src/skills/interpolate.d.ts
+/**
+ * Interpolate shell commands in skill instructions.
+ *
+ * Runs each !\`command\` through the execution context and replaces
+ * the placeholder with the command's stdout. If a command fails,
+ * the placeholder is replaced with an error message.
+ *
+ * @param instructions - Raw skill instructions with potential !\`command\` patterns
+ * @param execution - The execution context to run commands in
+ * @param handle - The active execution handle
+ * @returns Instructions with all !\`command\` patterns replaced by output
+ */
+declare function interpolateShellCommands(instructions: string, execution: ExecutionContext, handle: ExecutionHandle): Promise<string>;
+//#endregion
+//#region src/skills/resolve.d.ts
+/**
+ * Resolved-skills bundle: the materialized list plus a `cleanup` fn that
+ * removes any temporary directory created for `config.write` skills.
+ *
+ * Inline skills must live on disk for the lifetime of the agent (the
+ * `skills_read` / `skills_run_script` tools resolve relative paths against
+ * `baseDir`), so cleanup is deferred to `agent.destroy()`. When no temp
+ * directory was created, `cleanup` is a no-op.
+ */
+interface ResolvedSkillsBundle {
+  skills: SkillConfig[];
+  cleanup: () => void;
+}
+/**
+ * Resolve all skills from a SkillsConfig:
+ *
+ * 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
+ *
+ * Returns `{ skills, cleanup }` — call `cleanup()` on agent destroy to remove
+ * the temp directory created for inline `config.write` skills. The agent
+ * factory wires this automatically; standalone callers must invoke it
+ * themselves to avoid leaking OS temp.
+ */
+declare function resolveSkills(config: SkillsConfig): Promise<ResolvedSkillsBundle>;
+//#endregion
+//#region src/skills/validate.d.ts
+/**
+ * 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;
+//#endregion
+//#region src/skills/writer.d.ts
+/**
+ * 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.
+ * Each skill gets its own subdirectory with a SKILL.md file.
+ * Returns the target directory path (for use as a scan path).
+ */
+declare function writeSkillsToDisk(skills: SkillConfig[], targetDir: string): string;
+//#endregion
+//#region src/skills/index.d.ts
+/**
+ * Define an inline skill configuration.
+ *
+ * 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: Omit<SkillConfig, 'source'> & {
+  source?: SkillConfig['source'];
+}): SkillConfig;
+//#endregion
+export { installAllowedToolsGate as S, inferSource as _, SkillValidationResult as a, buildCatalog as b, parseAllowedToolPattern as c, validateSkillName as d, resolveSkills as f, getDefaultScanPaths as g, discoverSkills as h, SkillValidationIssue as i, validateResourcePath as l, SourcedScanPath as m, writeSkillToDisk as n, isToolAllowedByUnion as o, interpolateShellCommands as p, writeSkillsToDisk as r, matchesAllowedTool as s, defineSkill as t, validateSkillForWrite as u, parseFrontmatter as v, IMPLICITLY_ALLOWED_SKILL_TOOLS as x, parseSkillFile as y };
+//# sourceMappingURL=index-DPsd0qwm.d.ts.map

package/dist/index-DPsd0qwm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DPsd0qwm.d.ts","names":[],"sources":["../src/skills/allowed-tools.ts","../src/skills/catalog.ts","../src/skills/discovery.ts","../src/skills/interpolate.ts","../src/skills/resolve.ts","../src/skills/validate.ts","../src/skills/writer.ts","../src/skills/index.ts"],"mappings":";;;;;;cAuBa,8BAAA;;;;;;;;;;ACHb;iBDmBgB,uBAAA,CACd,KAAA,EAAO,QAAA,CAAS,UAAA,GAChB,KAAA,EAAO,oBAAA;;;UCrBQ,mBAAA;EDoBR;;;;;ECdP,oBAAA;EDe2B;;;;ECV3B,YAAA;AAAA;;;;iBAMc,YAAA,CACd,MAAA,EAAQ,WAAA,IACR,OAAA,GAAS,mBAAA;;;UCCD,eAAA;EACR,WAAA,EAAa,MAAA;EACb,IAAA;EACA,WAAA,EAAa,eAAA;AAAA;;;;;;;;;;;iBAaC,gBAAA,CAAiB,OAAA,WAAkB,eAAA;AAAA,UA0MzC,iBAAA;ED9O0B;ECgPlC,MAAA,GAAS,WAAA;AAAA;;AD/NX;;;;;;;;;;iBC6OsB,cAAA,CACpB,QAAA,UACA,OAAA,GAAS,iBAAA,GACR,OAAA,CAAQ,WAAA;;UA0MM,eAAA;EACf,IAAA;EACA,MAAA,EAAQ,WAAA;AAAA;;;;;;iBAQM,mBAAA,CAAA,GAAuB,eAAA;;;AAjbvC;;iBAkcgB,WAAA,CAAY,IAAA,WAAe,WAAA;;;AArY1C;;;iBAkZqB,cAAA,CAAe,KAAA,EAAO,eAAA,KAAoB,OAAA,CAAQ,WAAA;;;;;;;;;;;;;;;iBC1elD,wBAAA,CACpB,YAAA,UACA,SAAA,EAAW,gBAAA,EACX,MAAA,EAAQ,eAAA,GACP,OAAA;;;AHVH;;;;;AAgBA;;;;AAhBA,UIGiB,oBAAA;EACf,MAAA,EAAQ,WAAA;EACR,OAAA;AAAA;;;;;;;;;;;AHRF;;;iBGwBsB,aAAA,CAAc,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,oBAAA;;;;;;AJLnE;;UKCiB,oBAAA;ELAC;EKEhB,IAAA;ELDO;EKGP,OAAA;ELH2B;EKK3B,KAAA;AAAA;AAAA,UAGe,qBAAA;EACf,KAAA;EACA,MAAA,EAAQ,oBAAA;AAAA;;;;;AJ/BV;;;;;AAiBA;iBI+BgB,iBAAA,CAAkB,IAAA;;;;;;iBAmBlB,qBAAA,CAAsB,KAAA,EAAO,WAAA,GAAc,qBAAA;;;;;;AH3E4B;;;;;;iBGiLvE,oBAAA,CACd,OAAA,UACA,OAAA;EACG,KAAA;EAAa,YAAA;AAAA;EAA2B,KAAA;EAAc,KAAA;AAAA;;;;AH3E1D;;;;iBG0He,uBAAA,CAAwB,KAAA;EAAkB,IAAA;EAAc,SAAA;AAAA;;;;;;;;;;;;;AHgPxE;;iBGnNgB,kBAAA,CACd,WAAA,UACA,KAAA,EAAO,MAAA,mBACP,OAAA;;;;;;iBAyBc,oBAAA,CACd,WAAA,UACA,KAAA,EAAO,MAAA,mBACP,KAAA;;;;;;ALpQF;;;;;iBM8BgB,gBAAA,CAAiB,KAAA,EAAO,WAAA,EAAa,SAAA;;;;;;iBAoCrC,iBAAA,CAAkB,MAAA,EAAQ,WAAA,IAAe,SAAA;;;;;;;;;iBCnDzC,WAAA,CAAY,MAAA,EAAQ,IAAA,CAAK,WAAA;EAA2B,MAAA,GAAS,WAAA;AAAA,IAA0B,WAAA"}

package/dist/index.d.ts

@@ -1,95 +1,5 @@
-import { A as AgentHooks } from './agent-BAHrGtqu.js';
-export { a as ActivationVia, b as ActiveSkill, c as Agent, d as AgentAbortedError, e as AgentBehavior, f as AgentContextExceededError, g as AgentOptions, h as AgentProviderError, i as AgentRunOptions, j as AgentStats, k as AgentToolNotAllowedError, l as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, m as CerebrasParams, n as ClassifiedError, o as ClassifiedErrorKind, p as CreateSessionOptions, D as DeactivationReason, F as FileMapAdapter, q as FileMapStoreOptions, M as McpConnection, r as McpServerConfig, s as McpToolHookContext, O as OAuthRefreshHookContext, t as OpenAICompatAuthHeader, u as OpenAICompatHttpError, v as OpenAICompatParams, w as OpenAIParams, x as OpenRouterParams, P as PromptDocumentPart, y as PromptImagePart, z as PromptPart, B as PromptTextPart, E as Provider, G as ProviderCapabilities, R as RemoteStoreOptions, H as RunHookMap, I as Session, J as SessionContentBlock, K as SessionData, L as SessionEndStatus, N as SessionHookContext, Q as SessionMessage, T as SessionRun, S as SessionStore, U as SessionTurn, V as SkillActivationState, W as SkillActivationStateOptions, X as SkillConfig, Y as SkillDiagnostic, Z as SkillResource, _ as SkillSource, $ as SkillsConfig, a0 as SpawnHookContext, a1 as StreamCallbacks, a2 as StreamHookContext, a3 as StreamOptions, a4 as ThinkingLevel, a5 as ToolCall, a6 as ToolContext, a7 as ToolDef, a8 as ToolExecutionMode, a9 as ToolHookContext, aa as ToolMap, ab as ToolResult, ac as ToolResultContent, ad as ToolResultImageContent, ae as ToolResultTextContent, af as ToolSpec, ag as TurnFinishReason, ah as TurnResult, ai as TurnUsage, aj as anthropic, ak as autoDetectAndConvert, al as cerebras, am as classifyOpenAICompatError, an as connectMcpServers, ao as createAgent, ap as createFileMapStore, aq as createMemoryStore, ar as createRemoteStore, as as createSession, at as createSkillActivationState, au as fromAnthropic, av as fromOpenAI, aw as loadSession, ax as mapOAIFinishReason, ay as matchesContextExceeded, az as normalizeMcpBlocks, aA as normalizeMcpServers, aB as openai, aC as openaiCompat, aD as openrouter, aE as resultToString, aF as toAnthropic, aG as toOpenAI, aH as toTypedError, aI as toolOutputByteLength, aJ as toolResultToText } from './agent-BAHrGtqu.js';
-export { createDockerContext, createProcessContext } from './contexts.js';
-export { S as SandboxProvider, c as createSandboxContext } from './sandbox-D7v6Wy62.js';
-export { C as ContextCapabilities, b as ContextType, E as ExecResult, a as ExecutionContext, c as ExecutionHandle, S as SpawnConfig } from './types-Bai5rKpa.js';
-export { Preset, basic, basicTools, definePreset } from './presets.js';
-export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillValidationIssue, SkillValidationResult, SourcedScanPath, buildCatalog, defineSkill, discoverSkills, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk } from './skills.js';
-export { ModelUsage, flattenTurns, statsByModel } from './types.js';
-export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, f as edit, g as glob, h as grep, m as multiEdit } from './skills-use-DwZrNmcw.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, V as ValidationResult, c as createInteractionTool, b as createSpawnTool, v as validateToolArgs } from './validation-Pm--dQEU.js';
-import { Hookable } from 'hookable';
-import '@modelcontextprotocol/sdk/client/index.js';
-
-/**
- * Tracing helper — wraps agent lifecycle hooks in caller-provided spans.
- *
- * Zidane is hooks-native; rather than introducing a plugin abstraction just for
- * observability, we ship a small helper that turns an arbitrary `startSpan`
- * function into a bundle of hook handlers. Works with Sentry, OpenTelemetry,
- * Datadog — any tracer that can hand back an object with an `end()` method.
- *
- * The helper:
- * - Starts a `turn:${n}` span on `turn:before`, ends it on `turn:after`.
- * - Starts a `tool:${name}` span on `tool:before`, ends it on `tool:after` / `tool:error`.
- * - Starts a `mcp:${server}:${tool}` span on `mcp:tool:before`, ends it on `mcp:tool:after` / `mcp:tool:error`.
- * - On `agent:done` closes any spans still open (defensive — normally all tool/turn
- *   spans have matching end hooks, but an abort mid-execution can leave dangling ones).
- *
- * Returns an `install(hooks)` helper that registers every handler at once and
- * yields an `uninstall()` function for cleanup. Safe across multiple runs.
- */
-
-/** Minimal span shape — any tracer that provides these two methods is compatible. */
-interface Span {
-    /** Close the span. Called exactly once per span. */
-    end: () => void;
-    /** Optional: attach additional attributes after the span is started (ignored if unsupported). */
-    setAttributes?: (attrs: Record<string, unknown>) => void;
-}
-/** Function that opens a span. Caller-provided so we stay tracer-agnostic. */
-type StartSpan = (name: string, attrs?: Record<string, unknown>) => Span;
-interface TracingHooksOptions {
-    /** Tracer seam. Receives a span name + attributes; must return a `Span`. */
-    startSpan: StartSpan;
-    /**
-     * Optional attribute namespace. Prepended to every span name (e.g. `"agent"` →
-     * span names like `agent/turn:0`, `agent/tool:Bash`).
-     */
-    namespace?: string;
-}
-/** Value returned by {@link createTracingHooks} — install entrypoint. */
-interface TracingHookSet {
-    /**
-     * Attach every hook handler to the given agent hooks instance.
-     *
-     * @returns an `uninstall` function that detaches every handler and closes any
-     * still-open spans. Safe to call multiple times.
-     */
-    install: (hooks: Hookable<AgentHooks>) => () => void;
-}
-/**
- * Build a set of tracing hook handlers that can be installed on an agent.
- *
- * @example Sentry
- * ```ts
- * const tracing = createTracingHooks({
- *   startSpan: (name, attrs) => Sentry.startInactiveSpan({ name, attributes: attrs }),
- * })
- * const uninstall = tracing.install(agent.hooks)
- * try { await agent.run({ prompt }) }
- * finally { uninstall() }
- * ```
- */
-declare function createTracingHooks(options: TracingHooksOptions): TracingHookSet;
-
-/**
- * Zod v4 integration helper.
- *
- * Normalizes the output of z.toJsonSchema() for use as ToolSpec.inputSchema.
- * Zod is an optional peer dependency — consumers call z.toJsonSchema() themselves.
- *
- * Usage:
- *   import { z } from 'zod'
- *   import { zodToJsonSchema } from 'zidane'
- *   const schema = zodToJsonSchema(z.toJsonSchema(z.object({ name: z.string() })))
- */
-/**
- * Normalize a JSON Schema (e.g. from zod v4's z.toJsonSchema()) for use
- * as a ToolSpec.inputSchema.
- *
- * Strips the $schema key that some providers reject.
- */
-declare function zodToJsonSchema(jsonSchema: Record<string, unknown>): Record<string, unknown>;
-
-export { AgentHooks, type Span, type TracingHookSet, type TracingHooksOptions, createTracingHooks, zodToJsonSchema };
+import { a as ContextCapabilities, c as ExecutionContext, i as createDockerContext, l as ExecutionHandle, n as createSandboxContext, o as ContextType, r as createProcessContext, s as ExecResult, t as SandboxProvider, u as SpawnConfig } from "./index-BfSdALzk.js";
+import { $ as OpenAICompatHttpError, A as loadSession, At as ToolExecutionMode, B as FileMapStoreOptions, Bt as AgentContextExceededError, C as SkillsConfig, Ct as SessionEndStatus, D as SessionRun, Dt as SpawnHookContext, E as SessionData, Et as SessionTurn, F as fromOpenAI, Ft as TurnFinishReason, G as StreamOptions, Gt as ClassifiedErrorKind, H as Provider, Ht as AgentToolNotAllowedError, I as toAnthropic, It as TurnUsage, J as ToolSpec, K as ToolCall, Kt as matchesContextExceeded, L as toOpenAI, Lt as toolOutputByteLength, M as createRemoteStore, Mt as ToolResultContent, N as autoDetectAndConvert, Nt as ToolResultImageContent, O as SessionStore, Ot as StreamHookContext, P as fromAnthropic, Pt as ToolResultTextContent, Q as OpenAICompatAuthHeader, R as createMemoryStore, Rt as toolResultToText, S as SkillSource, St as SessionContentBlock, T as Session, Tt as SessionMessage, U as ProviderCapabilities, Ut as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, V as createFileMapStore, Vt as AgentProviderError, W as StreamCallbacks, Wt as ClassifiedError, X as OpenRouterParams, Y as TurnResult, Z as openrouter, _ as ToolDef, _t as PromptDocumentPart, a as ActivationVia, at as openai, b as SkillDiagnostic, bt as PromptTextPart, c as SkillActivationState, ct as AnthropicParams, d as McpConnection, dt as AgentRunOptions, et as OpenAICompatParams, f as connectMcpServers, ft as AgentStats, g as ToolContext, gt as OAuthRefreshHookContext, h as resultToString, ht as McpToolHookContext, i as createAgent, it as OpenAIParams, j as RemoteStoreOptions, jt as ToolHookContext, k as createSession, kt as ThinkingLevel, l as SkillActivationStateOptions, lt as anthropic, m as normalizeMcpServers, mt as McpServerConfig, n as AgentHooks, nt as mapOAIFinishReason, o as ActiveSkill, ot as CerebrasParams, p as normalizeMcpBlocks, q as ToolResult, qt as toTypedError, r as AgentOptions, rt as openaiCompat, s as DeactivationReason, st as cerebras, t as Agent, tt as classifyOpenAICompatError, u as createSkillActivationState, ut as AgentBehavior, v as ToolMap, vt as PromptImagePart, w as CreateSessionOptions, wt as SessionHookContext, x as SkillResource, xt as RunHookMap, y as SkillConfig, yt as PromptPart, z as FileMapAdapter, zt as AgentAbortedError } from "./agent-BoV5Twdl.js";
+import { A as edit, D as createInteractionTool, E as InteractionToolOptions, F as definePreset, I as _default, L as basicTools, M as flattenTurns, N as statsByModel, O as grep, P as Preset, _ as createSkillsUseTool, a as createTracingHooks, b as SkillsReadToolOptions, c as validateToolArgs, f as ChildAgent, g as SkillsUseToolOptions, h as createSpawnTool, i as TracingHooksOptions, j as ModelUsage, k as glob, m as SpawnToolState, n as Span, p as SpawnToolOptions, r as TracingHookSet, s as ValidationResult, t as zodToJsonSchema, v as SkillsRunScriptToolOptions, w as multiEdit, x as createSkillsReadTool, y as createSkillsRunScriptTool } from "./index-28otmfLX.js";
+import { S as installAllowedToolsGate, a as SkillValidationResult, b as buildCatalog, c as parseAllowedToolPattern, d as validateSkillName, f as resolveSkills, h as discoverSkills, i as SkillValidationIssue, l as validateResourcePath, m as SourcedScanPath, n as writeSkillToDisk, o as isToolAllowedByUnion, p as interpolateShellCommands, r as writeSkillsToDisk, s as matchesAllowedTool, t as defineSkill, u as validateSkillForWrite, x as IMPLICITLY_ALLOWED_SKILL_TOOLS, y as parseSkillFile } from "./index-DPsd0qwm.js";
+export { ActivationVia, ActiveSkill, Agent, AgentAbortedError, AgentBehavior, AgentContextExceededError, AgentHooks, AgentOptions, AgentProviderError, AgentRunOptions, AgentStats, AgentToolNotAllowedError, AnthropicParams, CONTEXT_EXCEEDED_MESSAGE_PATTERNS, CerebrasParams, ChildAgent, ClassifiedError, ClassifiedErrorKind, ContextCapabilities, ContextType, CreateSessionOptions, DeactivationReason, ExecResult, ExecutionContext, ExecutionHandle, FileMapAdapter, FileMapStoreOptions, IMPLICITLY_ALLOWED_SKILL_TOOLS, InteractionToolOptions, McpConnection, McpServerConfig, McpToolHookContext, ModelUsage, OAuthRefreshHookContext, OpenAICompatAuthHeader, OpenAICompatHttpError, OpenAICompatParams, OpenAIParams, OpenRouterParams, Preset, PromptDocumentPart, PromptImagePart, PromptPart, PromptTextPart, Provider, ProviderCapabilities, RemoteStoreOptions, RunHookMap, SandboxProvider, Session, SessionContentBlock, SessionData, SessionEndStatus, SessionHookContext, SessionMessage, SessionRun, SessionStore, SessionTurn, SkillActivationState, SkillActivationStateOptions, SkillConfig, SkillDiagnostic, SkillResource, SkillSource, SkillValidationIssue, SkillValidationResult, SkillsConfig, SkillsReadToolOptions, SkillsRunScriptToolOptions, SkillsUseToolOptions, SourcedScanPath, Span, SpawnConfig, SpawnHookContext, SpawnToolOptions, SpawnToolState, StreamCallbacks, StreamHookContext, StreamOptions, ThinkingLevel, ToolCall, ToolContext, ToolDef, ToolExecutionMode, ToolHookContext, ToolMap, ToolResult, ToolResultContent, ToolResultImageContent, ToolResultTextContent, ToolSpec, TracingHookSet, TracingHooksOptions, TurnFinishReason, TurnResult, TurnUsage, ValidationResult, anthropic, autoDetectAndConvert, _default as basic, basicTools, buildCatalog, cerebras, classifyOpenAICompatError, connectMcpServers, createAgent, createDockerContext, createFileMapStore, createInteractionTool, createMemoryStore, createProcessContext, createRemoteStore, createSandboxContext, createSession, createSkillActivationState, createSkillsReadTool, createSkillsRunScriptTool, createSkillsUseTool, createSpawnTool, createTracingHooks, definePreset, defineSkill, discoverSkills, edit, flattenTurns, fromAnthropic, fromOpenAI, glob, grep, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, loadSession, mapOAIFinishReason, matchesAllowedTool, matchesContextExceeded, multiEdit, normalizeMcpBlocks, normalizeMcpServers, openai, openaiCompat, openrouter, parseAllowedToolPattern, parseSkillFile, resolveSkills, resultToString, statsByModel, toAnthropic, toOpenAI, toTypedError, toolOutputByteLength, toolResultToText, validateResourcePath, validateSkillForWrite, validateSkillName, validateToolArgs, writeSkillToDisk, writeSkillsToDisk, zodToJsonSchema };