zidane 6.4.4 → 6.5.0

package/dist/{index-C-Nd2ZbV.d.ts → index-CWBSrqI6.d.ts}

@@ -174,6 +174,49 @@ declare function setModelCatalog(catalog: ModelCatalog | null): void;
 /** The process-wide catalog, normalized to source form. */
 declare function getModelCatalog(): ModelCatalogSource | undefined;
 //#endregion
+//#region src/mcp/origin-pinned-fetch.d.ts
+/**
+ * The transport-reachability rule for a remote MCP endpoint: HTTPS anywhere,
+ * plaintext HTTP only when it stays on the machine, nothing else.
+ *
+ * THE single encoding of that policy. It's enforced at two points on opposite
+ * sides of the plugin boundary — once when validating a plugin's `mcp.json`
+ * (`plugins/mcp.ts`), and again per redirect hop inside
+ * {@link originPinnedFetch} — and those two must never disagree. If they did,
+ * a URL the loader refused could still be reached by redirect, which is the
+ * exact hole the pinning exists to close. Relaxing the rule (private ranges,
+ * `*.localhost`, …) is then a one-line change that both sites inherit.
+ *
+ * Scheme and host only. Authoring rules that apply to a CONFIGURED url but
+ * have no meaning for a redirect target — no userinfo, no fragment — stay with
+ * the loader.
+ */
+declare function isAllowedRemoteUrl(url: URL): boolean;
+/**
+ * The fetch shape this wrapper supports — deliberately narrower than
+ * `typeof fetch`, matching the MCP SDK's `FetchLike`.
+ *
+ * A `Request` input is NOT accepted: the wrapper rebuilds each hop from
+ * `init`, so it would silently drop a Request's method, headers and body and
+ * issue a bare credential-less GET. Narrowing the type makes that shape
+ * unrepresentable rather than a quiet failure on a security-relevant helper.
+ * Both SDK transports only ever pass a URL plus init.
+ */
+type PinnedFetch = (url: string | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Wrap `baseFetch` so `headerNames` are dropped on any hop that leaves the
+ * origin of `configuredUrl`, and so a redirect cannot downgrade the session
+ * to cleartext.
+ *
+ * `authorization` is ALWAYS protected, whether or not the caller listed it.
+ * The MCP SDK's OAuth provider injects that header per request rather than
+ * through `McpServerConfig.headers` — `bootstrapServer` attaches a provider to
+ * a flagless server whenever stored tokens exist — so a strip list derived
+ * only from the configured header names would leave the bearer token exposed
+ * on exactly the servers that have one.
+ */
+declare function originPinnedFetch(configuredUrl: string, headerNames: readonly string[], baseFetch?: PinnedFetch): PinnedFetch;
+//#endregion
 //#region src/mcp/index.d.ts
 interface McpConnection {
   tools: Record<string, ToolDef>;
@@ -228,6 +271,21 @@ declare function deriveMcpToolMeta(namespacedName: string, servers: readonly Mcp
  * `AgentOptions.mcpToolWrap` hook to discovered tools.
  */
 declare function wrapDiscoveredMcpTools(tools: Record<string, ToolDef>, wrap: McpToolWrap, servers: readonly McpServerConfig[]): Record<string, ToolDef>;
+/**
+ * The config a transport is actually built from.
+ *
+ * `${VAR}` placeholders resolve HERE, not at normalize time — see
+ * {@link expandMcpConfigEnv} for why (config writers round-trip normalized
+ * configs to disk; expanded secrets must never ride along).
+ *
+ * A `preExpanded` config skips the pass entirely. The Agent Plugins loader
+ * has already substituted the only two placeholders that spec permits, in
+ * only the three fields it permits, so a second pass would both widen the
+ * scope (into `command` / `url` / `headers`) and let an ambient
+ * `PLUGIN_ROOT` env var reach text the spec says stays literal. See
+ * {@link McpServerConfig.preExpanded}.
+ */
+declare function resolveTransportConfig(config: McpServerConfig): McpServerConfig;
 /**
  * Expand environment-variable placeholders in one config string. The
  * `:-default` form follows shell semantics — the default substitutes when
@@ -1891,6 +1949,14 @@ interface ToolContext {
    * directly off the context instead of resolving via the session.
    */
   parentRunId?: string;
+  /**
+   * Tool-call id of the `spawn` call that created the run owning this tool
+   * call. Set for every child the built-in `spawn` tool starts (it forwards
+   * its own `callId`), absent on top-level runs and on host-rolled subagents
+   * that don't pass `AgentRunOptions.parentCallId`. Unlike `parentRunId` it
+   * does not depend on a shared session — see `ToolHookContext.parentCallId`.
+   */
+  parentCallId?: string;
   /**
    * The agent's session, when one was provided to `createAgent`. Tools that
    * want to persist their own state (or, in the case of `spawn`, inherit the
@@ -1995,6 +2061,20 @@ interface ToolDef {
    * should leave it unset.
    */
   isConcurrencySafe?: boolean | ((input: Record<string, unknown>) => boolean);
+  /**
+   * Whether this tool runs a full nested agent loop inside its `execute`
+   * (the built-in `spawn` tool, or any host orchestrator tool that calls
+   * `agent.run`). Purely declarative — the loop treats such tools like any
+   * other; it exists for durable-execution adapters.
+   *
+   * Why adapters care: a nested agent drives its OWN provider and tools,
+   * which under a durable runtime are already journaled. Wrapping the outer
+   * tool would nest those journal entries inside the outer tool's journaled
+   * closure, which durable runtimes forbid. `wrapAgentTools` therefore leaves
+   * these tools unwrapped so the child's own steps journal directly — see
+   * `docs/RESTATE.md`.
+   */
+  runsNestedAgent?: boolean;
 }
 type ToolMap = Map<string, ToolDef>;
 //#endregion
@@ -2042,6 +2122,18 @@ interface AgentClock {
    * RFC-4122 v4 UUID string. Always sync.
    */
   randomUUID: () => string;
+  /**
+   * Set by durable-execution adapters whose `now()` is journaled (e.g.
+   * `restateClock`), i.e. one that replays byte-identical values instead of
+   * advancing with real time. Absent / `false` on the native clock.
+   *
+   * Consumers use it to avoid branching on wall-clock time inside a journaled
+   * region — a `setTimeout` race decides differently on a replay than it did
+   * live, which diverges control flow. The built-in `spawn` tool reads it to
+   * enforce its per-child timeout through the loop's journaled `maxWallMs`
+   * deadline instead of a timer.
+   */
+  journaled?: boolean;
 }
 /** Native clock backing the default (Date.now + crypto.randomUUID). */
 declare const DEFAULT_AGENT_CLOCK: AgentClock;
@@ -2272,6 +2364,34 @@ interface McpServerConfig {
    * eligible to succeed once the upstream is reachable again.
    */
   lazyConnect?: boolean;
+  /**
+   * Suppress `${VAR}` expansion at the transport boundary.
+   *
+   * Set by the Agent Plugins loader (`plugins/mcp.ts`), whose placeholder
+   * rules are DELIBERATELY narrower than zidane's: the spec expands only
+   * `${PLUGIN_ROOT}` / `${PLUGIN_DATA}`, and only inside `args`, `env`
+   * values and `cwd` — never in `command`, `url` or `headers`. Those two
+   * placeholders are already substituted by the time the config gets here,
+   * so a second pass would (a) expand the wrong fields and (b) let an
+   * ambient `PLUGIN_ROOT` env var reach fields the spec says must keep the
+   * literal text.
+   *
+   * Hand-written `mcps.json` entries leave this unset and keep the full
+   * `${VAR}` / `${VAR:-default}` / `${env:VAR}` behavior.
+   */
+  preExpanded?: boolean;
+  /**
+   * Pin {@link McpServerConfig.headers} to the configured URL's origin
+   * (sse / streamable-http only).
+   *
+   * When set, redirects are followed manually and the configured headers
+   * are STRIPPED the moment a hop leaves the original origin, so a
+   * cooperating-then-redirecting server cannot harvest a plugin's bearer
+   * token. Set by the Agent Plugins loader, which must satisfy the spec's
+   * "never forward configured headers to a different origin" rule; opt in
+   * manually for any other server whose headers carry a secret.
+   */
+  pinHeaderOrigin?: boolean;
 }
 /**
  * Configuration for the loop's retry-with-backoff policy around
@@ -4516,6 +4636,21 @@ interface AgentRunOptions {
    * parent↔child run tree can be reconstructed from a persisted session.
    */
   parentRunId?: string;
+  /**
+   * Tool-call id of the `spawn` call that created this run. The built-in
+   * `spawn` tool populates it from its own `ToolContext.callId` for every
+   * child it starts — no `persist` / shared session needed, unlike
+   * `parentRunId`. Hosts that roll their own subagent (calling `agent.run`
+   * with `depth` set from inside a tool) must pass it themselves; nothing
+   * derives it, so `depth >= 1` alone does not imply it is set.
+   *
+   * Lands on every `ToolContext` / `ToolHookContext` / `McpToolHookContext`
+   * of the run, so a host can attribute a subagent's tool call to the spawn
+   * call that owns it — see {@link ToolHookContext.parentCallId}. Not
+   * persisted onto `SessionRun`: it names a call in the spawning agent's
+   * live turn, not a row in the run tree.
+   */
+  parentCallId?: string;
   /**
    * Resume a prior run's conversation: seed this run's turns from the
    * session turns tagged with this `runId` (filtered through
@@ -4717,6 +4852,12 @@ interface AgentStats {
 interface ChildRunStats {
   id: string;
   task: string;
+  /**
+   * Tool-call id of the `spawn` call that produced this child — see
+   * {@link SpawnHookContext.callId}. Lets a `spawn:complete` listener close
+   * out the same grouping key it opened on `spawn:before`.
+   */
+  callId?: string;
   /**
    * The child agent's full {@link AgentStats}. Cumulative for that child's
    * own subtree (child loop + its grandchildren). Do **not** sum
@@ -4779,6 +4920,29 @@ interface ToolHookContext {
    * without resolving the run row.
    */
   parentRunId?: string;
+  /**
+   * Tool-call id of the `spawn` call that created the run this tool call
+   * belongs to. Absent on top-level runs.
+   *
+   * Set for every child the built-in `spawn` tool starts — it comes from the
+   * spawn tool's own call rather than from session-backed run bookkeeping,
+   * so unlike `parentRunId` it survives `persist: false` spawns. It is NOT
+   * an invariant of `depth >= 1`: a host that spawns by calling `agent.run`
+   * with `depth` itself sees a subagent with no `parentCallId` unless it
+   * passes `AgentRunOptions.parentCallId` too. Treat it as present-or-absent,
+   * not as derivable from depth.
+   *
+   * Hosts mirroring subagent activity into a client protocol use it as the
+   * "parent tool use" grouping key: absent at depth 0, and at depth >= 1 a
+   * real tool-call id rather than a synthetic label. Where it *resolves*
+   * depends on depth — at depth 1 it names a call the parent's own `tool:*`
+   * events already carried, while at depth >= 2 it names a call in the
+   * child's turn, which a top-level listener only ever saw as
+   * `child:tool:*`. So it always groups correctly, but a lookup against the
+   * top-level tool stream alone only hits for depth 1. This mirrors the
+   * ancestry semantics of `childId` / `depth` on `child:*` events.
+   */
+  parentCallId?: string;
   /**
    * Subagent depth for this tool call. 0 = top-level, 1 = first-level
    * child, etc. Mirrors `ToolContext.depth` so hook consumers don't
@@ -4809,6 +4973,8 @@ interface McpToolHookContext {
   runId?: string;
   /** Parent run id when this tool call's agent is a subagent — see `ToolHookContext.parentRunId`. */
   parentRunId?: string;
+  /** Spawning tool call's id when this tool call's agent is a subagent — see `ToolHookContext.parentCallId`. */
+  parentCallId?: string;
   /** Subagent depth — see `ToolHookContext.depth`. */
   depth?: number;
 }
@@ -4820,6 +4986,19 @@ interface SessionHookContext {
 interface SpawnHookContext {
   id: string;
   task: string;
+  /**
+   * Tool-call id of the `spawn` call this event belongs to — the same value
+   * the child's own tool events carry as `ToolHookContext.parentCallId`.
+   * Gives hosts the `childId` -> spawn-call mapping at spawn time, which is
+   * the only place to learn it for a child that never dispatches a tool (and
+   * the only place at all under parallel spawns, where `tool:before` for two
+   * spawn calls and their `spawn:before` events interleave).
+   *
+   * Absent for hand-fired payloads and for spawn-style tools invoked with a
+   * `ToolContext` that carries no `callId`. Not persisted — see
+   * `AgentRunOptions.parentCallId`.
+   */
+  callId?: string;
   /**
    * Child label of the prior run this spawn continues (e.g. `"child-2"`),
    * set when the spawn was invoked with `resume`. Hosts render it next to
@@ -8767,6 +8946,30 @@ interface Settings {
    * list on the next toggle (consistent with skills / MCPs).
    */
   enabledExtensions?: readonly string[];
+  /**
+   * Allowlist of Agent Plugin names — everything discovered under
+   * `.agents/plugins/<name>/` or `.{prefix}/plugins/<name>/` (project +
+   * user), plus plugins an extension loaded via `ctx.loadAgentPlugin`. Same
+   * polarity + semantics as `enabledSkills` / `enabledMcps`:
+   *
+   *   - `undefined` → every discovered plugin loads (fresh-install default).
+   *   - `[]`        → no plugins load.
+   *   - `[names]`   → allowlist; only those load.
+   *
+   * The key is the plugin's MANIFEST name (its identity per the Agent
+   * Plugins spec), falling back to the directory basename for a plugin whose
+   * manifest was rejected — so a broken plugin still has a stable row.
+   *
+   * A plugin's skills and MCP servers are gated by this list. Its skills are
+   * additionally force-included into `enabledSkills` when the user has an
+   * allowlist there, since enabling the plugin IS the consent.
+   *
+   * The gate is plugin-level only: a plugin's skills do not appear in the
+   * Skills tab (that list is a disk scan of the skill scan paths, which plugin
+   * skills deliberately bypass), so there is no per-skill toggle for them.
+   * Turning off one skill of a plugin means disabling the plugin.
+   */
+  enabledPlugins?: readonly string[];
   /**
    * Per-server **deny-list** of tool names to hide from the model. Maps
    * 1:1 onto `McpServerConfig.disabledTools` at agent-construction
@@ -10373,6 +10576,94 @@ declare const BUILTIN_THEMES: Readonly<Record<string, Theme>>;
 /** Resolve a theme id to its full `Theme`, falling back to default on unknown ids. */
 declare function resolveTheme(id: string | undefined, extraThemes?: Readonly<Record<string, Theme>>): Theme;
 //#endregion
+//#region src/chat/xdg.d.ts
+/**
+ * XDG Base Directory resolution for zidane.
+ *
+ * The user's storage spreads across four logical slots:
+ *
+ *   - **config** — credentials, mcp-credentials, keybindings, config.json,
+ *     mcps.json, skills (user-editable surface).
+ *   - **data**   — sessions.db (long-lived chat history).
+ *   - **state**  — state.json (per-machine UI bookkeeping: last provider,
+ *     last model, last agent, settings).
+ *   - **cache**  — persisted tool results, background-task logs,
+ *     auto-update registry cache (regenerable, safe to wipe).
+ *
+ * Historically all four collapsed to `~/.zidane/`. This module adds
+ * XDG-Base-Directory-aware defaults so a Linux user with no existing
+ * `~/.zidane/` lands in the conventional `~/.config/zidane/`,
+ * `~/.local/share/zidane/`, `~/.local/state/zidane/`, `~/.cache/zidane/`
+ * trio. Existing setups (anyone with a `~/.zidane/` directory or
+ * `ZIDANE_STORAGE_DIR` set) keep the single-dir layout unchanged.
+ *
+ * Resolution flow — applied in this order:
+ *
+ *   1. Caller passed an explicit `storageDir` (`ChatOptions.storageDir`)
+ *      OR `ZIDANE_STORAGE_DIR` is set → **legacy-explicit** single-dir
+ *      layout under `<storageDir>/<prefix>`. The four slots collapse to
+ *      the same directory.
+ *   2. `~/<prefix>/` already exists on disk → **legacy-existing**
+ *      single-dir layout under that directory. Upgrades never silently
+ *      shift files around.
+ *   3. Any `XDG_*_HOME` env var is set OR `process.platform === 'linux'`
+ *      → **XDG split**. Each slot lands in its own dir. Per-slot
+ *      `ZIDANE_{CONFIG,DATA,CACHE,STATE}_DIR` overrides beat the XDG
+ *      vars for surgical tweaks.
+ *   4. Otherwise (macOS/Windows, no XDG signal, no existing dir) →
+ *      **default** single-dir layout at `~/<prefix>/`. Day-one behavior
+ *      on these platforms is unchanged.
+ *
+ * The `userDir` legacy alias always equals `configDir` so existing code
+ * that still references `paths.userDir` keeps reading credentials, mcps,
+ * etc. from the right place.
+ */
+/** The four slot kinds we resolve. Names match the XDG spec. */
+type StorageSlot = 'config' | 'data' | 'state' | 'cache';
+/** Which resolution branch produced the layout — surfaced for debugging + tests. */
+type StorageMode = 'legacy-explicit' | 'legacy-existing' | 'xdg' | 'default';
+/**
+ * Per-slot directories. In legacy / default modes the four fields all
+ * point at the same path; in XDG mode they fan out into their
+ * spec-conventional locations.
+ *
+ * `mode` carries the resolution branch so a host that wants to print
+ * a startup banner ("zidane is using XDG paths") can detect the
+ * layout without re-running the logic.
+ */
+interface StorageDirs {
+  configDir: string;
+  dataDir: string;
+  stateDir: string;
+  cacheDir: string;
+  mode: StorageMode;
+}
+interface ResolveStorageDirsOptions {
+  /** Storage prefix. Leading dot tolerated. Default: `'.zidane'`. */
+  prefix?: string;
+  /**
+   * Explicit storage root (`ChatOptions.storageDir`). When set, forces
+   * legacy-explicit mode regardless of the platform / XDG signals.
+   */
+  storageDir?: string;
+  /** Override `os.homedir()` for tests. */
+  home?: string;
+  /** Override `process.platform` for tests. */
+  platform?: NodeJS.Platform;
+  /** Override `process.env` for tests. */
+  env?: Readonly<Record<string, string | undefined>>;
+}
+/**
+ * Resolve the four storage slots according to the precedence above.
+ *
+ * Pure aside from one filesystem probe (`existsSync(home/<prefix>)`)
+ * — the same probe `resolveStoragePaths` would do anyway when
+ * computing `paths.userDir`. No directories are created here; the
+ * relevant write paths (state store, credentials writer, persist
+ * dir) handle their own lazy `mkdirSync` already.
+ */
+declare function resolveStorageDirs(opts?: ResolveStorageDirsOptions): StorageDirs;
+//#endregion
 //#region src/skills/activation.d.ts
 /** How a skill was activated. Surfaced in `skills:activate` hook ctx. */
 type ActivationVia = 'model' | 'explicit' | 'resume';
@@ -10963,6 +11254,264 @@ declare function defineSkill(config: Omit<SkillConfig, 'source'> & {
   source?: SkillConfig['source'];
 }): SkillConfig;
 //#endregion
+//#region src/plugins/types.d.ts
+/**
+ * Agent Plugins spec versions this loader implements, newest first.
+ *
+ * The spec requires clients to select validation rules from the manifest's
+ * `$schema` WITHOUT retrieving it, and to let plugins keep targeting older
+ * versions under a locally supported compatibility policy. Our policy: a
+ * version is supported iff it appears in this list. Adding `1.1.0` later
+ * means adding it here plus any rule deltas in `./manifest` — never
+ * reinterpreting an already-published identifier, which the spec forbids.
+ */
+declare const SUPPORTED_AGENT_PLUGINS_VERSIONS: readonly ["1.0.0"];
+type AgentPluginsVersion = typeof SUPPORTED_AGENT_PLUGINS_VERSIONS[number];
+/** Which canonical schema a `$schema` identifier selects. */
+type PluginSchemaKind = 'plugin' | 'mcp';
+/**
+ * Canonical schema identifier for a given document kind + version. Built
+ * rather than hardcoded so the two call sites (manifest, mcp.json) can't
+ * drift, and so the version cross-check the spec requires between
+ * `plugin.json` and `mcp.json` is a plain string comparison.
+ */
+declare function agentPluginsSchemaId(kind: PluginSchemaKind, version: string): string;
+/**
+ * Split a canonical `$schema` identifier into its document kind + version.
+ * Returns `null` for anything that isn't a canonical identifier; the caller
+ * decides whether that's fatal (manifest) or component-scoped (mcp.json).
+ *
+ * Purely syntactic: it never fetches. The spec forbids retrieving a schema
+ * during load, so version support is a lookup against
+ * {@link SUPPORTED_AGENT_PLUGINS_VERSIONS}, not a download.
+ */
+declare function parseSchemaId(value: string): {
+  kind: PluginSchemaKind;
+  version: string;
+} | null;
+/** True when this loader implements the given Agent Plugins version. */
+declare function isSupportedAgentPluginsVersion(version: string): version is AgentPluginsVersion;
+/** Optional author block. Closed: only these three keys, all strings. */
+interface PluginAuthor {
+  name?: string;
+  email?: string;
+  url?: string;
+}
+/**
+ * A validated `plugin.json`. Only spec fields survive validation —
+ * unknown top-level keys are reported and dropped, so consumers can
+ * never accidentally depend on a non-portable field.
+ *
+ * `version` here is the PLUGIN's own version string; the spec version
+ * selected by `$schema` lands on {@link PluginManifest.specVersion}.
+ */
+interface PluginManifest {
+  /** Agent Plugins version selected by the manifest's `$schema`. */
+  specVersion: AgentPluginsVersion;
+  /** Plugin name + package identifier (1-64 chars, see `./manifest`). */
+  name: string;
+  version?: string;
+  description?: string;
+  author?: PluginAuthor;
+  homepage?: string;
+  repository?: string;
+  license?: string;
+  keywords?: string[];
+  /**
+   * Client-owned data keyed by reverse-domain namespace. Values are
+   * deliberately `unknown`: the spec says to ignore namespaces the client
+   * does not implement WITHOUT validating their contents, so this loader
+   * never inspects a member it doesn't own.
+   */
+  extensions?: Record<string, unknown>;
+}
+/**
+ * A load-time finding. Mirrors `SkillDiagnostic`'s shape (severity + stable
+ * code + message) so host UIs already rendering skill diagnostics can
+ * render these with no new plumbing.
+ *
+ * `severity: 'error'` on a returned plugin means a narrow boundary fired
+ * (a component type disabled, a skill skipped) — NOT that the whole plugin
+ * failed. Plugin-level rejection is signalled by `LoadedPlugin.ok === false`.
+ */
+interface PluginDiagnostic {
+  severity: 'warning' | 'error';
+  /** Stable machine-readable code (e.g. `manifest-unknown-field`). */
+  code: string;
+  message: string;
+  /** Manifest field the finding relates to, when applicable. */
+  field?: string;
+  /** Filesystem path the finding relates to, when applicable. */
+  path?: string;
+}
+/**
+ * Per-component-type outcome. The spec insists a missing fixed location is
+ * NOT an error, and that an invalid one disables only its own component
+ * type — so these four states are load-bearing, not cosmetic:
+ *
+ *   - `absent`      fixed location not present. Valid.
+ *   - `loaded`      discovered (possibly zero entries, e.g. an empty `skills/`).
+ *   - `invalid`     wrong filesystem kind, or the location escaped the root.
+ *   - `unsupported` never discovered — not implemented by this client,
+ *                   disabled by the caller, or the plugin was rejected
+ *                   before component discovery ran.
+ */
+type PluginComponentStatus = 'absent' | 'loaded' | 'invalid' | 'unsupported';
+/**
+ * Result of {@link loadAgentPlugin}. Never thrown — a rejected plugin comes
+ * back as `ok: false` with the reason in `diagnostics`, because one bad
+ * plugin must not take down a host that's loading several.
+ */
+interface LoadedPlugin {
+  /**
+   * `false` when a fatal manifest or boundary violation rejected the whole
+   * plugin. Components are empty in that case and were never discovered —
+   * the spec requires rejection to happen BEFORE component discovery.
+   */
+  ok: boolean;
+  /** Plugin root as requested, resolved to an absolute path. */
+  dir: string;
+  /**
+   * Symlink-resolved plugin root. Every package path a caller touches must
+   * stay under this — it's the boundary the spec defines. Falls back to
+   * `dir` when the root itself could not be resolved.
+   */
+  root: string;
+  /** Validated manifest. Absent iff `ok === false`. */
+  manifest?: PluginManifest;
+  /** Skills discovered under `skills/`. */
+  skills: SkillConfig[];
+  /** MCP servers declared by `mcp.json`. */
+  mcpServers: McpServerConfig[];
+  /** Per-component-type outcome — see {@link PluginComponentStatus}. */
+  components: {
+    skills: PluginComponentStatus;
+    mcp: PluginComponentStatus;
+  };
+  /** Everything worth reporting: rejections, disabled components, skipped skills. */
+  diagnostics: PluginDiagnostic[];
+}
+interface LoadAgentPluginOptions {
+  /**
+   * Source tag stamped onto every discovered skill, driving collision
+   * precedence and the `trustProjectSkills` gate downstream. Defaults to
+   * `'project'` — the conservative choice, since a plugin sitting in a
+   * repo is exactly the untrusted-input case that gate exists for.
+   */
+  source?: SkillSource;
+  /**
+   * Prefix applied to discovered skill names as `<prefix>-<name>`.
+   *
+   * Agent Plugins leaves naming to the client, and zidane's skill catalog
+   * is a single flat namespace (`discoverSkills` dedupes by name), so two
+   * plugins shipping a `deploy` skill would silently shadow one another.
+   * Opt in to prefixing when loading untrusted or multiple plugins.
+   */
+  namePrefix?: string;
+  /** Discover `skills/`. Default `true`. */
+  skills?: boolean;
+  /** Discover `mcp.json`. Default `true`. */
+  mcp?: boolean;
+  /**
+   * Exact directory exposed to MCP servers as `${PLUGIN_DATA}`.
+   *
+   * Must live outside the plugin root: the spec requires this directory to
+   * persist across plugin updates, and an update replaces the package tree.
+   * Prefer {@link LoadAgentPluginOptions.dataRoot} unless you need to pin one
+   * specific plugin's directory.
+   */
+  dataDir?: string;
+  /**
+   * Parent directory under which `${PLUGIN_DATA}` is created as
+   * `<dataRoot>/<plugin-name>/`.
+   *
+   * Exists because the plugin name comes from the manifest, which the caller
+   * hasn't read yet — a host that wants its own namespace (the extensions
+   * seam puts plugin data inside the loading extension's storage root) can
+   * supply the parent and let the loader append the name.
+   *
+   * Defaults to `<dataDir>/plugin-data` from `resolveStorageDirs`. Ignored
+   * when {@link LoadAgentPluginOptions.dataDir} is set.
+   */
+  dataRoot?: string;
+}
+//#endregion
+//#region src/plugins/load.d.ts
+/** Fixed location of the plugin manifest. */
+declare const PLUGIN_MANIFEST_FILE = "plugin.json";
+/**
+ * Default parent of every plugin's `${PLUGIN_DATA}` directory.
+ *
+ * Deliberately OUTSIDE any plugin root: the spec requires the data directory
+ * to persist across plugin updates, and an update replaces the package tree.
+ * Keyed by plugin name so two copies of the same plugin (project + user)
+ * share state, which is what an author storing a cache or a token expects.
+ *
+ * Routed through `resolveStorageDirs` rather than hardcoding `~/.zidane` so it
+ * honours `ZIDANE_STORAGE_DIR` and the XDG dirs like every other persisted
+ * location — otherwise an XDG-mode install would scatter plugin data into a
+ * `~/.zidane` nothing else in the app touches.
+ *
+ * NB: `resolveStorageDirs` does NOT read `ZIDANE_PREFIX`; it defaults `prefix`
+ * to `.zidane`. Callers with a configured prefix must pass it, or plugin data
+ * lands beside a prefix the rest of the install doesn't use.
+ */
+declare function defaultPluginDataRoot(opts?: ResolveStorageDirsOptions): string;
+/**
+ * Load an Agent Plugin from `dir`.
+ *
+ * @returns A {@link LoadedPlugin}. Check `ok` before trusting `manifest`;
+ * check `components` to tell "the plugin ships no skills" (`absent`) from
+ * "its skills were rejected" (`invalid`).
+ */
+declare function loadAgentPlugin(dir: string, opts?: LoadAgentPluginOptions): Promise<LoadedPlugin>;
+//#endregion
+//#region src/plugins/manifest.d.ts
+type ManifestValidation = {
+  ok: true;
+  manifest: PluginManifest;
+  diagnostics: PluginDiagnostic[];
+} | {
+  ok: false;
+  diagnostics: PluginDiagnostic[];
+};
+/**
+ * Parse manifest text, then validate it.
+ *
+ * A JSON syntax error is fatal — unlike `mcps.json` (where
+ * `parseJsonTolerant` repairs copy-paste whitespace artifacts), a plugin
+ * manifest is a package file produced by a build or an author's editor, not
+ * pasted into a settings box. Repairing it would mean guessing at the
+ * contents of a third-party package.
+ */
+declare function parsePluginManifest(text: string): ManifestValidation;
+/**
+ * Validate an already-parsed manifest value against the closed 1.0.0 schema.
+ *
+ * Fatal violations short-circuit: `$schema` and `name` are checked first
+ * because without them there is no contract to validate against and no
+ * identity to report problems under.
+ */
+declare function validatePluginManifest(raw: unknown): ManifestValidation;
+//#endregion
+//#region src/plugins/mcp.d.ts
+/** Fixed location for the MCP component type. */
+declare const PLUGIN_MCP_FILE = "mcp.json";
+/**
+ * Substitute the two reserved placeholders in one string.
+ *
+ * Single-pass by construction (`String.replace` never re-scans its own
+ * output), so a `${PLUGIN_ROOT}` whose value somehow contained
+ * `${PLUGIN_DATA}` cannot expand twice. Unknown `${...}` text is left
+ * verbatim: the spec defines exactly two placeholders, and silently
+ * blanking anything else would corrupt legitimate literals.
+ */
+declare function expandPluginVars(value: string, vars: Record<string, string>): string;
+//#endregion
+//#region src/plugins/skills.d.ts
+/** Fixed location for the skills component type. */
+declare const PLUGIN_SKILLS_DIR = "skills";
+//#endregion
 //#region src/tools/model-search.d.ts
 /**
  * A {@link ModelInfo} paired with the runtime `Provider.name` that serves
@@ -11101,6 +11650,27 @@ interface SpawnToolOptions {
    * tools resolve via `ctx.readState ?? getReadState(ctx.session)`.
    */
   shareReadState?: boolean;
+  /**
+   * Run children on the parent's execution handle instead of letting each
+   * child mint (and destroy) its own. Default: `false` — an isolated handle
+   * per child.
+   *
+   * Why you'd turn it on: for a remote context (sandbox / container), a child
+   * calling `execution.spawn()` is a real allocation. Under a durable runtime
+   * that allocation is NOT a journaled side effect, so a replayed attempt
+   * mints a FRESH sandbox and orphans the first — one leak per child per
+   * attempt (see `docs/RESTATE.md` § Re-attach to the execution context). It
+   * also removes a per-child spawn/destroy round-trip on the hot path.
+   *
+   * The trade: children see the parent's filesystem and background-task
+   * namespace directly, so an isolated scratch space per child is gone. The
+   * child never destroys a shared handle (that's `AgentOptions.handle`
+   * semantics — host owns the lifecycle), and teardown skips background-task
+   * reassignment entirely since there is no child handle to promote from.
+   *
+   * No effect when the parent has no handle (`ctx.handle` absent).
+   */
+  shareHandle?: boolean;
   /**
    * Forward a curated subset of child hook events (`stream:*`, `tool:*`,
    * `turn:after`) onto the parent's hook bus as `child:*` events. Default:
@@ -11585,7 +12155,7 @@ type ExtensionSource = 'project' | 'user' | 'inline' | 'builtin';
 /** Stable extension API version supported by this runtime. */
 type ExtensionApiVersion = 1;
 /** Declarative capability labels surfaced by discovery/settings UIs. */
-type ExtensionCapability = 'tools' | 'hooks' | 'mcps' | 'skills' | 'providers' | 'themes' | 'agents' | 'completions' | 'context' | 'tui' | 'gui' | 'storage' | 'session' | 'metadata' | 'transforms';
+type ExtensionCapability = 'tools' | 'hooks' | 'mcps' | 'skills' | 'plugins' | 'providers' | 'themes' | 'agents' | 'completions' | 'context' | 'tui' | 'gui' | 'storage' | 'session' | 'metadata' | 'transforms';
 /** Descriptive permission labels. These document intent; they are not a sandbox. */
 type ExtensionPermission = 'session:read' | 'session:write' | 'storage:read' | 'storage:write' | 'mcp:configure' | 'provider:wrap' | 'tools:transform' | 'skills:activate';
 interface ExtensionManifest {
@@ -11596,6 +12166,24 @@ interface ExtensionManifest {
   permissions?: readonly ExtensionPermission[];
   capabilities?: readonly ExtensionCapability[];
 }
+/**
+ * Options for `ctx.loadAgentPlugin`. Pass a bare string for the common case
+ * (`ctx.loadAgentPlugin('./vendor/my-plugin')`).
+ */
+interface ExtensionAgentPluginOptions {
+  /** Plugin root. Absolute, or relative to the extension's own directory. */
+  dir: string;
+  /** Register the plugin's `skills/`. Default `true`. */
+  skills?: boolean;
+  /** Register the plugin's `mcp.json` servers. Default `true`. */
+  mcp?: boolean;
+  /**
+   * Rename discovered skills to `<prefix>-<name>`. zidane's skill catalog is
+   * a single flat namespace, so set this when loading several plugins that
+   * might ship same-named skills. Defaults to no prefix.
+   */
+  namePrefix?: string;
+}
 type ExtensionStorageScope = 'user' | 'project' | 'session' | 'cache' | 'data';
 interface ExtensionPaths {
   cwd: string;
@@ -11963,6 +12551,27 @@ interface ExtensionContext {
    * allowlist the user authored before installing the extension.
    */
   registerSkill: (skill: SkillConfig) => void;
+  /**
+   * Load an Agent Plugin (agent-plugins.org) and register everything it
+   * ships — one call replaces hand-rolling `registerSkill` /
+   * `registerMcpServer` per component.
+   *
+   * `dir` may be absolute, or relative to the extension's own directory
+   * (so an extension can vendor plugins inside itself and load them with
+   * `ctx.loadAgentPlugin('./vendor/deploy-tools')`). Inline extensions
+   * with no directory resolve relative to `ctx.paths.cwd`.
+   *
+   * Never throws for plugin-level problems: a malformed manifest, an
+   * escaping symlink or an invalid skill comes back as diagnostics on the
+   * returned {@link LoadedPlugin} (and is logged to the extension's
+   * logger), so one bad package can't fail your `setup()`. Check `ok`
+   * before trusting `manifest`.
+   *
+   * Must be awaited INSIDE `setup()` — registration closes when `setup()`
+   * resolves, and a load still in flight at that point is dropped with a
+   * warning rather than mutating an already-published registry.
+   */
+  loadAgentPlugin: (spec: string | ExtensionAgentPluginOptions) => Promise<LoadedPlugin>;
   /**
    * Register a prompt-completion provider — same shape used by the
    * built-in `@` (files) and `/` (skills) providers. Triggers must
@@ -12278,12 +12887,33 @@ interface LoadedExtension {
   /** True once `setup()` was invoked, even if it later failed or timed out. */
   setupRan?: boolean;
 }
+/**
+ * One Agent Plugin an extension loaded through `ctx.loadAgentPlugin`.
+ *
+ * The plugin's skills and MCP servers are already folded into the
+ * surrounding {@link ExtensionContributions}; this record exists so hosts can
+ * still see that a PLUGIN was involved. Without it a plugin's contributions
+ * are indistinguishable from ones the extension author wrote by hand, and the
+ * settings UI has nothing to show a row or a toggle for.
+ */
+interface LoadedPluginRecord {
+  /** Manifest name, or the plugin root's basename when it was rejected. */
+  name: string;
+  /** Name of the extension that loaded it. */
+  extensionName: string;
+  /** Plugin root as requested by the extension. */
+  dir: string;
+  /** Load result, including `manifest`, `components` and `diagnostics`. */
+  plugin: LoadedPlugin;
+}
 /** Per-extension contributions recorded during `setup`. */
 interface ExtensionContributions {
   tools: Readonly<Record<string, ToolDef>>;
   hooks: { readonly [E in keyof AgentHooks]?: ReadonlyArray<AgentHooks[E]> };
   mcpServers: readonly McpServerConfig[];
   skills: readonly SkillConfig[];
+  /** Agent Plugins loaded via `ctx.loadAgentPlugin`, in load order. */
+  plugins: readonly LoadedPluginRecord[];
   systemFragments: readonly string[];
   contextBreakdownSections: readonly ContextBreakdownContributor[];
   contextPanelSections: readonly ContextBreakdownContributor[];
@@ -12351,6 +12981,14 @@ interface ExtensionRegistry {
   mcpServers: readonly McpServerConfig[];
   /** Programmatic skills. */
   skills: readonly SkillConfig[];
+  /**
+   * Agent Plugins loaded by extensions, across every active extension.
+   *
+   * Informational — the plugins' own skills / servers already appear in
+   * `skills` and `mcpServers`. This is what lets the settings list show an
+   * extension-loaded plugin as its own row with its origin.
+   */
+  plugins: readonly LoadedPluginRecord[];
   /** System-prompt fragments, in registration order. */
   systemFragments: readonly string[];
   /** Extension-owned context panel contributors. */
@@ -13208,6 +13846,41 @@ declare function composeExtensionPreset(registry: ExtensionRegistry, explicitPre
  * nothing has changed.
  */
 declare function filterExtensionRegistry(registry: ExtensionRegistry, enabled: readonly string[] | undefined): ExtensionRegistry;
+/**
+ * Drop the contributions of Agent Plugins the user has disabled.
+ *
+ * `filterExtensionRegistry` keys on EXTENSION names, so it can't express
+ * "this extension runs, but the plugin it loaded does not". Plugin skills and
+ * MCP servers are fanned into the loading extension's sinks by
+ * `ctx.loadAgentPlugin`, which means without this pass `enabledPlugins` would
+ * render a checkbox that changes nothing for extension-loaded plugins.
+ *
+ * Skills are matched by `metadata['zidane.plugin']` (stamped by the loader);
+ * MCP servers carry no such marker, so they're matched by identity against
+ * the server list on each {@link LoadedPluginRecord}.
+ *
+ * Returns the input registry unchanged when nothing is disabled, so callers
+ * can compare identity to skip recomposing.
+ */
+declare function filterRegistryPlugins(registry: ExtensionRegistry, enabledPlugins: readonly string[] | undefined,
+/**
+ * Plugin names already provided by another source (in practice: disk
+ * discovery). Pruned regardless of the allowlist.
+ *
+ * The settings list dedupes a plugin found both on disk and inside an
+ * extension down to ONE row, preferring the disk copy. Contributions have to
+ * agree, or that single checkbox governs two live copies: both sets of skills
+ * reach the catalog, where one shadows the other and earns a spurious
+ * `name-collision-shadowed` warning about a collision the user never created.
+ *
+ * The MCP half is less severe but the same shape — both configs reach the
+ * merge, where `dedupMcpServers` (app.tsx, first-wins by name) collapses them
+ * to one. So there's no double spawn; what's wrong is that one checkbox
+ * nominally governs two records, and which copy survives is decided by merge
+ * order rather than by anything the user chose.
+ */
+
+shadowed?: ReadonlySet<string>): ExtensionRegistry;
 /** Dispose resources owned by an extension registry. Idempotent per registry. */
 declare function disposeExtensionRegistry(registry: ExtensionRegistry): Promise<void>;
 /** Shape returned by {@link partitionExtensionCatalog}. */
@@ -18296,5 +18969,5 @@ declare function definePreset(config: Preset): Preset;
  */
 declare function composePresets(...presets: Preset[]): Preset;
 //#endregion
-export { SessionArtifactDirMigration as $, ExtensionConfigSurface as $a, CompletionItem as $c, hashMessages as $d, planMistralReasoning as $f, ReasoningWireAction as $h, ExtensionCatalogPartition as $i, isInteractionTool as $l, ToolDef as $m, HeadlessResult as $n, ExtensionToolResultTransform as $o, DEFAULT_AGENT_CLOCK as $p, createRunSummaryCollector as $r, resolveSkills as $s, EvalRunUsage as $t, restoreChainFallbacks as $u, Meter as A, inlineLoadedExtension as Aa, BUILTIN_THEMES as Ac, shouldAutoCompact as Ad, OpenAICompatParams as Af, normalizeMcpServers as Ag, SessionRun as Ah, CompactionSlice as Ai, ConfirmQuestion as Al, StaleReadPolicy as Am, efficiencyMetricValues as An, ExtensionModal as Ao, OAuthParams as Ap, createSkillsReadTool as Ar, SpawnToolOptions as As, resolveExtensionDocsDir as At, DEFAULT_PERSIST_EXCLUDE_TOOLS as Au, McpCredentialStore as B, ExtensionConfigActionItem as Ba, resolveChipColor as Bc, ContextItem as Bd, mapOAIFinishReason as Bf, withExtensionSession as Bh, defaultRepeatGuardTracked as Bi, PlanRequest as Bl, ToolResultDocumentContent as Bm, functionalityMetric as Bn, ExtensionSessionStateSurface as Bo, OAuthProviderInterface as Bp, grep as Br, matchModelEntries as Bs, EvalAgentStats as Bt, Owner as Bu, SuccessfulMutationOutcome as C, removeInstalledExtension as Ca, installAllowedToolsGate as Cc, piIdOf as Cd, normalizeOpenRouterModelId as Cf, connectMcpServers as Cg, SkillSource as Ch, buildCompactPrompt as Ci, commandBlockToEvent as Cl, RunHookMap as Cm, clearRegisteredEvals as Cn, ExtensionFooterHint as Co, resolveAnthropicAuthShape as Cp, ToolSearchToolOptions as Cr, createExtensionHostRuntimeBridge as Cs, ZIDANE_SKILL_EDIT_SKILL_NAME as Ct, AgentAccent as Cu, Counter as D, ExtensionScanEntry as Da, SkillActivationState as Dc, AutoCompactInput as Dd, OAITool as Df, expandMcpConfigEnv as Dg, Session as Dh, buildUpToCompactPrompt as Di, parseCommandInvocation as Dl, SessionMessage as Dm, createReusableExecutionContext as Dn, ExtensionKeybindingDispatchContext as Do, PromptCacheKeyOption as Dp, SkillsRunScriptToolOptions as Dr, SpawnTaskInput as Ds, extensionDirForCwd as Dt, BUILTIN_AGENTS as Du, resolveModelTargets as E, ENTRY_CANDIDATES as Ea, DeactivationReason as Ec, AutoCompactDecision as Ed, OAIMessage as Ef, expandEnvPlaceholders as Eg, LoadSessionOptions as Eh, buildTailCompactPrompt as Ei, executeCommand as El, SessionHookContext as Em, createEvalRunReporter as En, ExtensionKeybinding as Eo, PromptCacheKeyContext as Ep, createSkillsUseTool as Er, ExtensionSubagentDef as Es, editSessionMetadata as Et, BUILD_AGENT as Eu, createMetricsHooks as F, discoverAndBuildExtensionRegistry as Fa, SyntaxTokenStyle as Fc, ContextCategory as Fd, assistantMessage as Ff, ModelCatalogSource as Fg, demoteStaleRunningStatus as Fh, summaryToTurn as Fi, InteractionsProvider as Fl, ToolBatchExecutor as Fm, fileExistsOneOf as Fn, ExtensionPromptTransform as Fo, isOAuthAccessToken as Fp, readFile as Fr, createSpawnTool as Fs, EvalAgent as Ft, EditDiffDisplay as Fu, OAuthCallbackHandle as G, ExtensionConfigChangeBehavior as Ga, createPathAutocompleteProvider as Gc, CacheBreakInfo as Gd, userMessage as Gf, FileMapStoreOptions as Gh, AgentHookMap as Gi, QuestionPayload as Gl, ToolResultTextContent as Gm, runEvalCase as Gn, ExtensionToolCatalogTransform as Go, AutoCompact as Gp, RunSummaryBudget as Gr, SkillValidationResult as Gs, EvalDefinitionContext as Gt, StreamEvent as Gu, McpOAuthProviderOptions as H, ExtensionConfigActionStatus as Ha, InlineAutocompleteContext as Hc, ContextSnapshot as Hd, openaiCompat as Hf, createRemoteStore as Hh, stableStringify as Hi, PlanStep as Hl, ToolResultImageContent as Hm, normalizeMetric as Hn, ExtensionSource as Ho, AgentClock as Hp, edit as Hr, writeSkillToDisk as Hs, EvalCaseOptions as Ht, Screen as Hu, LoginMcpServerOptions as I, ExtensionPromptBridge as Ia, Theme as Ic, ContextCategoryId as Id, buildAssistantContent as If, getModelCatalog as Ig, getExtensionSessionState as Ih, truncateHeadForPtlRetry as Ii, PRESENT_PLAN_TOOL as Il, ToolHookContext as Im, finalizeEvalMetrics as In, ExtensionProviderMiddleware as Io, readOAuthCredentials as Ip, multiEdit as Ir, isSpawnTool as Is, EvalAgentMcpServers as It, EditHunk as Iu, startOAuthCallback as J, ExtensionConfigItemBase as Ja, tokenEndingAtCursor as Jc, CacheDimensionName as Jd, mapCodexStopReason as Jf, ORPHANED_TOOL_RESULT_MARKER as Jh, McpConnector as Ji, QuestionType as Jl, TurnUsage as Jm, FormattedHeadlessTurnEvent as Jn, ExtensionToolRenderer as Jo, ChildRunStats as Jp, RunSummaryCollectorOptions as Jr, parseAllowedToolPattern as Js, EvalRunMetricAggregate as Jt, buildRunModel as Ju, OAuthCallbackOptions as K, ExtensionConfigEnumItem as Ka, patchInlineGhost as Kc, CacheBreakLoggerOptions as Kd, OpenAIParams as Kf, createFileMapStore as Kh, AgentHooks as Ki, QuestionRequest as Kl, ToolResultVideoContent as Km, statusCompleted as Kn, ExtensionToolPolicy as Ko, AutoCompactConfig as Kp, RunSummaryByModel as Kr, isToolAllowedByUnion as Ks, EvalMetric as Kt, ToolCallDisplay as Ku, LoginMcpServerResult as L, ExtensionPromptDelivery as La, ThemeColors as Lc, ContextExactCounts as Ld, classifyOpenAICompatError as Lf, setModelCatalog as Lg, loadSession as Lh, GenerateStructuredDataOptions as Li, PendingInteractionEntry as Ll, ToolOutcome as Lm, formatEvalCaseSummary as Ln, ExtensionRegistry as Lo, registerCustomOAuthProvider as Lp, listFiles as Lr, SpawnModelEntry as Ls, EvalAgentRunOptions as Lt, EditOutcome as Lu, MetricsHookSet as M, parseExtensionScanPathEnv as Ma, ChipColorMap as Mc, ContextBreakdownContributionContext as Md, TOOL_RESULTS_TAG as Mf, wrapDiscoveredMcpTools as Mg, createSession as Mh, anchorPreviewFor as Mi, InteractionRequest as Ml, StreamHookContext as Mm, fileContains as Mn, ExtensionOrderedContribution as Mo, credentialsFilePath as Mp, CreateShellToolOptions as Mr, SubagentDef as Ms, withZidaneSkillEditSkill as Mt, accentColor as Mu, MetricsHooksOptions as N, scanExtensionDirectories as Na, DEFAULT_THEME as Nc, ContextBreakdownContributor as Nd, applyOAICacheBreakpoints as Nf, ModelCatalog as Ng, currentExtensionSession as Nh, sliceForCompaction as Ni, InteractionResponse as Nl, ThinkingDecay as Nm, fileContentQuality as Nn, ExtensionPaths as No, credentialsFromParams as Np, createShellTool as Nr, SubagentOverride as Ns, CreateEvalAgentOptions as Nt, resolveAgentId as Nu, Histogram as O, defaultExtensionScanPaths as Oa, SkillActivationStateOptions as Oc, OUTPUT_RESERVE_TOKENS as Od, OpenAICompatAuthHeader as Of, nonOwningMcpView as Og, SessionData as Oh, ANCHOR_PREVIEW_MAX_CHARS as Oi, ASK_USER_TOOL as Ol, SessionTurn as Om, defineEval as On, ExtensionManifest as Oo, derivePromptCacheKey as Op, createSkillsRunScriptTool as Or, SpawnTaskOutcome as Os, extensionScaffold as Ot, DEFAULT_AGENT_ID as Ou, UpDownCounter as P, DiscoverAndBuildExtensionRegistryOptions as Pa, SyntaxStyles as Pc, ContextBreakdownOptions as Pd, applyOAIToolCacheBreakpoint as Pf, ModelCatalogEntry as Pg, deleteExtensionSessionState as Ph, stripImagesFromTurns as Pi, InteractionsActions as Pl, ThinkingLevel as Pm, fileExists as Pn, ExtensionPermission as Po, extractRuntimeCredentials as Pp, shell as Pr, SubagentRegistry as Ps, EFFICIENCY_METRICS as Pt, singleAgentRegistry as Pu, PersistOutcome as Q, ExtensionConfigStringItem as Qa, CompletionContext as Qc, fnv1a32 as Qd, mistral as Qf, PairingRepairMode as Qh, BuildExtensionRegistryOptions as Qi, createInteractionTools as Ql, ToolContext as Qm, HeadlessOutputFormat as Qn, ExtensionToolResultPatch as Qo, CompactStartHookContext as Qp, RunSummaryValidation as Qr, validateSkillName as Qs, EvalRunSummaryCase as Qt, providerKeySetChanged as Qu, loginMcpServer as R, createExtensionPromptBridge as Ra, ThemeSelect as Rc, ContextExtensionRow as Rd, consumeSSE as Rf, resumeChainRunIds as Rh, generateStructuredData as Ri, PlanDecision as Rl, ToolResultAudioContent as Rm, formatEvalRunSummary as Rn, ExtensionRunTransform as Ro, resolveOAuthApiKey as Rp, InteractionToolOptions as Rr, createModelSearchTool as Rs, EvalAgentRunResult as Rt, EditOutcomeKind as Ru, MutationValidationResult as S, readExtensionInstallProvenance as Sa, IMPLICITLY_ALLOWED_SKILL_TOOLS as Sc, openrouterDescriptor as Sd, OpenRouterParams as Sf, attachStderrWarnPump as Sg, SkillResource as Sh, TRAILER as Si, CommandStepFn as Sl, RetryConfig as Sm, buildTrajectory as Sn, ExtensionDefinition as So, planAnthropicThinking as Sp, LazyToolEntry as Sr, ExtensionWorkspaceSurface as Ss, ZIDANE_EXTENSION_SKILL_NAME as St, jsonSink as Su, normalizeProviders as T, registerExtensionHostModules as Ta, ActiveSkill as Tc, AUTO_COMPACT_MIN_GROWTH_FRACTION as Td, ASSISTANT_TOOL_CALLS_TAG as Tf, deriveMcpToolMeta as Tg, CreateSessionOptions as Th, buildFullCompactPrompt as Ti, commandSteps as Tl, SessionEndStatus as Tm, createEvalAgent as Tn, ExtensionGuiSurface as To, resolveAnthropicMaxOutput as Tp, SkillsUseToolOptions as Tr, ChildAgent as Ts, buildZidaneSkillEditSkill as Tt, AgentRegistry as Tu, createMemoryMcpCredentialStore as U, ExtensionConfigBooleanItem as Ua, InlineAutocompleteProvider as Uc, ContextUsageSplit as Ud, toOAIMessages as Uf, createMemoryStore as Uh, localReliabilityBehavior as Ui, Question as Ul, ToolResultImageRefContent as Um, registerEvalTests as Un, ExtensionStorageScope as Uo, AgentRunOptions as Up, RunSummary as Ur, writeSkillsToDisk as Us, EvalCaseResult as Ut, SessionMeta as Uu, McpOAuthProvider as V, ExtensionConfigActionResult as Va, resolveTheme as Vc, ContextMcpGroup as Vd, openAICompatPromptMessage as Vf, RemoteStoreOptions as Vh, normalizeShellCommand as Vi, PlanResponse as Vl, ToolResultDocumentRefContent as Vm, llmJudge as Vn, ExtensionSkillPolicy as Vo, AgentBehavior as Vp, glob as Vr, defineSkill as Vs, EvalArtifacts as Vt, Picked as Vu, hasAuthorizationHeader as W, ExtensionConfigCategory as Wa, InlineGhost as Wc, buildContextBreakdown as Wd, toolResultsMessage as Wf, FileMapAdapter as Wh, Agent as Wi, QuestionChoice as Wl, ToolResultMetadata as Wm, relativeArtifactPath as Wn, ExtensionStorageSurface as Wo, AgentStats as Wp, RunSummaryBlock as Wr, SkillValidationIssue as Ws, EvalDefinition as Wt, Settings as Wu, PERSISTENCE_PREVIEW_BYTES as X, ExtensionConfigNumberItem as Xa, useCompletion as Xc, CacheDriftInfo as Xd, toPiMessages as Xf, PairingDropKind as Xh, McpToolWrap as Xi, TextQuestion as Xl, toolOutputByteLength as Xm, HeadlessEvent as Xn, ExtensionToolRendererRegistration as Xo, CompactFunction as Xp, RunSummaryRepeatGuard as Xr, validateResourcePathReal as Xs, EvalRunReporterOptions as Xt, chainsEqual as Xu, PERSISTED_STUB_PREFIX as Y, ExtensionConfigModelItem as Ya, CompletionState as Yc, CacheDimensionSnapshot as Yd, openai as Yf, PairingDrop as Yh, McpToolMeta as Yi, SelectQuestion as Yl, toolOutputBudgetByteLength as Ym, HeadlessErrorInfo as Yn, ExtensionToolRendererEntry as Yo, CompactEndHookContext as Yp, RunSummaryError as Yr, validateResourcePath as Ys, EvalRunReporter as Yt, chainPositionOf as Yu, PersistInput as Z, ExtensionConfigScope as Za, ActiveTrigger as Zc, diffCacheDimensions as Zd, MistralParams as Zf, PairingRepair as Zh, createAgent as Zi, buildResumedToolResultsTurn as Zl, toolResultToText as Zm, HeadlessOptions as Zn, ExtensionToolResultMetadataRegistration as Zo, CompactHookContext as Zp, RunSummaryTokens as Zr, validateSkillForWrite as Zs, EvalRunSummary as Zt, filterChainFallbacks as Zu, statsByModel as _, InstalledExtensionTargetOptions as _a, getDefaultScanPaths as _c, localDescriptor as _d, SchemaSanitizeOptions as _f, toOpenAI as _g, isToolStateOps as _h, BASE_INSTRUCTIONS as _i, CommandOutputBlock as _l, PromptVideoPart as _m, TrajectoryStep as _n, ExtensionContext as _o, applyAnthropicCacheBreakpoints as _p, waitTask as _r, ExtensionModelEntry as _s, EXTENSION_EDIT_METADATA_KEY as _t, LoggingHooksOptions as _u, basicTools as a, mergeContributions as aa, SkillInstallCandidate as ac, detectAuth as ad, StreamCallbacks as af, autoDetectAndConvert as ag, hashContent as ah, RecentFile as ai, findActiveTrigger as al, McpToolHookContext as am, EvalWorkspaceFile as an, clampExtensionConfigNumber as ao, cerebras as ap, exitCodeForHeadlessResult as ar, ExtensionBannerOptions as as, resolveLegacySessionDir as at, InferSchemaOutput as au, MutationValidationHooksOptions as b, listExtensionCandidates as ba, parseSkillFile as bc, modelsForDescriptor as bd, sanitizeToolSchema as bf, McpConnection as bg, SkillConfig as bh, CompactPromptOptions as bi, CommandStep as bl, ResolveContentRef as bm, buildEvalRunSummary as bn, ExtensionCustomRenderer as bo, credentialIdentity as bp, TailTruncateOptions as br, ExtensionSessionsSurface as bs, SKILL_EDIT_METADATA_KEY as bt, createLogger as bu, StartSpan as c, ExtensionInstallCandidate as ca, SkillInstallOptions as cc, ModelInfo as cd, ToolCall as cf, ensureEndsWithUserMessage as cg, readStateKey as ch, selectFilesFromSession as ci, resolveCompletionSubmit as cl, ModelTargetSpec as cm, LlmJudgeOptions as cn, isValidExtensionConfigValue as co, planBasetenReasoning as cp, formattedHeadlessTurnEventToJsonl as cr, ExtensionHudStatus as cs, resolveSessionDir as ct, isStandardSchema as cu, TracingHooksOptions as d, ExtensionInstallIo as da, installSkillFromSpec as dc, anthropicDescriptor as dd, TurnResult as df, fromAnthropic as dg, StagedToolState as dh, CompactOptions as di, CommandArgSuggestion as dl, ProgressNudgeMessage as dm, MetricSpec as dn, sanitizeExtensionConfigActionPatch as do, AnthropicBedrockConfig as dp, providerTranscriptFormatForProvider as dr, ExtensionNotifyOptions as ds, SHELL_CASCADE_CANCEL_MESSAGE as dt, ConsoleSinkOptions as du, buildExtensionPreset as ea, InterpolateShellCommandsOptions as ec, sanitizeModelChain as ed, installCacheBreakLogger as ef, RemintResult as eg, ToolMap as eh, BYTES_PER_TOKEN as ei, CompletionProvider as el, DedupHasher as em, EvalScore as en, ExtensionConfigValue as eo, LocalParams as ep, HeadlessStatus as er, ExtensionToolVerdict as es, buildPersistedStub as et, makeRequestInteraction as eu, createTracingHooks as f, ExtensionInstallProvenance as fa, listSkillCandidates as fc, cerebrasDescriptor as fd, ZaiParams as ff, fromOpenAI as fg, ToolStateController as fh, CompactResult as fi, CommandAttachment as fl, PromptAudioPart as fm, MetricSpecMap as fn, toWireConfigSchema as fo, AnthropicContextManagement as fp, runHeadless as fr, ExtensionNotifyTone as fs, TOOL_USE_CANCELLED_MESSAGE as ft, LogLevel as fu, formatTokenUsage as g, InstallExtensionFromSpecOptions as ga, discoverSkills as gc, getModelInfo as gd, xai as gf, toAnthropic as gg, createToolStateController as gh, CompactPromptTooLongError as gi, CommandInvocation as gl, PromptTextPart as gm, Trajectory as gn, ExtensionCapability as go, anthropic as gp, WAIT_TASK_TIMED_OUT_PREFIX as gr, ExtensionHostRuntimeImpl as gs, renderStaleReadNotice as gt, LoggingHookSet as gu, flattenTurns as h, ExtensionInstallSource as ha, SourcedScanPath as hc, getContextWindow as hd, XaiParams as hf, sanitizeHistoryForProvider as hg, ToolStateView as hh, CompactInvalidInputError as hi, CommandInteraction as hl, PromptPart as hm, ReusableExecutionContext as hn, ExtensionBehaviorTransform as ho, EXTENDED_CACHE_TTL_BETA as hp, writeFile as hr, ExtensionHostRuntimeBridge as hs, collectNewlyStaleReadPaths as ht, Logger as hu, _default as i, filterExtensionRegistry as ia, SkillCandidateDetail as ic, ProviderKey as id, ProviderCapabilities as if, TurnInterruptionState as ig, getReadState as ih, PostCompactRestoreOptions as ii, collectReferences as il, McpServerConfig as im, EvalVariantSummary as in, WireExtensionConfigSchema as io, CerebrasParams as ip, ProviderTranscriptFormat as ir, TuiContributions as is, resolveLegacyPersistDir as it, useInteractionsQueue as iu, MetricAttributes as j, isExtensionDefinition as ja, ChipColor as jc, ContextBreakdown as jd, OpenAICompatStreamError as jf, resultToString as jg, SessionStore as jh, SummaryToTurnInput as ji, CreateInteractionToolsOptions as jl, StepThinkingDecay as jm, emitEfficiencyMetrics as jn, ExtensionModalNode as jo, ResolveOAuthApiKeyOptions as jp, shellKill as jr, SpawnToolState as js, withZidaneExtensionSkill as jt, PLAN_AGENT as ju, InstrumentOptions as k, discoverExtensions as ka, createSkillActivationState as kc, effectiveContextWindow as kd, OpenAICompatHttpError as kf, normalizeMcpBlocks as kg, SessionMetaRow as kh, CompactScope as ki, AnswerValue as kl, SpawnHookContext as km, defineMetrics as kn, ExtensionMcpConfigTransform as ko, resolvePromptCacheKey as kp, SkillsReadToolOptions as kr, SpawnTool as ks, readSkillEditMarker as kt, DEFAULT_BUDGET_EXCLUDE_TOOLS as ku, TracingConventions as l, ExtensionInstallError as la, SkillInstallResult as lc, ModelOption as ld, ToolResult as lf, ensureToolResultPairing as lg, resolveReadStateMap as lh, selectRecentFiles as li, Command as ll, OAuthRefreshHookContext as lm, MetricDirection as ln, resolveExtensionConfig as lo, ArceeParams as lp, headlessEventToJsonl as lr, ExtensionHudWriter as ls, resolveTasksDir as lt, resolveSchemaInput as lu, TokenUsageLike as m, ExtensionInstallScope as ma, readSkillProvenance as mc, enabledModelOptions as md, zai as mf, remintDuplicateToolCallIds as mg, ToolStateStore as mh, compactConversation as mi, CommandGenerateDataOptions as ml, PromptImagePart as mm, RegisterEvalTestsOptions as mn, ExtensionApiVersion as mo, AnthropicThinkingPlan as mp, transcriptToProviderMessages as mr, createExtensionHud as ms, applyCompactSummaryCutoff as mt, LogSink as mu, composePresets as n, composeExtensionPreset as na, stripShellInterpolations as nc, AuthMethod as nd, HistoryRepair as nf, TOOL_USE_INTERRUPTED_MARKER as ng, ReadStateEntry as nh, utf8ByteLength as ni, CompletionSubmitContext as nl, GeometricThinkingDecay as nm, EvalScorerContext as nn, StoredExtensionConfigItem as no, CursorParams as np, OpenAIChatContentPart as nr, GuiContributions as ns, maybePersistToolResult as nt, serializeInteractionResponse as nu, GEN_AI_ATTRIBUTES as o, partitionExtensionCatalog as oa, SkillInstallError as oc, BUILTIN_PROVIDERS as od, StreamOptions as of, detectTurnInterruption as og, hydrateReadStateFromSession as oh, buildPostCompactAttachments as oi, mergeReferences as ol, McpToolSchema as om, EvalWorkspaceOptions as on, coerceExtensionConfigInput as oo, BasetenParams as op, formatHeadlessResult as or, ExtensionHud as os, resolveMcpWarningsDir as ot, SchemaInput as ou, ModelUsage as p, ExtensionInstallResult as pa, parseSkillInstallSpec as pc, credKeyOf as pd, planZaiReasoning as pf, reasoningWireAction as pg, ToolStateOp as ph, CompactStartEvent as pi, CommandExecution as pl, PromptDocumentPart as pm, MetricStats as pn, EMPTY_EXTENSION_REGISTRY as po, AnthropicParams as pp, transcriptToOpenAIMessages as pr, ExtensionStatusOptions as ps, TOOL_USE_SKIPPED_MESSAGE as pt, LogRecord as pu, OAuthCallbackResult as q, ExtensionConfigItem as qa, resolveInlineSuggestion as qc, CacheDimensionDiff as qd, classifyOpenAIError as qf, EnsureToolResultPairingOptions as qh, AgentOptions as qi, QuestionResponse as ql, TurnFinishReason as qm, FormattedHeadlessResult as qn, ExtensionToolRenderProps as qo, CacheTtl as qp, RunSummaryCollector as qr, matchesAllowedTool as qs, EvalMetricError as qt, ModelChainEntry as qu, definePreset as r, disposeExtensionRegistry as ra, SKILL_PROVENANCE_FILE as rc, ProviderAuth as rd, Provider as rf, ToWireMessagesOptions as rg, ReadStateMap as rh, PostCompactAttachments as ri, applyInsert as rl, JsonValue as rm, EvalTestRunner as rn, WireExtensionConfigItem as ro, cursor as rp, OpenAIChatMessage as rr, LoadedExtension as rs, migrateSessionArtifactDirs as rt, useInteractionsActions as ru, Span as s, ExtensionFetchResult as sa, SkillInstallErrorCode as sc, CustomField as sd, TokenCountPayload as sf, dropInvalidToolPairings as sg, hydrateReadStateFromSessionAsync as sh, selectFilesFromReadState as si, mergeSuggestions as sl, ModelTarget as sm, EvalWorkspaceSnapshot as sn, isValidExtensionConfigItem as so, baseten as sp, formatHeadlessTurnEvent as sr, ExtensionHudState as ss, resolvePersistDir as st, StandardSchemaLike as su, Preset as t, buildExtensionRegistry as ta, interpolateShellCommands as tc, toggleChainEntry as td, snapshotCacheDimensions as tf, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as tg, HydrateReadStateOptions as th, estimateTokens as ti, CompletionReference as tl, DedupToolConfig as tm, EvalScorer as tn, ExtensionConfigValueItem as to, local as tp, HeadlessUsage as tr, ExtensionTuiSurface as ts, cleanupPersistedSession as tt, pendingInteractionsFromTurns as tu, TracingHookSet as u, ExtensionInstallErrorCode as ua, SkillInstallSpec as uc, ProviderDescriptor as ud, ToolSpec as uf, filterUnresolvedToolUses as ug, DEFAULT_MAX_VALUE_BYTES as uh, CompactEndEvent as ui, CommandAgentResult as ul, ProgressNudgeKind as um, MetricEmitter as un, resolveExtensionConfigValue as uo, arcee as up, installHeadlessEventAdapter as ur, ExtensionNotification as us, INTERRUPT_MESSAGE_FOR_TOOL_USE as ut, zodToJsonSchema as uu, MutationValidationBatch as v, fetchExtensionSource as va, inferSource as vc, modelOptionsFor as vd, SchemaSanitizeProfile as vf, toWireMessages as vg, stagedToolState as vh, CompactDirection as vi, CommandSpawnResult as vl, RepeatGuardConfig as vm, TrajectoryStepKind as vn, ExtensionContextTransform as vo, buildAnthropicClientOptions as vp, ValidationResult as vr, ExtensionRuntimeSurface as vs, EditSessionTarget as vt, RingBufferSink as vu, createMutationValidationHooks as w, updateInstalledExtension as wa, ActivationVia as wc, restoreModelOptions as wd, openrouter as wf, createStderrLineEmitter as wg, SkillsConfig as wh, buildFromCompactPrompt as wi, commandBlocksToContent as wl, SessionContentBlock as wm, computeEvalTagScores as wn, ExtensionGuiPanel as wo, resolveAnthropicBetas as wp, createToolSearchTool as wr, createWorkspaceSurface as ws, buildZidaneExtensionSkill as wt, AgentProfile as wu, MutationValidationMutation as x, parseExtensionInstallSource as xa, buildCatalog as xc, openaiDescriptor as xd, sanitizeToolSpecs as xf, McpExecutionBinding as xg, SkillDiagnostic as xh, NO_TOOLS_PREAMBLE as xi, CommandStepContext as xl, ResolveContentRefBlock as xm, buildRegisteredEvals as xn, ExtensionCustomRendererEntry as xo, defaultAnthropicMaxTokens as xp, tailTruncate as xr, ExtensionWorkspacePair as xs, SkillEditMarker as xt, createLoggingHooks as xu, MutationValidationFailure as y, installExtensionFromSpec as ya, parseFrontmatter as yc, modelSupportsReasoning as yd, SchemaSanitizeResult as yf, ConnectMcpServersOptions as yg, ShellInterpolationApproval as yh, CompactPromptBuilder as yi, CommandSpawnTask as yl, RepeatGuardToolMatcher as ym, artifactPath as yn, ExtensionContributions as yo, classifyAnthropicError as yp, validateToolArgs as yr, ExtensionSessionSummary as ys, ExtensionEditMarker as yt, consoleSink as yu, McpCredentialEntry as z, defineExtension as za, ThemeSurfaces as zc, ContextExtensionSection as zd, formatTools as zf, setExtensionSessionState as zh, defaultRepeatGuardNormalize as zi, PlanPayload as zl, ToolResultContent as zm, formatTrajectoryLine as zn, ExtensionRuntimeEnv as zo, writeOAuthCredentials as zp, createInteractionTool as zr, formatModelLine as zs, EvalAgentRunStats as zt, EditPayload as zu };
-//# sourceMappingURL=index-C-Nd2ZbV.d.ts.map
+export { SessionArtifactDirMigration as $, ExtensionConfigStringItem as $a, createSkillActivationState as $c, restoreModelOptions as $d, openrouter as $f, createStderrLineEmitter as $g, SkillsConfig as $h, ExtensionCatalogPartition as $i, commandBlocksToContent as $l, SessionContentBlock as $m, HeadlessResult as $n, ExtensionToolResultMetadataRegistration as $o, resolveAnthropicBetas as $p, createRunSummaryCollector as $r, AgentPluginsVersion as $s, EvalRunUsage as $t, AgentProfile as $u, Meter as A, discoverExtensions as Aa, SkillInstallError as Ac, toggleChainEntry as Ad, snapshotCacheDimensions as Af, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as Ag, HydrateReadStateOptions as Ah, CompactionSlice as Ai, CompletionReference as Al, DedupToolConfig as Am, efficiencyMetricValues as An, ExtensionManifest as Ao, local as Ap, createSkillsReadTool as Ar, SpawnTaskInput as As, resolveExtensionDocsDir as At, pendingInteractionsFromTurns as Au, McpCredentialStore as B, defineExtension as Ba, discoverSkills as Bc, anthropicDescriptor as Bd, TurnResult as Bf, fromAnthropic as Bg, StagedToolState as Bh, defaultRepeatGuardTracked as Bi, CommandArgSuggestion as Bl, ProgressNudgeMessage as Bm, functionalityMetric as Bn, ExtensionRunTransform as Bo, AnthropicBedrockConfig as Bp, grep as Br, SpawnModelEntry as Bs, EvalAgentStats as Bt, ConsoleSinkOptions as Bu, SuccessfulMutationOutcome as C, readExtensionInstallProvenance as Ca, resolveSkills as Cc, buildRunModel as Cd, CacheDimensionName as Cf, ORPHANED_TOOL_RESULT_MARKER as Cg, TurnUsage as Ch, buildCompactPrompt as Ci, tokenEndingAtCursor as Cl, ChildRunStats as Cm, clearRegisteredEvals as Cn, ExtensionCustomRendererEntry as Co, mapCodexStopReason as Cp, ToolSearchToolOptions as Cr, ExtensionSessionsSurface as Cs, ZIDANE_SKILL_EDIT_SKILL_NAME as Ct, QuestionType as Cu, Counter as D, ENTRY_CANDIDATES as Da, SKILL_PROVENANCE_FILE as Dc, providerKeySetChanged as Dd, fnv1a32 as Df, PairingRepairMode as Dg, ToolContext as Dh, buildUpToCompactPrompt as Di, CompletionContext as Dl, CompactStartHookContext as Dm, createReusableExecutionContext as Dn, ExtensionGuiSurface as Do, mistral as Dp, SkillsRunScriptToolOptions as Dr, createWorkspaceSurface as Ds, extensionDirForCwd as Dt, createInteractionTools as Du, resolveModelTargets as E, registerExtensionHostModules as Ea, stripShellInterpolations as Ec, filterChainFallbacks as Ed, diffCacheDimensions as Ef, PairingRepair as Eg, toolResultToText as Eh, buildTailCompactPrompt as Ei, ActiveTrigger as El, CompactHookContext as Em, createEvalRunReporter as En, ExtensionGuiPanel as Eo, MistralParams as Ep, createSkillsUseTool as Er, createExtensionHostRuntimeBridge as Es, editSessionMetadata as Et, buildResumedToolResultsTurn as Eu, createMetricsHooks as F, DiscoverAndBuildExtensionRegistryOptions as Fa, installSkillFromSpec as Fc, BUILTIN_PROVIDERS as Fd, StreamOptions as Ff, detectTurnInterruption as Fg, hydrateReadStateFromSession as Fh, summaryToTurn as Fi, mergeReferences as Fl, McpToolSchema as Fm, fileExistsOneOf as Fn, ExtensionPaths as Fo, BasetenParams as Fp, readFile as Fr, SubagentDef as Fs, EvalAgent as Ft, SchemaInput as Fu, OAuthCallbackHandle as G, ExtensionConfigCategory as Ga, buildCatalog as Gc, getModelInfo as Gd, xai as Gf, toAnthropic as Gg, createToolStateController as Gh, AgentHookMap as Gi, CommandInvocation as Gl, PromptTextPart as Gm, runEvalCase as Gn, ExtensionStorageScope as Go, anthropic as Gp, RunSummaryBudget as Gr, PLUGIN_MCP_FILE as Gs, EvalDefinitionContext as Gt, LoggingHookSet as Gu, McpOAuthProviderOptions as H, ExtensionConfigActionResult as Ha, inferSource as Hc, credKeyOf as Hd, planZaiReasoning as Hf, reasoningWireAction as Hg, ToolStateOp as Hh, stableStringify as Hi, CommandExecution as Hl, PromptDocumentPart as Hm, normalizeMetric as Hn, ExtensionSessionStateSurface as Ho, AnthropicParams as Hp, edit as Hr, formatModelLine as Hs, EvalCaseOptions as Ht, LogRecord as Hu, LoginMcpServerOptions as I, discoverAndBuildExtensionRegistry as Ia, listSkillCandidates as Ic, CustomField as Id, TokenCountPayload as If, dropInvalidToolPairings as Ig, hydrateReadStateFromSessionAsync as Ih, truncateHeadForPtlRetry as Ii, mergeSuggestions as Il, ModelTarget as Im, finalizeEvalMetrics as In, ExtensionPermission as Io, baseten as Ip, multiEdit as Ir, SubagentOverride as Is, EvalAgentMcpServers as It, StandardSchemaLike as Iu, startOAuthCallback as J, ExtensionConfigItem as Ja, ActivationVia as Jc, modelSupportsReasoning as Jd, SchemaSanitizeResult as Jf, ConnectMcpServersOptions as Jg, ShellInterpolationApproval as Jh, McpConnector as Ji, CommandSpawnTask as Jl, RepeatGuardToolMatcher as Jm, FormattedHeadlessTurnEvent as Jn, ExtensionToolPolicy as Jo, classifyAnthropicError as Jp, RunSummaryCollectorOptions as Jr, parsePluginManifest as Js, EvalRunMetricAggregate as Jt, consoleSink as Ju, OAuthCallbackOptions as K, ExtensionConfigChangeBehavior as Ka, IMPLICITLY_ALLOWED_SKILL_TOOLS as Kc, localDescriptor as Kd, SchemaSanitizeOptions as Kf, toOpenAI as Kg, isToolStateOps as Kh, AgentHooks as Ki, CommandOutputBlock as Kl, PromptVideoPart as Km, statusCompleted as Kn, ExtensionStorageSurface as Ko, applyAnthropicCacheBreakpoints as Kp, RunSummaryByModel as Kr, expandPluginVars as Ks, EvalMetric as Kt, LoggingHooksOptions as Ku, LoginMcpServerResult as L, ExtensionPromptBridge as La, parseSkillInstallSpec as Lc, ModelInfo as Ld, ToolCall as Lf, ensureEndsWithUserMessage as Lg, readStateKey as Lh, GenerateStructuredDataOptions as Li, resolveCompletionSubmit as Ll, ModelTargetSpec as Lm, formatEvalCaseSummary as Ln, ExtensionPromptTransform as Lo, planBasetenReasoning as Lp, listFiles as Lr, SubagentRegistry as Ls, EvalAgentRunOptions as Lt, isStandardSchema as Lu, MetricsHookSet as M, isExtensionDefinition as Ma, SkillInstallOptions as Mc, ProviderAuth as Md, Provider as Mf, ToWireMessagesOptions as Mg, ReadStateMap as Mh, anchorPreviewFor as Mi, applyInsert as Ml, JsonValue as Mm, fileContains as Mn, ExtensionModal as Mo, cursor as Mp, CreateShellToolOptions as Mr, SpawnTool as Ms, withZidaneSkillEditSkill as Mt, useInteractionsActions as Mu, MetricsHooksOptions as N, parseExtensionScanPathEnv as Na, SkillInstallResult as Nc, ProviderKey as Nd, ProviderCapabilities as Nf, TurnInterruptionState as Ng, getReadState as Nh, sliceForCompaction as Ni, collectReferences as Nl, McpServerConfig as Nm, fileContentQuality as Nn, ExtensionModalNode as No, CerebrasParams as Np, createShellTool as Nr, SpawnToolOptions as Ns, CreateEvalAgentOptions as Nt, useInteractionsQueue as Nu, Histogram as O, ExtensionScanEntry as Oa, SkillCandidateDetail as Oc, restoreChainFallbacks as Od, hashMessages as Of, ReasoningWireAction as Og, ToolDef as Oh, ANCHOR_PREVIEW_MAX_CHARS as Oi, CompletionItem as Ol, DEFAULT_AGENT_CLOCK as Om, defineEval as On, ExtensionKeybinding as Oo, planMistralReasoning as Op, createSkillsRunScriptTool as Or, ChildAgent as Os, extensionScaffold as Ot, isInteractionTool as Ou, UpDownCounter as P, scanExtensionDirectories as Pa, SkillInstallSpec as Pc, detectAuth as Pd, StreamCallbacks as Pf, autoDetectAndConvert as Pg, hashContent as Ph, stripImagesFromTurns as Pi, findActiveTrigger as Pl, McpToolHookContext as Pm, fileExists as Pn, ExtensionOrderedContribution as Po, cerebras as Pp, shell as Pr, SpawnToolState as Ps, EFFICIENCY_METRICS as Pt, InferSchemaOutput as Pu, PersistOutcome as Q, ExtensionConfigScope as Qa, SkillActivationStateOptions as Qc, piIdOf as Qd, normalizeOpenRouterModelId as Qf, connectMcpServers as Qg, SkillSource as Qh, BuildExtensionRegistryOptions as Qi, commandBlockToEvent as Ql, RunHookMap as Qm, HeadlessOutputFormat as Qn, ExtensionToolRendererRegistration as Qo, resolveAnthropicAuthShape as Qp, RunSummaryValidation as Qr, loadAgentPlugin as Qs, EvalRunSummaryCase as Qt, AgentAccent as Qu, loginMcpServer as R, ExtensionPromptDelivery as Ra, readSkillProvenance as Rc, ModelOption as Rd, ToolResult as Rf, ensureToolResultPairing as Rg, resolveReadStateMap as Rh, generateStructuredData as Ri, Command as Rl, OAuthRefreshHookContext as Rm, formatEvalRunSummary as Rn, ExtensionProviderMiddleware as Ro, ArceeParams as Rp, InteractionToolOptions as Rr, createSpawnTool as Rs, EvalAgentRunResult as Rt, resolveSchemaInput as Ru, MutationValidationResult as S, parseExtensionInstallSource as Sa, validateSkillName as Sc, ModelChainEntry as Sd, CacheDimensionDiff as Sf, EnsureToolResultPairingOptions as Sg, TurnFinishReason as Sh, TRAILER as Si, resolveInlineSuggestion as Sl, CacheTtl as Sm, buildTrajectory as Sn, ExtensionCustomRenderer as So, classifyOpenAIError as Sp, LazyToolEntry as Sr, ExtensionSessionSummary as Ss, ZIDANE_EXTENSION_SKILL_NAME as St, QuestionResponse as Su, normalizeProviders as T, updateInstalledExtension as Ta, interpolateShellCommands as Tc, chainsEqual as Td, CacheDriftInfo as Tf, PairingDropKind as Tg, toolOutputByteLength as Th, buildFullCompactPrompt as Ti, useCompletion as Tl, CompactFunction as Tm, createEvalAgent as Tn, ExtensionFooterHint as To, toPiMessages as Tp, SkillsUseToolOptions as Tr, ExtensionWorkspaceSurface as Ts, buildZidaneSkillEditSkill as Tt, TextQuestion as Tu, createMemoryMcpCredentialStore as U, ExtensionConfigActionStatus as Ua, parseFrontmatter as Uc, enabledModelOptions as Ud, zai as Uf, remintDuplicateToolCallIds as Ug, ToolStateStore as Uh, localReliabilityBehavior as Ui, CommandGenerateDataOptions as Ul, PromptImagePart as Um, registerEvalTests as Un, ExtensionSkillPolicy as Uo, AnthropicThinkingPlan as Up, RunSummary as Ur, matchModelEntries as Us, EvalCaseResult as Ut, LogSink as Uu, McpOAuthProvider as V, ExtensionConfigActionItem as Va, getDefaultScanPaths as Vc, cerebrasDescriptor as Vd, ZaiParams as Vf, fromOpenAI as Vg, ToolStateController as Vh, normalizeShellCommand as Vi, CommandAttachment as Vl, PromptAudioPart as Vm, llmJudge as Vn, ExtensionRuntimeEnv as Vo, AnthropicContextManagement as Vp, glob as Vr, createModelSearchTool as Vs, EvalArtifacts as Vt, LogLevel as Vu, hasAuthorizationHeader as W, ExtensionConfigBooleanItem as Wa, parseSkillFile as Wc, getContextWindow as Wd, XaiParams as Wf, sanitizeHistoryForProvider as Wg, ToolStateView as Wh, Agent as Wi, CommandInteraction as Wl, PromptPart as Wm, relativeArtifactPath as Wn, ExtensionSource as Wo, EXTENDED_CACHE_TTL_BETA as Wp, RunSummaryBlock as Wr, PLUGIN_SKILLS_DIR as Ws, EvalDefinition as Wt, Logger as Wu, PERSISTENCE_PREVIEW_BYTES as X, ExtensionConfigModelItem as Xa, DeactivationReason as Xc, openaiDescriptor as Xd, sanitizeToolSpecs as Xf, McpExecutionBinding as Xg, SkillDiagnostic as Xh, McpToolWrap as Xi, CommandStepContext as Xl, ResolveContentRefBlock as Xm, HeadlessEvent as Xn, ExtensionToolRenderer as Xo, defaultAnthropicMaxTokens as Xp, RunSummaryRepeatGuard as Xr, PLUGIN_MANIFEST_FILE as Xs, EvalRunReporterOptions as Xt, createLoggingHooks as Xu, PERSISTED_STUB_PREFIX as Y, ExtensionConfigItemBase as Ya, ActiveSkill as Yc, modelsForDescriptor as Yd, sanitizeToolSchema as Yf, McpConnection as Yg, SkillConfig as Yh, McpToolMeta as Yi, CommandStep as Yl, ResolveContentRef as Ym, HeadlessErrorInfo as Yn, ExtensionToolRenderProps as Yo, credentialIdentity as Yp, RunSummaryError as Yr, validatePluginManifest as Ys, EvalRunReporter as Yt, createLogger as Yu, PersistInput as Z, ExtensionConfigNumberItem as Za, SkillActivationState as Zc, openrouterDescriptor as Zd, OpenRouterParams as Zf, attachStderrWarnPump as Zg, SkillResource as Zh, createAgent as Zi, CommandStepFn as Zl, RetryConfig as Zm, HeadlessOptions as Zn, ExtensionToolRendererEntry as Zo, planAnthropicThinking as Zp, RunSummaryTokens as Zr, defaultPluginDataRoot as Zs, EvalRunSummary as Zt, jsonSink as Zu, statsByModel as _, InstallExtensionFromSpecOptions as _a, matchesAllowedTool as _c, Screen as _d, ContextSnapshot as _f, createRemoteStore as _g, ToolResultImageContent as _h, BASE_INSTRUCTIONS as _i, InlineAutocompleteContext as _l, AgentClock as _m, TrajectoryStep as _n, ExtensionBehaviorTransform as _o, openaiCompat as _p, waitTask as _r, createExtensionHud as _s, EXTENSION_EDIT_METADATA_KEY as _t, PlanStep as _u, basicTools as a, normalizeMcpServers as a_, filterRegistryPlugins as aa, PluginManifest as ac, DEFAULT_PERSIST_EXCLUDE_TOOLS as ad, shouldAutoCompact as af, SessionRun as ag, StaleReadPolicy as ah, RecentFile as ai, BUILTIN_THEMES as al, OAuthParams as am, EvalWorkspaceFile as an, WireExtensionConfigSchema as ao, OpenAICompatParams as ap, exitCodeForHeadlessResult as ar, LoadedExtension as as, resolveLegacySessionDir as at, ConfirmQuestion as au, MutationValidationHooksOptions as b, installExtensionFromSpec as ba, validateResourcePathReal as bc, StreamEvent as bd, CacheBreakInfo as bf, FileMapStoreOptions as bg, ToolResultTextContent as bh, CompactPromptOptions as bi, createPathAutocompleteProvider as bl, AutoCompact as bm, buildEvalRunSummary as bn, ExtensionContextTransform as bo, userMessage as bp, TailTruncateOptions as br, ExtensionModelEntry as bs, SKILL_EDIT_METADATA_KEY as bt, QuestionPayload as bu, StartSpan as c, wrapDiscoveredMcpTools as c_, ExtensionFetchResult as ca, agentPluginsSchemaId as cc, resolveAgentId as cd, ContextBreakdownContributor as cf, currentExtensionSession as cg, ThinkingDecay as ch, selectFilesFromSession as ci, DEFAULT_THEME as cl, credentialsFromParams as cm, LlmJudgeOptions as cn, isValidExtensionConfigItem as co, applyOAICacheBreakpoints as cp, formattedHeadlessTurnEventToJsonl as cr, ExtensionBannerOptions as cs, resolveSessionDir as ct, InteractionResponse as cu, TracingHooksOptions as d, originPinnedFetch as d_, ExtensionInstallErrorCode as da, defineSkill as dc, EditHunk as dd, ContextCategoryId as df, getExtensionSessionState as dg, ToolHookContext as dh, CompactOptions as di, Theme as dl, readOAuthCredentials as dm, MetricSpec as dn, resolveExtensionConfigValue as do, buildAssistantContent as dp, providerTranscriptFormatForProvider as dr, ExtensionHudStatus as ds, SHELL_CASCADE_CANCEL_MESSAGE as dt, PRESENT_PLAN_TOOL as du, deriveMcpToolMeta as e_, buildExtensionPreset as ea, LoadAgentPluginOptions as ec, AgentRegistry as ed, AUTO_COMPACT_MIN_GROWTH_FRACTION as ef, CreateSessionOptions as eg, SessionEndStatus as eh, BYTES_PER_TOKEN as ei, ResolveStorageDirsOptions as el, resolveAnthropicMaxOutput as em, EvalScore as en, ExtensionConfigSurface as eo, ASSISTANT_TOOL_CALLS_TAG as ep, HeadlessStatus as er, ExtensionToolResultPatch as es, buildPersistedStub as et, commandSteps as eu, createTracingHooks as f, ModelCatalog as f_, ExtensionInstallIo as fa, writeSkillToDisk as fc, EditOutcome as fd, ContextExactCounts as ff, loadSession as fg, ToolOutcome as fh, CompactResult as fi, ThemeColors as fl, registerCustomOAuthProvider as fm, MetricSpecMap as fn, sanitizeExtensionConfigActionPatch as fo, classifyOpenAICompatError as fp, runHeadless as fr, ExtensionHudWriter as fs, TOOL_USE_CANCELLED_MESSAGE as ft, PendingInteractionEntry as fu, formatTokenUsage as g, setModelCatalog as g_, ExtensionInstallSource as ga, isToolAllowedByUnion as gc, Picked as gd, ContextMcpGroup as gf, RemoteStoreOptions as gg, ToolResultDocumentRefContent as gh, CompactPromptTooLongError as gi, resolveTheme as gl, AgentBehavior as gm, Trajectory as gn, ExtensionApiVersion as go, openAICompatPromptMessage as gp, WAIT_TASK_TIMED_OUT_PREFIX as gr, ExtensionStatusOptions as gs, renderStaleReadNotice as gt, PlanResponse as gu, flattenTurns as h, getModelCatalog as h_, ExtensionInstallScope as ha, SkillValidationResult as hc, Owner as hd, ContextItem as hf, withExtensionSession as hg, ToolResultDocumentContent as hh, CompactInvalidInputError as hi, resolveChipColor as hl, OAuthProviderInterface as hm, ReusableExecutionContext as hn, ExtensionAgentPluginOptions as ho, mapOAIFinishReason as hp, writeFile as hr, ExtensionNotifyTone as hs, collectNewlyStaleReadPaths as ht, PlanRequest as hu, _default as i, normalizeMcpBlocks as i_, filterExtensionRegistry as ia, PluginDiagnostic as ic, DEFAULT_BUDGET_EXCLUDE_TOOLS as id, effectiveContextWindow as if, SessionMetaRow as ig, SpawnHookContext as ih, PostCompactRestoreOptions as ii, resolveStorageDirs as il, resolvePromptCacheKey as im, EvalVariantSummary as in, WireExtensionConfigItem as io, OpenAICompatHttpError as ip, ProviderTranscriptFormat as ir, GuiContributions as is, resolveLegacyPersistDir as it, AnswerValue as iu, MetricAttributes as j, inlineLoadedExtension as ja, SkillInstallErrorCode as jc, AuthMethod as jd, HistoryRepair as jf, TOOL_USE_INTERRUPTED_MARKER as jg, ReadStateEntry as jh, SummaryToTurnInput as ji, CompletionSubmitContext as jl, GeometricThinkingDecay as jm, emitEfficiencyMetrics as jn, ExtensionMcpConfigTransform as jo, CursorParams as jp, shellKill as jr, SpawnTaskOutcome as js, withZidaneExtensionSkill as jt, serializeInteractionResponse as ju, InstrumentOptions as k, defaultExtensionScanPaths as ka, SkillInstallCandidate as kc, sanitizeModelChain as kd, installCacheBreakLogger as kf, RemintResult as kg, ToolMap as kh, CompactScope as ki, CompletionProvider as kl, DedupHasher as km, defineMetrics as kn, ExtensionKeybindingDispatchContext as ko, LocalParams as kp, SkillsReadToolOptions as kr, ExtensionSubagentDef as ks, readSkillEditMarker as kt, makeRequestInteraction as ku, TracingConventions as l, PinnedFetch as l_, ExtensionInstallCandidate as la, isSupportedAgentPluginsVersion as lc, singleAgentRegistry as ld, ContextBreakdownOptions as lf, deleteExtensionSessionState as lg, ThinkingLevel as lh, selectRecentFiles as li, SyntaxStyles as ll, extractRuntimeCredentials as lm, MetricDirection as ln, isValidExtensionConfigValue as lo, applyOAIToolCacheBreakpoint as lp, headlessEventToJsonl as lr, ExtensionHud as ls, resolveTasksDir as lt, InteractionsActions as lu, TokenUsageLike as m, ModelCatalogSource as m_, ExtensionInstallResult as ma, SkillValidationIssue as mc, EditPayload as md, ContextExtensionSection as mf, setExtensionSessionState as mg, ToolResultContent as mh, compactConversation as mi, ThemeSurfaces as ml, writeOAuthCredentials as mm, RegisterEvalTestsOptions as mn, EMPTY_EXTENSION_REGISTRY as mo, formatTools as mp, transcriptToProviderMessages as mr, ExtensionNotifyOptions as ms, applyCompactSummaryCutoff as mt, PlanPayload as mu, composePresets as n, expandMcpConfigEnv as n_, composeExtensionPreset as na, PluginAuthor as nc, BUILTIN_AGENTS as nd, AutoCompactInput as nf, Session as ng, SessionMessage as nh, utf8ByteLength as ni, StorageMode as nl, PromptCacheKeyOption as nm, EvalScorerContext as nn, ExtensionConfigValueItem as no, OAITool as np, OpenAIChatContentPart as nr, ExtensionToolVerdict as ns, maybePersistToolResult as nt, parseCommandInvocation as nu, GEN_AI_ATTRIBUTES as o, resolveTransportConfig as o_, mergeContributions as oa, PluginSchemaKind as oc, PLAN_AGENT as od, ContextBreakdown as of, SessionStore as og, StepThinkingDecay as oh, buildPostCompactAttachments as oi, ChipColor as ol, ResolveOAuthApiKeyOptions as om, EvalWorkspaceOptions as on, clampExtensionConfigNumber as oo, OpenAICompatStreamError as op, formatHeadlessResult as or, LoadedPluginRecord as os, resolveMcpWarningsDir as ot, CreateInteractionToolsOptions as ou, ModelUsage as p, ModelCatalogEntry as p_, ExtensionInstallProvenance as pa, writeSkillsToDisk as pc, EditOutcomeKind as pd, ContextExtensionRow as pf, resumeChainRunIds as pg, ToolResultAudioContent as ph, CompactStartEvent as pi, ThemeSelect as pl, resolveOAuthApiKey as pm, MetricStats as pn, toWireConfigSchema as po, consumeSSE as pp, transcriptToOpenAIMessages as pr, ExtensionNotification as ps, TOOL_USE_SKIPPED_MESSAGE as pt, PlanDecision as pu, OAuthCallbackResult as q, ExtensionConfigEnumItem as qa, installAllowedToolsGate as qc, modelOptionsFor as qd, SchemaSanitizeProfile as qf, toWireMessages as qg, stagedToolState as qh, AgentOptions as qi, CommandSpawnResult as ql, RepeatGuardConfig as qm, FormattedHeadlessResult as qn, ExtensionToolCatalogTransform as qo, buildAnthropicClientOptions as qp, RunSummaryCollector as qr, ManifestValidation as qs, EvalMetricError as qt, RingBufferSink as qu, definePreset as r, nonOwningMcpView as r_, disposeExtensionRegistry as ra, PluginComponentStatus as rc, DEFAULT_AGENT_ID as rd, OUTPUT_RESERVE_TOKENS as rf, SessionData as rg, SessionTurn as rh, PostCompactAttachments as ri, StorageSlot as rl, derivePromptCacheKey as rm, EvalTestRunner as rn, StoredExtensionConfigItem as ro, OpenAICompatAuthHeader as rp, OpenAIChatMessage as rr, ExtensionTuiSurface as rs, migrateSessionArtifactDirs as rt, ASK_USER_TOOL as ru, Span as s, resultToString as s_, partitionExtensionCatalog as sa, SUPPORTED_AGENT_PLUGINS_VERSIONS as sc, accentColor as sd, ContextBreakdownContributionContext as sf, createSession as sg, StreamHookContext as sh, selectFilesFromReadState as si, ChipColorMap as sl, credentialsFilePath as sm, EvalWorkspaceSnapshot as sn, coerceExtensionConfigInput as so, TOOL_RESULTS_TAG as sp, formatHeadlessTurnEvent as sr, TuiContributions as ss, resolvePersistDir as st, InteractionRequest as su, Preset as t, expandEnvPlaceholders as t_, buildExtensionRegistry as ta, LoadedPlugin as tc, BUILD_AGENT as td, AutoCompactDecision as tf, LoadSessionOptions as tg, SessionHookContext as th, estimateTokens as ti, StorageDirs as tl, PromptCacheKeyContext as tm, EvalScorer as tn, ExtensionConfigValue as to, OAIMessage as tp, HeadlessUsage as tr, ExtensionToolResultTransform as ts, cleanupPersistedSession as tt, executeCommand as tu, TracingHookSet as u, isAllowedRemoteUrl as u_, ExtensionInstallError as ua, parseSchemaId as uc, EditDiffDisplay as ud, ContextCategory as uf, demoteStaleRunningStatus as ug, ToolBatchExecutor as uh, CompactEndEvent as ui, SyntaxTokenStyle as ul, isOAuthAccessToken as um, MetricEmitter as un, resolveExtensionConfig as uo, assistantMessage as up, installHeadlessEventAdapter as ur, ExtensionHudState as us, INTERRUPT_MESSAGE_FOR_TOOL_USE as ut, InteractionsProvider as uu, MutationValidationBatch as v, InstalledExtensionTargetOptions as va, parseAllowedToolPattern as vc, SessionMeta as vd, ContextUsageSplit as vf, createMemoryStore as vg, ToolResultImageRefContent as vh, CompactDirection as vi, InlineAutocompleteProvider as vl, AgentRunOptions as vm, TrajectoryStepKind as vn, ExtensionCapability as vo, toOAIMessages as vp, ValidationResult as vr, ExtensionHostRuntimeBridge as vs, EditSessionTarget as vt, Question as vu, createMutationValidationHooks as w, removeInstalledExtension as wa, InterpolateShellCommandsOptions as wc, chainPositionOf as wd, CacheDimensionSnapshot as wf, PairingDrop as wg, toolOutputBudgetByteLength as wh, buildFromCompactPrompt as wi, CompletionState as wl, CompactEndHookContext as wm, computeEvalTagScores as wn, ExtensionDefinition as wo, openai as wp, createToolSearchTool as wr, ExtensionWorkspacePair as ws, buildZidaneExtensionSkill as wt, SelectQuestion as wu, MutationValidationMutation as x, listExtensionCandidates as xa, validateSkillForWrite as xc, ToolCallDisplay as xd, CacheBreakLoggerOptions as xf, createFileMapStore as xg, ToolResultVideoContent as xh, NO_TOOLS_PREAMBLE as xi, patchInlineGhost as xl, AutoCompactConfig as xm, buildRegisteredEvals as xn, ExtensionContributions as xo, OpenAIParams as xp, tailTruncate as xr, ExtensionRuntimeSurface as xs, SkillEditMarker as xt, QuestionRequest as xu, MutationValidationFailure as y, fetchExtensionSource as ya, validateResourcePath as yc, Settings as yd, buildContextBreakdown as yf, FileMapAdapter as yg, ToolResultMetadata as yh, CompactPromptBuilder as yi, InlineGhost as yl, AgentStats as ym, artifactPath as yn, ExtensionContext as yo, toolResultsMessage as yp, validateToolArgs as yr, ExtensionHostRuntimeImpl as ys, ExtensionEditMarker as yt, QuestionChoice as yu, McpCredentialEntry as z, createExtensionPromptBridge as za, SourcedScanPath as zc, ProviderDescriptor as zd, ToolSpec as zf, filterUnresolvedToolUses as zg, DEFAULT_MAX_VALUE_BYTES as zh, defaultRepeatGuardNormalize as zi, CommandAgentResult as zl, ProgressNudgeKind as zm, formatTrajectoryLine as zn, ExtensionRegistry as zo, arcee as zp, createInteractionTool as zr, isSpawnTool as zs, EvalAgentRunStats as zt, zodToJsonSchema as zu };
+//# sourceMappingURL=index-CWBSrqI6.d.ts.map