@wrongstack/core 0.1.1 → 0.1.3

package/dist/{tool-executor-DjnMELMV.d.ts → session-reader-DR4u3bu9.d.ts}

@@ -1,4 +1,5 @@
-import { f as ContentBlock, ag as Context, a2 as Tool, a9 as WireFamily, z as ProviderConfig, y as Provider, ah as Container, ai as EventBus, au as Pipeline, D as Request, K as Response, a5 as ToolUseBlock, a4 as ToolResultBlock, a0 as TextBlock, aw as RunOptions, az as ReadonlyPipeline, d as Config, j as Logger, aj as EventName, ak as Listener, v as PermissionPolicy, S as SecretScrubber, R as Renderer } from './secret-scrubber-Dax_Ou_o.js';
+import { c as ContentBlock, a0 as Context, v as Tool, B as ToolResultBlock, F as ToolUseBlock, h as Provider, R as Request, k as Response, T as TextBlock, a5 as RunOptions, W as WrongStackError, J as JSONSchema, U as Usage, n as SessionEvent, o as SessionMetadata, p as SessionStore } from './provider-DovtyuM8.js';
+import { p as PermissionPolicy, S as SecretScrubber, R as Renderer, B as EventBus, W as WireFamily, t as ProviderConfig, A as Container, X as Pipeline, _ as ReadonlyPipeline, b as Config, g as Logger, D as EventName, G as Listener } from './secret-scrubber-qU3AwEiI.js';
 
 type AttachmentKind = 'text' | 'image' | 'file';
 interface AttachmentMeta {
@@ -85,6 +86,13 @@ interface SlashCommand {
     /** Short aliases — also prefixed automatically: `pluginName:alias`. */
     aliases?: string[];
     description: string;
+    /**
+     * Optional detailed help shown by `/help <name>`. Use this for usage,
+     * arguments, examples, side-effects — anything that doesn't fit in
+     * `description`. Renders verbatim, so format with line breaks.
+     * If absent, `/help <name>` falls back to `description`.
+     */
+    help?: string;
     /**
      * Execute the command.
      * @param args Everything after the command name (trimmed by dispatch).
@@ -100,6 +108,12 @@ interface SlashCommand {
 declare class ToolRegistry {
     private readonly tools;
     register(tool: Tool, owner?: string): void;
+    /**
+     * Attempt to register a tool. Returns true if successful, false if a tool
+     * with the same name is already registered. Useful in multi-agent or plugin
+     * scenarios where duplicate registration may be intentional.
+     */
+    tryRegister(tool: Tool, owner?: string): boolean;
     /**
      * Register a tool as a default. If the tool name is already registered,
      * this is a no-op — the existing registration (from core or another
@@ -122,6 +136,145 @@ declare class ToolRegistry {
     clear(): void;
 }
 
+/**
+ * Observability primitives — metrics, tracing, health. Implementations live in
+ * `defaults/observability/`. Consumers depend on these interfaces so a noop
+ * sink can be swapped for an OTel/Prometheus adapter without touching call
+ * sites.
+ */
+type MetricLabels = Record<string, string>;
+interface MetricsSink {
+    /** Monotonically-increasing counter (e.g. total tool calls). */
+    counter(name: string, value?: number, labels?: MetricLabels): void;
+    /** Latency / size distribution (e.g. tool duration). */
+    histogram(name: string, value: number, labels?: MetricLabels): void;
+    /** Current value (e.g. active subagents, pending tasks). */
+    gauge(name: string, value: number, labels?: MetricLabels): void;
+    /** Point-in-time export — for /metrics scrape, debug dumps, tests. */
+    snapshot(): MetricsSnapshot;
+    /** Reset all metrics. Useful for tests; production code should rarely use. */
+    reset(): void;
+}
+interface MetricSeries {
+    name: string;
+    type: 'counter' | 'histogram' | 'gauge';
+    labels: MetricLabels;
+    /** Counter/gauge: latest value. Histogram: count, sum, min, max, p50, p95, p99. */
+    values: Record<string, number>;
+}
+interface MetricsSnapshot {
+    timestamp: number;
+    series: MetricSeries[];
+}
+type HealthStatus = 'healthy' | 'degraded' | 'unhealthy';
+interface HealthCheckResult {
+    status: HealthStatus;
+    detail?: string;
+    /** Optional structured data (e.g. latency, version) for dashboards. */
+    data?: Record<string, unknown>;
+}
+interface HealthCheck {
+    readonly name: string;
+    check(): Promise<HealthCheckResult>;
+}
+interface AggregateHealth {
+    status: HealthStatus;
+    timestamp: number;
+    checks: (HealthCheckResult & {
+        name: string;
+    })[];
+}
+interface HealthRegistry {
+    register(check: HealthCheck): void;
+    unregister(name: string): void;
+    run(): Promise<AggregateHealth>;
+}
+/**
+ * Minimal OTel-compatible Span. The default implementation is a noop; wire an
+ * OpenTelemetry adapter in production to get distributed tracing for free.
+ */
+interface Span {
+    setAttribute(key: string, value: string | number | boolean): void;
+    recordError(err: Error): void;
+    end(): void;
+}
+interface Tracer {
+    startSpan(name: string, attrs?: Record<string, string | number | boolean>): Span;
+}
+
+/**
+ * Input for a single tool execution, scoped to a single iteration's budget.
+ */
+interface ToolExecution {
+    toolUse: ToolUseBlock;
+    result: ToolResultBlock;
+    /** True if the tool was not found in the registry. */
+    unknownTool?: boolean;
+    /** True if the tool execution threw an exception. */
+    threw?: boolean;
+}
+/**
+ * Output from a single tool execution.
+ */
+interface ToolExecutionOutput {
+    result: ToolResultBlock | ToolConfirmPendingResult;
+    tool?: Tool;
+    durationMs: number;
+}
+/**
+ * Result of running a batch of tools for a single agent iteration.
+ */
+interface ToolBatchResult {
+    outputs: ToolExecutionOutput[];
+    remainingBudget: number;
+}
+type ConfirmAwaiter = (tool: Tool, input: unknown, toolUseId: string, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>;
+interface ToolExecutorOptions {
+    permissionPolicy: PermissionPolicy;
+    secretScrubber: SecretScrubber;
+    renderer?: Renderer | undefined;
+    /**
+     * Optional event bus. When provided, the executor emits `tool.started`
+     * before invoking each tool's `execute()`. Closes the observability gap
+     * between "model decided to call tool" and "tool finished".
+     */
+    events?: EventBus | undefined;
+    /**
+     * Optional tracer. When provided, every tool execution opens a
+     * `tool.<name>` span with attributes for tool name, permission decision,
+     * input size, output size, and outcome. Spans are no-op by default.
+     */
+    tracer?: Tracer | undefined;
+    /**
+     * Async callback invoked when a tool needs user confirmation.
+     * When omitted and confirmation is required, the executor returns a
+     * failure result immediately (TUI path). When provided (CLI path),
+     * the callback handles the interactive prompt and returns a decision.
+     */
+    confirmAwaiter?: ConfirmAwaiter | undefined;
+    iterationTimeoutMs?: number;
+    perIterationOutputCapBytes?: number;
+}
+interface ToolExecutorInit {
+    registry: ToolRegistry;
+    options: ToolExecutorOptions;
+}
+/**
+ * Result returned by executeBatch when a tool needs confirmation and
+ * no confirmAwaiter is available. The TUI catches this and surfaces a
+ * confirmation dialog; once resolved the tool is re-executed.
+ * The string tag identifies it as a "pending confirm" result so callers
+ * can distinguish it from an error without inspecting content strings.
+ */
+interface ToolConfirmPendingResult {
+    type: 'tool_confirm_pending';
+    toolUseId: string;
+    toolName: string;
+    input: unknown;
+    suggestedPattern: string;
+}
+type ToolExecutorStrategy = 'parallel' | 'sequential' | 'smart';
+
 /**
  * Factory for constructing a Provider instance. The `family` field
  * declares the wire protocol so callers can route without inspecting
@@ -144,7 +297,18 @@ interface ProviderFactory$1 {
 }
 declare class ProviderRegistry {
     private readonly factories;
+    /**
+     * Register a provider factory. If a factory with the same type already
+     * exists, it is replaced. Use this for both initial registration and
+     * runtime overrides (e.g. from plugins or CLI flags).
+     */
     register(f: ProviderFactory$1): void;
+    /**
+     * Override an existing factory. Throws if no factory is registered
+     * for the given type. Use this to safely replace a provider at runtime
+     * (e.g. in tests or when a plugin provides a custom implementation).
+     */
+    override(type: string, f: ProviderFactory$1): void;
     has(type: string): boolean;
     create(cfg: ProviderConfig): Provider;
     list(): string[];
@@ -154,7 +318,14 @@ declare class ProviderRegistry {
 declare const DEFAULT_MAX_ITERATIONS = 100;
 interface RunResult {
     status: 'done' | 'failed' | 'max_iterations' | 'aborted';
-    error?: unknown;
+    /**
+     * Set when `status === 'failed'` (always) or `'aborted'` (when the abort
+     * carried an error context). Always a `WrongStackError` so callers can
+     * branch on `code`, `severity`, and `recoverable` without parsing strings.
+     * Raw throws are wrapped into an `AgentError` with code `AGENT_RUN_FAILED`
+     * by `Agent.run` before they reach this field.
+     */
+    error?: WrongStackError;
     finalText?: string;
     iterations: number;
 }
@@ -175,6 +346,20 @@ interface AgentInit {
      * emit `iteration.limit_reached` and wait for a listener to grant/deny.
      */
     autoExtendLimit?: boolean;
+    /**
+     * Optional confirm handler. When set, the executor calls it synchronously
+     * when a tool needs user confirmation (CLI path). When omitted, the
+     * executor returns a `ToolConfirmPendingResult` and the agent emits
+     * `tool.confirm_needed` for the TUI to resolve.
+     */
+    confirmAwaiter?: ConfirmAwaiter | undefined;
+    /**
+     * Optional tracer. When provided, `Agent.run` opens an `agent.run` span,
+     * per-iteration `agent.iteration` spans, and `provider.complete` spans
+     * inside the retry loop. Tool spans are opened by the ToolExecutor.
+     * Default is `NoopTracer` (zero overhead).
+     */
+    tracer?: Tracer | undefined;
 }
 interface AgentPipelines {
     request: Pipeline<Request>;
@@ -213,6 +398,7 @@ declare class Agent {
     private readonly plugins;
     private readonly toolExecutor;
     private readonly autoExtendLimit;
+    private readonly tracer;
     constructor(init: AgentInit);
     private get logger();
     private get retry();
@@ -226,20 +412,39 @@ declare class Agent {
     run(userInput: AgentInput, opts?: RunOptions): Promise<RunResult>;
     private runInner;
     /**
-     * Emit an event asking listeners (CLI/TUI) whether to extend the iteration
-     * limit. Returns the number of additional iterations granted. If no listener
-     * responds or the user declines, returns 0.
+     * Normalize user input and emit through userInput pipeline + session append.
+     */
+    private normalizeAndEmitUserInput;
+    /**
+     * Check if iteration limit has been reached and request extension if needed.
+     * Returns the new effective limit (possibly extended) and a RunResult if
+     * the loop should exit. Returns `{ limit }` with no result when the
+     * iteration may proceed.
+     */
+    private checkIterationLimit;
+    /**
+     * Build request and run through request pipeline.
+     */
+    private buildAndRunRequestPipeline;
+    /**
+     * Process the provider response: run response pipeline, emit events,
+     * update session, render text, handle abort.
      */
-    private requestLimitExtension;
+    private processResponse;
     /**
-     * Consume a Provider.stream() into a Response, emitting text_delta and
-     * tool_use lifecycle events to the EventBus as they arrive. This is the
-     * canonical path when the provider declares `capabilities.streaming`;
-     * complete() is only used as a fallback for legacy providers.
+     * Execute tools and append tool results to context.
+     * When a tool returns `tool_confirm_pending` (no confirmAwaiter set),
+     * we pause and emit `tool.confirm_needed`. The run is blocked until
+     * the event listener resolves the confirmation, then we re-run the
+     * single tool.
      */
-    private streamProviderToResponse;
-    private callProviderWithRetry;
     private executeTools;
+    private waitForConfirm;
+    private executeSingleWithDecision;
+    /**
+     * Run context window pipeline if compactor is present.
+     */
+    private compactContextIfNeeded;
 }
 
 interface ToolRegistryView {
@@ -306,14 +511,68 @@ interface PluginAPI {
      */
     onEvent<K extends EventName>(event: K, handler: Listener<K>): () => void;
 }
+/**
+ * Capability declaration — informs the host which subsystems a plugin
+ * intends to touch. Used for diagnostics and per-plugin enable/disable UX
+ * (e.g. "this plugin registers tools — disable to remove them"). Not
+ * enforced at runtime: a plugin that declares `tools: false` can still
+ * call `api.tools.register()`, but the host can flag the discrepancy.
+ */
+interface PluginCapabilities {
+    /** Will register tools via `api.tools.register()`. */
+    tools?: boolean;
+    /** Will register provider factories via `api.providers.register()`. */
+    providers?: boolean;
+    /**
+     * Pipelines the plugin hooks into. Use the standard names
+     * (`request | response | toolCall | userInput | assistantOutput | contextWindow`)
+     * or custom pipeline names exposed by other plugins.
+     */
+    pipelines?: string[];
+    /** Will register slash commands via `api.slashCommands.register()`. */
+    slashCommands?: boolean;
+    /** Will start MCP servers via `api.mcp.start()`. */
+    mcp?: boolean;
+}
+/**
+ * Structured dependency declaration. The string form (`dependsOn: ['foo']`)
+ * is shorthand for `[{ name: 'foo' }]` — both work. Use the structured form
+ * when you need a version constraint:
+ *
+ *   dependsOn: [{ name: 'wstack-auth', version: '^1.2.0' }]
+ */
+interface PluginDependency {
+    name: string;
+    /** npm-style semver range. Supports `^`, `~`, exact, and unprefixed. */
+    version?: string;
+}
 interface Plugin {
     name: string;
     version?: string;
+    /** One-line summary for `wstack plugins list` and error messages. */
+    description?: string;
+    /** Semver range against the kernel API version (KERNEL_API_VERSION). */
     apiVersion: string;
-    /** Mandatory plugin dependencies — loading fails if any are absent. */
-    dependsOn?: string[];
+    /**
+     * Capability hints — what subsystems the plugin will register against.
+     * Optional; provided for diagnostics and UX. The loader does not enforce
+     * these, but mismatch is surfaced via logger at warn level.
+     */
+    capabilities?: PluginCapabilities;
+    /**
+     * JSON Schema for the options under `Config.plugins[<name>].options`.
+     * When present, the loader validates that section before calling `setup`
+     * and rejects the plugin with a clear error path on failure.
+     */
+    configSchema?: JSONSchema;
+    /**
+     * Mandatory plugin dependencies — loading fails if any are absent or
+     * version-incompatible. Accepts both the legacy string-array form and
+     * the structured form with version constraints.
+     */
+    dependsOn?: (string | PluginDependency)[];
     /** Optional plugin dependencies — silently skipped if absent. */
-    optionalDeps?: string[];
+    optionalDeps?: (string | PluginDependency)[];
     conflictsWith?: string[];
     setup(api: PluginAPI): void | Promise<void>;
     teardown?(api: PluginAPI): void | Promise<void>;
@@ -376,13 +635,75 @@ interface BridgeTransport {
     close(agentId: string): Promise<void>;
 }
 
+type BudgetKind = 'tool_calls' | 'iterations' | 'tokens' | 'timeout' | 'cost';
+declare class BudgetExceededError extends Error {
+    readonly kind: BudgetKind;
+    readonly limit: number;
+    readonly observed: number;
+    constructor(kind: BudgetKind, limit: number, observed: number);
+}
+interface BudgetLimits {
+    maxIterations?: number;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    /** Estimated USD cost ceiling. */
+    maxCostUsd?: number;
+    /** Wall-clock timeout from start() to checkTimeout(). */
+    timeoutMs?: number;
+}
+interface BudgetUsage {
+    iterations: number;
+    toolCalls: number;
+    tokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    costUsd: number;
+    elapsedMs: number;
+}
+/**
+ * Per-subagent budget enforcement. Each subagent gets its own instance so a
+ * runaway agent can't drain the cost ceiling of its siblings. All record/check
+ * methods are O(1) and safe to call from hot paths.
+ *
+ * Behavior: `record*` methods throw `BudgetExceededError` synchronously the
+ * moment a limit is crossed. The caller (runner/coordinator) catches this and
+ * marks the task as 'failed' with the budget kind, so the operator can see
+ * exactly which ceiling tripped.
+ */
+declare class SubagentBudget {
+    readonly limits: Readonly<BudgetLimits>;
+    private iterations;
+    private toolCalls;
+    private tokenInput;
+    private tokenOutput;
+    private costUsd;
+    private startTime;
+    constructor(limits?: BudgetLimits);
+    start(): void;
+    recordIteration(): void;
+    recordToolCall(): void;
+    recordUsage(usage: Usage, costUsd?: number): void;
+    /**
+     * Throws if the wall-clock budget is exhausted. Call this from the iteration
+     * loop so a hung tool can't keep a subagent running past its deadline.
+     */
+    checkTimeout(): void;
+    /** Returns true if a timeout has occurred without throwing. Useful for races. */
+    isTimedOut(): boolean;
+    usage(): BudgetUsage;
+}
+
 interface SubagentConfig {
-    id: string;
+    id?: string;
     name: string;
-    role: string;
+    role?: string;
     prompt?: string;
     maxIterations?: number;
     maxToolCalls?: number;
+    maxTokens?: number;
+    maxCostUsd?: number;
     timeoutMs?: number;
     tools?: string[];
     model?: string;
@@ -421,6 +742,18 @@ interface MultiAgentConfig {
     maxConcurrent?: number;
     doneCondition: DoneCondition;
     timeoutMs?: number;
+    /**
+     * Optional default budget applied to every spawned subagent. Per-subagent
+     * fields in `SubagentConfig` override these. Coordinator enforces them by
+     * constructing a `SubagentBudget` per spawn — see `SubagentRunContext.budget`.
+     */
+    defaultBudget?: {
+        maxIterations?: number;
+        maxToolCalls?: number;
+        maxTokens?: number;
+        maxCostUsd?: number;
+        timeoutMs?: number;
+    };
 }
 interface SpawnResult {
     subagentId: string;
@@ -461,6 +794,28 @@ interface MultiAgentCoordinator {
     stopAll(): Promise<void>;
     getStatus(): CoordinatorStatus;
 }
+/**
+ * Caller-supplied runner that actually executes a task. The coordinator
+ * provides isolated state (own budget, own AbortSignal, own bridge handle)
+ * and enforces concurrency limits — the runner just runs the task and reports
+ * the outcome. This is the injection seam that decouples the coordinator
+ * from `Agent` so it can be tested with mocks and reused for non-Agent
+ * subagents (workers, MCP-driven subagents, etc.).
+ */
+type SubagentRunner = (task: TaskSpec, ctx: SubagentRunContext) => Promise<SubagentRunOutcome>;
+interface SubagentRunContext {
+    subagentId: string;
+    config: SubagentConfig;
+    budget: SubagentBudget;
+    signal: AbortSignal;
+    /** Null until `setSubagentBridge` is called for this subagent. */
+    bridge: AgentBridge | null;
+}
+interface SubagentRunOutcome {
+    result?: unknown;
+    iterations: number;
+    toolCalls: number;
+}
 interface CoordinatorStatus {
     coordinatorId: string;
     subagents: {
@@ -642,48 +997,79 @@ declare function findCriticalPath(graph: TaskGraph): CriticalPathResult;
 declare function topologicalSort(graph: TaskGraph): string[];
 
 /**
- * Input for a single tool execution, scoped to a single iteration's budget.
- */
-interface ToolExecution {
-    toolUse: ToolUseBlock;
-    result: ToolResultBlock;
-    /** True if the tool was not found in the registry. */
-    unknownTool?: boolean;
-    /** True if the tool execution threw an exception. */
-    threw?: boolean;
-}
-/**
- * Output from a single tool execution.
- */
-interface ToolExecutionOutput {
-    result: ToolResultBlock;
-    tool?: Tool;
-    durationMs: number;
-}
-/**
- * Result of running a batch of tools for a single agent iteration.
+ * L2-A: SessionReader — query, replay, search, export over a `SessionStore`.
+ *
+ * Keeps a clean read-only interface (no `append`, no `delete`) so analytics
+ * code can be wired against a store without granting it the writer surface.
  */
-interface ToolBatchResult {
-    outputs: ToolExecutionOutput[];
-    remainingBudget: number;
-}
-interface ToolExecutorOptions {
-    permissionPolicy: PermissionPolicy;
-    secretScrubber: SecretScrubber;
-    renderer?: Renderer | undefined;
-    /**
-     * Optional event bus. When provided, the executor emits `tool.started`
-     * before invoking each tool's `execute()`. Closes the observability gap
-     * between "model decided to call tool" and "tool finished".
-     */
-    events?: EventBus | undefined;
-    iterationTimeoutMs?: number;
-    perIterationOutputCapBytes?: number;
-}
-interface ToolExecutorInit {
-    registry: ToolRegistry;
-    options: ToolExecutorOptions;
+type SessionEventType = SessionEvent['type'];
+interface SessionQuery {
+    /** Filter by start timestamp (ISO). Sessions started before this are excluded. */
+    since?: string;
+    /** Filter by start timestamp (ISO). Sessions started after this are excluded. */
+    until?: string;
+    /** Substring match against title (case-insensitive). */
+    titleContains?: string;
+    /** Filter by provider id. */
+    provider?: string;
+    /** Filter by model id. */
+    model?: string;
+    /** Minimum total tokens (input+output) to keep. */
+    minTokens?: number;
+    /** Limit result count. Defaults to no limit. */
+    limit?: number;
+}
+interface SessionSearchHit {
+    sessionId: string;
+    eventIndex: number;
+    ts: string;
+    type: SessionEventType;
+    /** Short snippet of the matched text — null for events without text content. */
+    snippet: string | null;
+}
+interface SessionSearchQuery {
+    /** Plain text or regex pattern. */
+    query: string;
+    /** Treat `query` as a regex. Defaults to false (literal substring). */
+    regex?: boolean;
+    /** Case-insensitive match. Defaults to true. */
+    caseInsensitive?: boolean;
+    /** Limit only to these event types. Defaults to all event types. */
+    types?: SessionEventType[];
+    /** Limit hit count. Defaults to 100. */
+    limit?: number;
+}
+interface SessionExportOptions {
+    /** "markdown" produces a human-readable chat log; "json" passes through raw events. */
+    format: 'markdown' | 'json' | 'text';
+    /** Include tool_use/tool_result blocks. Defaults to true. */
+    includeTools?: boolean;
+    /** Include system/diagnostic events (errors, compaction). Defaults to true. */
+    includeDiagnostics?: boolean;
+}
+interface SessionSummaryLite {
+    id: string;
+    title: string;
+    startedAt: string;
+    endedAt?: string;
+    provider: string;
+    model: string;
+    tokenTotal: number;
+}
+interface SessionReader {
+    /** List sessions matching the query. Uses the underlying store's summary cache. */
+    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
+    /** Yield events for `sessionId` in chronological order. */
+    replay(sessionId: string): AsyncIterable<SessionEvent>;
+    /** Full-text/regex search across one or all sessions. */
+    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
+    /** Render a session for human or downstream-tool consumption. */
+    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
+    /** Read the metadata header without loading the full event stream. */
+    metadata(sessionId: string): Promise<SessionMetadata>;
+}
+interface DefaultSessionReaderOptions {
+    store: SessionStore;
 }
-type ToolExecutorStrategy = 'parallel' | 'sequential' | 'smart';
 
-export { type TaskProgress as $, type AddAttachmentInput as A, type BridgeMessage as B, type CoordinatorEvents as C, DEFAULT_MODES as D, ENCRYPTED_PREFIX as E, type SpecAnalysis as F, type SpecApiEndpoint as G, type SpecRequirement as H, type SpecSection as I, type SpecSectionType as J, type SpecStatus as K, type SpecTemplate as L, type MCPRegistryView as M, type SpecValidationResult as N, type Specification as O, type Plugin as P, type SubagentConfig as Q, type SubagentContext as R, type SecretVault as S, type TaskAssignment as T, type TaskDelegation as U, type TaskDependency as V, type TaskEdge as W, type TaskFilter as X, type TaskGraph as Y, type TaskNode as Z, type TaskPriority as _, type AgentBridge as a, type TaskResult as a0, type TaskSort as a1, type TaskSpec as a2, type TaskStatus as a3, type TaskType as a4, type ToolBatchResult as a5, type ToolExecution as a6, type ToolExecutionOutput as a7, type ToolExecutorInit as a8, type ToolExecutorOptions as a9, type ToolExecutorStrategy as aa, type ToolRegistryView as ab, computeTaskProgress as ac, findCriticalPath as ad, topologicalSort as ae, ToolRegistry as af, ProviderRegistry as ag, Agent as ah, type AgentInit as ai, type AgentInput as aj, type AgentPipelines as ak, DEFAULT_MAX_ITERATIONS as al, type ProviderFactory$1 as am, type RunResult as an, type UserInputPayload as ao, createDefaultPipelines as ap, type AgentBridgeConfig as b, type Attachment as c, type AttachmentKind as d, type AttachmentMeta as e, type AttachmentRef as f, type AttachmentStore as g, type BridgeMessageType as h, type BridgeTransport as i, type CoordinatorStatus as j, type CriticalPathResult as k, DEFAULT_SPEC_TEMPLATE as l, type DoneCondition as m, type Mode as n, type ModeConfig as o, type ModeManifest as p, type ModeStore as q, type MultiAgentConfig as r, type MultiAgentCoordinator as s, type PluginAPI as t, type PluginPipelines as u, type ProviderFactory as v, type ProviderRegistryView as w, type SlashCommand as x, type SlashCommandRegistryView as y, type SpawnResult as z };
+export { type Span as $, type AddAttachmentInput as A, type BridgeMessage as B, type ConfirmAwaiter as C, DEFAULT_MODES as D, ENCRYPTED_PREFIX as E, type ModeStore as F, type MultiAgentConfig as G, type HealthCheck as H, type MultiAgentCoordinator as I, type PluginAPI as J, type PluginCapabilities as K, type PluginDependency as L, type MCPRegistryView as M, type PluginPipelines as N, type ProviderFactory as O, type Plugin as P, type ProviderRegistryView as Q, type SessionEventType as R, type SecretVault as S, type SessionExportOptions as T, type SessionQuery as U, type SessionReader as V, type SessionSearchHit as W, type SessionSearchQuery as X, type SessionSummaryLite as Y, type SlashCommand as Z, type SlashCommandRegistryView as _, type AgentBridge as a, type SpawnResult as a0, type SpecAnalysis as a1, type SpecApiEndpoint as a2, type SpecRequirement as a3, type SpecSection as a4, type SpecSectionType as a5, type SpecStatus as a6, type SpecTemplate as a7, type SpecValidationResult as a8, type Specification as a9, type ToolRegistryView as aA, type Tracer as aB, computeTaskProgress as aC, findCriticalPath as aD, topologicalSort as aE, ToolRegistry as aF, ProviderRegistry as aG, Agent as aH, type AgentInit as aI, type AgentInput as aJ, type AgentPipelines as aK, BudgetExceededError as aL, type BudgetKind as aM, type BudgetLimits as aN, type BudgetUsage as aO, DEFAULT_MAX_ITERATIONS as aP, type ProviderFactory$1 as aQ, type RunResult as aR, SubagentBudget as aS, type UserInputPayload as aT, createDefaultPipelines as aU, type SubagentConfig as aa, type SubagentContext as ab, type SubagentRunContext as ac, type SubagentRunOutcome as ad, type SubagentRunner as ae, type TaskAssignment as af, type TaskDelegation as ag, type TaskDependency as ah, type TaskEdge as ai, type TaskFilter as aj, type TaskGraph as ak, type TaskNode as al, type TaskPriority as am, type TaskProgress as an, type TaskResult as ao, type TaskSort as ap, type TaskSpec as aq, type TaskStatus as ar, type TaskType as as, type ToolBatchResult as at, type ToolConfirmPendingResult as au, type ToolExecution as av, type ToolExecutionOutput as aw, type ToolExecutorInit as ax, type ToolExecutorOptions as ay, type ToolExecutorStrategy as az, type AgentBridgeConfig as b, type AggregateHealth as c, type Attachment as d, type AttachmentKind as e, type AttachmentMeta as f, type AttachmentRef as g, type AttachmentStore as h, type BridgeMessageType as i, type BridgeTransport as j, type CoordinatorEvents as k, type CoordinatorStatus as l, type CriticalPathResult as m, DEFAULT_SPEC_TEMPLATE as n, type DefaultSessionReaderOptions as o, type DoneCondition as p, type HealthCheckResult as q, type HealthRegistry as r, type HealthStatus as s, type MetricLabels as t, type MetricSeries as u, type MetricsSink as v, type MetricsSnapshot as w, type Mode as x, type ModeConfig as y, type ModeManifest as z };

package/dist/{system-prompt-BG3nks8P.d.ts → system-prompt--mzZnenv.d.ts}

@@ -1,4 +1,4 @@
-import { a2 as Tool, a0 as TextBlock } from './secret-scrubber-Dax_Ou_o.js';
+import { v as Tool, T as TextBlock } from './provider-DovtyuM8.js';
 
 interface BuildContext {
     cwd: string;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
-export { C as CacheStats, a as Capabilities, b as CompactReport, c as Compactor, d as Config, e as ConfigLoader, f as ContentBlock, g as ContextConfig, E as ErrorHandler, F as FeaturesConfig, I as ImageBlock, h as InputReader, J as JSONSchema, L as LogConfig, i as LogLevel, j as Logger, M as MCPServerConfig, k as MemoryEntry, l as MemoryScope, m as MemoryStore, n as Message, o as MessageRole, p as ModelsDevModel, q as ModelsDevPayload, r as ModelsDevProvider, s as ModelsRegistry, P as PathResolver, t as Permission, u as PermissionDecision, v as PermissionPolicy, w as PluginConfig, x as PromptOption, y as Provider, z as ProviderConfig, A as ProviderError, B as ProviderErrorBody, R as Renderer, D as Request, G as ResolvedModel, H as ResolvedProvider, K as Response, N as ResumedSession, O as RetryPolicy, S as SecretScrubber, Q as SessionData, T as SessionEvent, U as SessionMetadata, V as SessionStore, W as SessionSummary, X as SessionWriter, Y as SkillLoader, Z as SkillManifest, _ as StopReason, $ as StreamEvent, a0 as TextBlock, a1 as TokenCounter, a2 as Tool, a3 as ToolCallContext, a4 as ToolResultBlock, a5 as ToolUseBlock, a6 as ToolsConfig, a7 as TrustPolicy, a8 as Usage, a9 as WireFamily, aa as asBlocks, ab as asText, ac as isImageBlock, ad as isTextBlock, ae as isToolResultBlock, af as isToolUseBlock } from '../secret-scrubber-Dax_Ou_o.js';
-export { A as AddAttachmentInput, a as AgentBridge, b as AgentBridgeConfig, c as Attachment, d as AttachmentKind, e as AttachmentMeta, f as AttachmentRef, g as AttachmentStore, B as BridgeMessage, h as BridgeMessageType, i as BridgeTransport, C as CoordinatorEvents, j as CoordinatorStatus, k as CriticalPathResult, D as DEFAULT_MODES, l as DEFAULT_SPEC_TEMPLATE, m as DoneCondition, E as ENCRYPTED_PREFIX, M as MCPRegistryView, n as Mode, o as ModeConfig, p as ModeManifest, q as ModeStore, r as MultiAgentConfig, s as MultiAgentCoordinator, P as Plugin, t as PluginAPI, u as PluginPipelines, v as ProviderFactory, w as ProviderRegistryView, S as SecretVault, x as SlashCommand, y as SlashCommandRegistryView, z as SpawnResult, F as SpecAnalysis, G as SpecApiEndpoint, H as SpecRequirement, I as SpecSection, J as SpecSectionType, K as SpecStatus, L as SpecTemplate, N as SpecValidationResult, O as Specification, Q as SubagentConfig, R as SubagentContext, T as TaskAssignment, U as TaskDelegation, V as TaskDependency, W as TaskEdge, X as TaskFilter, Y as TaskGraph, Z as TaskNode, _ as TaskPriority, $ as TaskProgress, a0 as TaskResult, a1 as TaskSort, a2 as TaskSpec, a3 as TaskStatus, a4 as TaskType, a5 as ToolBatchResult, a6 as ToolExecution, a7 as ToolExecutionOutput, a8 as ToolExecutorInit, a9 as ToolExecutorOptions, aa as ToolExecutorStrategy, ab as ToolRegistryView, ac as computeTaskProgress, ad as findCriticalPath, ae as topologicalSort } from '../tool-executor-DjnMELMV.js';
-export { B as BuildContext, S as SystemPromptBuilder } from '../system-prompt-BG3nks8P.js';
+export { A as AgentError, C as CacheStats, a as Capabilities, b as ConfigError, c as ContentBlock, E as ErrorCode, d as ErrorSeverity, e as ErrorSubsystem, I as ImageBlock, J as JSONSchema, M as Message, f as MessageRole, P as Permission, g as PluginError, h as Provider, i as ProviderError, j as ProviderErrorBody, R as Request, k as Response, l as ResumedSession, S as SessionData, m as SessionError, n as SessionEvent, o as SessionMetadata, p as SessionStore, q as SessionSummary, r as SessionWriter, s as StopReason, t as StreamEvent, T as TextBlock, u as TokenCounter, v as Tool, w as ToolCallContext, x as ToolError, y as ToolFinalEvent, z as ToolProgressEvent, B as ToolResultBlock, D as ToolStreamEvent, F as ToolUseBlock, U as Usage, W as WrongStackError, G as asBlocks, H as asText, K as isAgentError, L as isConfigError, N as isImageBlock, O as isPluginError, Q as isSessionError, V as isTextBlock, X as isToolError, Y as isToolResultBlock, Z as isToolUseBlock, _ as isWrongStackError, $ as toWrongStackError } from '../provider-DovtyuM8.js';
+export { C as CompactReport, a as Compactor, b as Config, c as ConfigLoader, d as ConfigStore, e as ContextConfig, E as ErrorHandler, F as FeaturesConfig, I as InputReader, L as LogConfig, f as LogLevel, g as Logger, M as MCPServerConfig, h as MemoryEntry, i as MemoryScope, j as MemoryStore, k as ModelsDevModel, l as ModelsDevPayload, m as ModelsDevProvider, n as ModelsRegistry, P as PathResolver, o as PermissionDecision, p as PermissionPolicy, q as PluginConfig, r as PromptOption, s as ProviderApiKey, t as ProviderConfig, R as Renderer, u as ResolvedModel, v as ResolvedProvider, w as RetryPolicy, S as SecretScrubber, x as SkillLoader, y as SkillManifest, T as ToolsConfig, z as TrustPolicy, W as WireFamily } from '../secret-scrubber-qU3AwEiI.js';
+export { A as AddAttachmentInput, a as AgentBridge, b as AgentBridgeConfig, c as AggregateHealth, d as Attachment, e as AttachmentKind, f as AttachmentMeta, g as AttachmentRef, h as AttachmentStore, B as BridgeMessage, i as BridgeMessageType, j as BridgeTransport, C as ConfirmAwaiter, k as CoordinatorEvents, l as CoordinatorStatus, m as CriticalPathResult, D as DEFAULT_MODES, n as DEFAULT_SPEC_TEMPLATE, o as DefaultSessionReaderOptions, p as DoneCondition, E as ENCRYPTED_PREFIX, H as HealthCheck, q as HealthCheckResult, r as HealthRegistry, s as HealthStatus, M as MCPRegistryView, t as MetricLabels, u as MetricSeries, v as MetricsSink, w as MetricsSnapshot, x as Mode, y as ModeConfig, z as ModeManifest, F as ModeStore, G as MultiAgentConfig, I as MultiAgentCoordinator, P as Plugin, J as PluginAPI, K as PluginCapabilities, L as PluginDependency, N as PluginPipelines, O as ProviderFactory, Q as ProviderRegistryView, S as SecretVault, R as SessionEventType, T as SessionExportOptions, U as SessionQuery, V as SessionReader, W as SessionSearchHit, X as SessionSearchQuery, Y as SessionSummaryLite, Z as SlashCommand, _ as SlashCommandRegistryView, $ as Span, a0 as SpawnResult, a1 as SpecAnalysis, a2 as SpecApiEndpoint, a3 as SpecRequirement, a4 as SpecSection, a5 as SpecSectionType, a6 as SpecStatus, a7 as SpecTemplate, a8 as SpecValidationResult, a9 as Specification, aa as SubagentConfig, ab as SubagentContext, ac as SubagentRunContext, ad as SubagentRunOutcome, ae as SubagentRunner, af as TaskAssignment, ag as TaskDelegation, ah as TaskDependency, ai as TaskEdge, aj as TaskFilter, ak as TaskGraph, al as TaskNode, am as TaskPriority, an as TaskProgress, ao as TaskResult, ap as TaskSort, aq as TaskSpec, ar as TaskStatus, as as TaskType, at as ToolBatchResult, au as ToolConfirmPendingResult, av as ToolExecution, aw as ToolExecutionOutput, ax as ToolExecutorInit, ay as ToolExecutorOptions, az as ToolExecutorStrategy, aA as ToolRegistryView, aB as Tracer, aC as computeTaskProgress, aD as findCriticalPath, aE as topologicalSort } from '../session-reader-DR4u3bu9.js';
+export { B as BuildContext, S as SystemPromptBuilder } from '../system-prompt--mzZnenv.js';