@prometheus-ai/agent 0.5.4 → 0.5.8

package/dist/types/async/index.d.ts

@@ -1,2 +1 @@
 export * from "./job-manager";
-export * from "./support";

package/dist/types/async/job-manager.d.ts

@@ -15,6 +15,12 @@ export interface AsyncJob {
      * supply an id (e.g. legacy tests, SDK consumers without an agent context).
      */
     ownerId?: string;
+    /**
+     * Job is registered but parked behind a caller-managed gate (e.g. a task
+     * batch semaphore). Queued jobs do not count toward the running-job limit
+     * until the caller invokes `markRunning()` from the run context.
+     */
+    queued?: boolean;
 }
 export interface AsyncJobManagerOptions {
     onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
@@ -32,6 +38,8 @@ export interface AsyncJobRegisterOptions {
     /** Registry id of the agent that owns this job; used to scope cancelAll. */
     ownerId?: string;
     onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
+    /** Register the job in queued state; see {@link AsyncJob.queued}. */
+    queued?: boolean;
 }
 /**
  * Filter applied to job query/cancel APIs. With `ownerId`, results are
@@ -50,10 +58,14 @@ export declare class AsyncJobManager {
     /** Reset the process-global instance. Test-only. */
     static resetForTests(): void;
     constructor(options: AsyncJobManagerOptions);
+    /** True when the running-job count has reached the configured cap. */
+    get atCapacity(): boolean;
     register(type: "bash" | "task", label: string, run: (ctx: {
         jobId: string;
         signal: AbortSignal;
         reportProgress: (text: string, details?: Record<string, unknown>) => Promise<void>;
+        /** Clear the queued flag once the job actually starts executing. */
+        markRunning: () => void;
     }) => Promise<string>, options?: AsyncJobRegisterOptions): string;
     /**
      * Cancel a single job by id. When `filter.ownerId` is set and does not
@@ -69,7 +81,28 @@ export declare class AsyncJobManager {
     hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
     watchJobs(jobIds: string[]): number;
     unwatchJobs(jobIds: string[]): number;
+    /**
+     * Compute the next adaptive ("smart") wait (ms) for a blocking `job` poll by
+     * the given owner. Consecutive polls — those starting within
+     * POLL_ESCALATION_RESET_MS of the previous poll returning — climb
+     * POLL_WAIT_LADDER_MS so a tight wait loop backs off; a longer gap means the
+     * agent left to do real work, so the wait resets to the floor. Pair each call
+     * with `recordPollWaitEnd()` once the wait returns.
+     */
+    nextPollWaitMs(ownerId: string | undefined, now?: number): number;
+    /**
+     * Mark a blocking poll wait as finished so the idle-reset window is measured
+     * from now. Polling again before POLL_ESCALATION_RESET_MS elapses keeps
+     * climbing the ladder; waiting longer resets it to the floor.
+     */
+    recordPollWaitEnd(ownerId: string | undefined, now?: number): void;
     acknowledgeDeliveries(jobIds: string[]): number;
+    /**
+     * Lift a foreground-wait suppression set via `acknowledgeDeliveries`. If the
+     * job already finished while suppressed (its delivery enqueue was skipped),
+     * re-enqueue the completion so the result is still delivered exactly once.
+     */
+    resumeDeliveries(jobIds: string[]): void;
     /**
      * Cancel running jobs. With `filter.ownerId` set, cancels only jobs the
      * matching agent registered; with no filter, cancels every running job

package/dist/types/autolearn/controller.d.ts

@@ -0,0 +1,25 @@
+import type { Settings } from "../config/settings";
+import type { AgentSession } from "../session/agent-session";
+/**
+ * Build the standing auto-learn guidance for the system prompt from the tools
+ * actually present in the active set, or null when `manage_skill` is absent.
+ *
+ * Driven by tool presence rather than live settings: the `learn`/`manage_skill`
+ * registry is built ONCE at session start (and only for top-level sessions), so
+ * keying the guidance on `autolearn.enabled` would let a mid-session enable — or
+ * a subagent that filtered the tools out — inject guidance pointing at tools the
+ * session never built. The `learn` addendum is included only when the `learn`
+ * tool is present (it requires a memory backend).
+ */
+export declare function buildAutoLearnInstructions(available: {
+    manageSkill: boolean;
+    learn: boolean;
+}): string | null;
+export interface AutoLearnControllerOptions {
+    session: AgentSession;
+    settings: Settings;
+}
+export declare class AutoLearnController {
+    #private;
+    constructor(options: AutoLearnControllerOptions);
+}

package/dist/types/autolearn/managed-skills.d.ts

@@ -0,0 +1,45 @@
+/** Provider id stamped on discovered managed skills (distinguishes them from authored). */
+export declare const MANAGED_SKILLS_PROVIDER_ID = "prometheus-managed";
+/** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
+export declare const MAX_MANAGED_SKILL_BYTES = 64000;
+/** Resolve the isolated managed-skills directory (`~/.prometheus/agent/managed-skills`). */
+export declare function getManagedSkillsDir(home?: string): string;
+/**
+ * Validate + normalize a managed-skill name. Throws on anything outside the
+ * strict allowlist so a bad name can never escape `getManagedSkillsDir()`
+ * (blocks `..`, slashes, empty, and uppercase).
+ */
+export declare function sanitizeSkillName(raw: string): string;
+/**
+ * Whether `name` is a safe managed-skill name (the exact post-sanitize shape).
+ * Used to validate names read from disk at discovery time — a managed
+ * `SKILL.md` whose `frontmatter.name` was not produced by `sanitizeSkillName`
+ * (e.g. hand-placed) must not render unescaped into the system prompt.
+ */
+export declare function isValidManagedSkillName(name: string): boolean;
+/**
+ * Neutralize a machine-generated managed-skill description so it cannot break
+ * out of the system prompt's `<skills>` listing. Managed descriptions are
+ * generated from prior task content and persist across sessions, so this is a
+ * trust boundary: strip control/format chars, angle brackets (`<system-directive>`
+ * / `</skills>`), and Markdown fence delimiters (backticks, `~~~`), then collapse
+ * to a single line. Applied on BOTH write and read so existing files are safe too.
+ */
+export declare function sanitizeManagedDescription(raw: string): string;
+/**
+ * Serialize the minimal `name`/`description` frontmatter block via the repo's
+ * YAML helper (round-trips through `parseFrontmatter`).
+ */
+export declare function toSkillFrontmatter(name: string, description: string): string;
+export interface WriteManagedSkillInput {
+    action: "create" | "update";
+    name: string;
+    description: string;
+    body: string;
+}
+/** Create or update a managed `SKILL.md`. Returns the resolved file path. */
+export declare function writeManagedSkill(input: WriteManagedSkillInput): Promise<{
+    path: string;
+}>;
+/** Delete a managed skill directory. Throws when it does not exist. */
+export declare function deleteManagedSkill(name: string): Promise<void>;

package/dist/types/autoresearch/state.d.ts

@@ -1,4 +1,4 @@
-import type { SessionEntry } from "../session/session-manager";
+import type { SessionEntry } from "../session/session-entries";
 import type { RunRow, SessionRow } from "./storage";
 import type { AutoresearchRuntime, ExperimentResult, ExperimentState, MetricDef, MetricDirection, NumericMetricMap, ReconstructedControlState, RuntimeStore } from "./types";
 export declare function createExperimentState(): ExperimentState;

package/dist/types/autoresearch/tools/init-experiment.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions, ExperimentState } from "../types";
 export declare const HARNESS_FILENAME = "autoresearch.sh";

package/dist/types/autoresearch/tools/log-experiment.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions, LogDetails } from "../types";
 declare const logExperimentSchema: z.ZodObject<{

package/dist/types/autoresearch/tools/run-experiment.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressDetails } from "../types";
 declare const runExperimentSchema: z.ZodObject<{

package/dist/types/autoresearch/tools/update-notes.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions } from "../types";
 declare const updateNotesSchema: z.ZodObject<{

package/dist/types/autoresearch/types.d.ts

@@ -1,6 +1,6 @@
 import type { AgentToolResult } from "@prometheus-ai/agent-core";
 import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
-import type { SessionEntry } from "../session/session-manager";
+import type { SessionEntry } from "../session/session-entries";
 import type { TruncationResult } from "../session/streaming-output";
 export type MetricDirection = "lower" | "higher";
 export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";

package/dist/types/capability/context-file.d.ts

@@ -1,15 +1,4 @@
 import type { SourceMeta } from "./types";
-/**
- * A concrete file represented by a context file item.
- */
-export interface ContextFileMember {
-    /** File name used for extension IDs and display */
-    name: string;
-    /** Absolute path to the file */
-    path: string;
-    /** File content */
-    content: string;
-}
 /**
  * A context file that provides persistent instructions to the agent.
  */
@@ -22,8 +11,6 @@ export interface ContextFile {
     level: "user" | "project";
     /** Distance from cwd (0 = in cwd, 1 = parent, etc.) for project files */
     depth?: number;
-    /** Underlying files represented by a merged context payload */
-    members?: ContextFileMember[];
     /** Source metadata */
     _source: SourceMeta;
 }

package/dist/types/capability/mcp.d.ts

@@ -28,6 +28,7 @@ export interface MCPServer {
         tokenUrl?: string;
         clientId?: string;
         clientSecret?: string;
+        resource?: string;
     };
     /** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath) for servers requiring explicit client credentials */
     oauth?: {

package/dist/types/capability/rule-buckets.d.ts

@@ -6,7 +6,7 @@
  * manager, and splits the rest into the always-apply and rulebook buckets.
  *
  * Bucket precedence (matches docs/rulebook-matching-pipeline.md §5):
- *   1. TTSR     — non-empty `condition` that `TtsrManager.addRule` accepts
+ *   1. TTSR     — non-empty `condition`/`astCondition` that `TtsrManager.addRule` accepts
  *   2. always   — `alwaysApply === true`
  *   3. rulebook — has a `description`
  */

package/dist/types/capability/rule.d.ts

@@ -15,6 +15,8 @@ export interface RuleFrontmatter {
     alwaysApply?: boolean;
     /** New key for TTSR match conditions. */
     condition?: string | string[];
+    /** TTSR match condition(s) expressed as ast-grep patterns (edit/write streams only). */
+    astCondition?: string | string[];
     /** New key for TTSR stream scope. */
     scope?: string | string[];
     /** Per-rule TTSR interrupt mode override. */
@@ -39,6 +41,8 @@ export interface Rule {
     description?: string;
     /** Regex condition(s) that can trigger TTSR interruption. */
     condition?: string[];
+    /** ast-grep pattern condition(s) that can trigger TTSR interruption (edit/write streams only). */
+    astCondition?: string[];
     /** Optional stream scope tokens (for example: text, thinking, tool:edit(*.ts)). */
     scope?: string[];
     /** Per-rule TTSR interrupt mode override (falls back to global ttsr.interruptMode). */
@@ -54,8 +58,9 @@ export interface Rule {
  * - legacy `ttsr_trigger` / `ttsrTrigger` are accepted as a `condition` fallback
  * - condition tokens that look like file globs become scope shorthands:
  *   `*.rs` => `tool:edit(*.rs)`, `tool:write(*.rs)` and a catch-all condition `.*`
+ * - `astCondition` holds ast-grep patterns and is kept verbatim (no glob inference)
  */
-export declare function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<Rule, "condition" | "scope">;
+export declare function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<Rule, "condition" | "astCondition" | "scope">;
 /**
  * Process-global snapshot of rules the active session loaded.
  * Read by internal URL protocol handlers (rule://).

package/dist/types/capability/types.d.ts

@@ -15,10 +15,6 @@ export interface LoadContext {
     home: string;
     /** Git repository root (directory containing .git), or null if not in a repo */
     repoRoot: string | null;
-    /** Disabled extension IDs for providers that need to filter before composing items */
-    disabledExtensions?: readonly string[];
-    /** Include disabled items in provider loads. Default: false */
-    includeDisabled?: boolean;
 }
 /**
  * Result from a provider's load function.

package/dist/types/cli/args.d.ts

@@ -1,13 +1,14 @@
 /**
  * CLI argument parsing and help display
  */
-import { type Effort } from "@prometheus-ai/ai";
+import { type Effort } from "@prometheus-ai/catalog/effort";
 export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui";
 export interface Args {
     cwd?: string;
     allowHome?: boolean;
     provider?: string;
     model?: string;
+    config?: string[];
     smol?: string;
     slow?: string;
     plan?: string;
@@ -25,6 +26,8 @@ export interface Args {
     sessionDir?: string;
     providerSessionId?: string;
     fork?: string;
+    /** Collab link to join at startup (set by the `join` subcommand; no CLI flag). */
+    join?: string;
     models?: string[];
     tools?: string[];
     noTools?: boolean;
@@ -39,17 +42,34 @@ export interface Args {
     noSkills?: boolean;
     skills?: string[];
     noRules?: boolean;
-    listModels?: string | true;
     noTitle?: boolean;
     autoApprove?: boolean;
     approvalMode?: "always-ask" | "write" | "yolo";
     messages: string[];
     fileArgs: string[];
-    /** Unknown flags (potentially extension flags) - map of flag name to value */
+    /** Extension-registered flags this parse recognized — name to value. */
     unknownFlags: Map<string, boolean | string>;
+    /**
+     * `--`/`-` prefixed tokens this parse could not match against any built-in
+     * or {@link extensionFlags} entry. The startup parse runs *before*
+     * extensions load, so it always lists every extension-registered flag here;
+     * the post-extension reparse in {@link applyExtensionFlags} clears those
+     * once the real flag set is known. Anything still present after that
+     * reparse is a genuine typo or stale flag and {@link reportUnrecognizedFlags}
+     * surfaces it as a hard error so the agent does not silently start a
+     * session with the misparsed positionals as a prompt (issue #2459).
+     */
+    unrecognizedFlags: string[];
 }
 export declare function parseArgs(inputArgs: string[], extensionFlags?: Map<string, {
     type: "boolean" | "string";
 }>): Args;
+/**
+ * Emit a stderr error listing the unrecognized flags and return `true` when
+ * there were any. Caller is expected to exit with a non-zero status. Splitting
+ * the print from the exit keeps the helper unit-testable without forking a
+ * process (issue #2459).
+ */
+export declare function reportUnrecognizedFlags(args: Pick<Args, "unrecognizedFlags">, write?: (text: string) => void): boolean;
 export declare function getExtraHelpText(): string;
 export declare function printHelp(): void;

package/dist/types/cli/bench-cli.d.ts

@@ -0,0 +1,78 @@
+import type { ResolvedThinkingLevel } from "@prometheus-ai/agent-core";
+import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "@prometheus-ai/ai";
+import type { CanonicalModelVariant } from "@prometheus-ai/catalog/identity";
+import type { ApiKeyResolverModel } from "../config/api-key-resolver";
+import { type CanonicalModelQueryOptions } from "../config/model-registry";
+import { Settings } from "../config/settings";
+export interface BenchCommandArgs {
+    models: string[];
+    flags: {
+        runs?: number;
+        maxTokens?: number;
+        prompt?: string;
+        json?: boolean;
+    };
+}
+export interface BenchModelRegistry {
+    getAll(): Model<Api>[];
+    getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
+    resolver(model: ApiKeyResolverModel, sessionId?: string): ApiKeyResolver;
+    resolveCanonicalModel?(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
+    getCanonicalVariants?(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
+    getCanonicalId?(model: Model<Api>): string | undefined;
+}
+export interface BenchRuntime {
+    modelRegistry: BenchModelRegistry;
+    settings?: Settings;
+    close?: () => void;
+}
+export interface BenchRunSuccess {
+    ok: true;
+    ttftMs: number;
+    durationMs: number;
+    outputTokens: number;
+    /** Generation throughput measured over the post-first-token window. */
+    tokensPerSecond: number;
+}
+export interface BenchRunFailure {
+    ok: false;
+    error: string;
+}
+export type BenchRunResult = BenchRunSuccess | BenchRunFailure;
+export interface BenchAverages {
+    ttftMs: number;
+    durationMs: number;
+    outputTokens: number;
+    tokensPerSecond: number;
+}
+export interface BenchModelReport {
+    /** Selector as the user typed it (e.g. "opus" or "gemini-3.5:low"). */
+    selector: string;
+    /** Resolved `provider/id`. */
+    model: string;
+    /** Explicit thinking level from a `:level` selector suffix; undefined = provider default. */
+    thinking?: ResolvedThinkingLevel;
+    results: BenchRunResult[];
+    /** Averages over successful runs; null when every run failed. */
+    average: BenchAverages | null;
+}
+export interface BenchSummary {
+    runs: number;
+    maxTokens: number;
+    models: BenchModelReport[];
+    failures: number;
+}
+type BenchStreamSimple = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+export interface BenchDependencies {
+    createRuntime?: () => Promise<BenchRuntime>;
+    randomSessionId?: () => string;
+    writeStdout?: (text: string) => void;
+    writeStderr?: (text: string) => void;
+    setExitCode?: (code: number) => void;
+    streamSimple?: BenchStreamSimple;
+    now?: () => number;
+    stdoutIsTTY?: boolean;
+}
+export declare function formatBenchTable(summary: BenchSummary): string;
+export declare function runBenchCommand(command: BenchCommandArgs, deps?: BenchDependencies): Promise<BenchSummary>;
+export {};

package/dist/types/cli/claude-trace-cli.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Fully automated Claude Code /v1/messages capture helper.
+ *
+ * Starts a local CONNECT proxy, MITMs TLS using a local self-signed debug
+ * certificate, drives Claude Code through a headless PTY/xterm, and returns the
+ * first completed /v1/messages request/response exchange.
+ */
 export interface HeaderEntry {
     name: string;
     value: string;

package/dist/types/cli/dry-balance-cli.d.ts

@@ -1,5 +1,5 @@
-import type { Api, AssistantMessageEventStream, Context, Model, OAuthAccess, OAuthAccessResolution, SimpleStreamOptions } from "@prometheus-ai/ai";
-import type { CanonicalModelVariant } from "../config/model-equivalence";
+import type { Api, AssistantMessageEventStream, AuthCredentialSnapshotEntry, Context, Model, OAuthAccess, OAuthAccessResolution, SimpleStreamOptions } from "@prometheus-ai/ai";
+import type { CanonicalModelVariant } from "@prometheus-ai/catalog/identity";
 import { type CanonicalModelQueryOptions } from "../config/model-registry";
 import { Settings } from "../config/settings";
 export interface DryBalanceCommandArgs {
@@ -20,6 +20,12 @@ export interface DryBalanceAuthOptions {
 export interface DryBalanceAuthStorage {
     getOAuthAccess(provider: string, sessionId?: string, options?: DryBalanceAuthOptions): Promise<OAuthAccess | undefined>;
     getOAuthAccesses?(provider: string, options?: DryBalanceAuthOptions): Promise<OAuthAccessResolution[]>;
+    /**
+     * Force-refresh a single credential by id (step (b) of the auth-retry
+     * policy). The bench re-mints the failing account's token in place on a
+     * 401 rather than rotating accounts — it is measuring each account.
+     */
+    forceRefreshCredentialById?(id: number, signal?: AbortSignal): Promise<AuthCredentialSnapshotEntry>;
 }
 export interface DryBalanceModelRegistry {
     authStorage: DryBalanceAuthStorage;
@@ -98,7 +104,15 @@ export interface DryBalanceDependencies {
     now?: () => number;
     stdoutIsTTY?: boolean;
     stderrIsTTY?: boolean;
+    stdoutColumns?: number;
+    stderrColumns?: number;
 }
+interface DryBalanceBenchProgressSink {
+    markRunning(index: number, account: string): void;
+    complete(index: number, result: DryBalanceBenchResult): void;
+    close(): void;
+}
+export declare function createBenchProgressSink(total: number, write: (text: string) => void, interactive: boolean, columns: number): DryBalanceBenchProgressSink;
 export declare function formatDryBalanceText(summary: DryBalanceSummary): string;
 export declare function runDryBalanceCommand(command: DryBalanceCommandArgs, deps?: DryBalanceDependencies): Promise<DryBalanceSummary>;
 export {};

package/dist/types/cli/gallery-cli.d.ts

@@ -0,0 +1,43 @@
+import { type GalleryFixture } from "./gallery-fixtures";
+/** Lifecycle states the gallery renders, in display order. */
+export declare const GALLERY_STATES: readonly ["streaming", "progress", "success", "error"];
+export type GalleryState = (typeof GALLERY_STATES)[number];
+export interface GalleryCommandArgs {
+    /** Render width in columns (defaults to terminal width, clamped). */
+    width?: number;
+    /** Restrict to a single tool name. */
+    tool?: string;
+    /** Restrict to specific lifecycle states. */
+    states?: GalleryState[];
+    /** Render the expanded variant of each renderer. */
+    expanded?: boolean;
+    /** Strip ANSI styling from the output (useful when redirecting to a file). */
+    plain?: boolean;
+    /** Capture the rendered gallery as PNG screenshot(s) via VHS instead of printing ANSI. */
+    screenshot?: boolean;
+    /** Screenshot output path (single image) or base path (suffixed when split across images). */
+    out?: string;
+    /** Font family for screenshots (must be installed; Nerd Font recommended for icon glyphs). */
+    font?: string;
+    /** Font size in points for screenshots. */
+    fontSize?: number;
+}
+/** One tool's rendered lifecycle, as ANSI lines: a leading blank, the section rule, then each state. */
+export interface GallerySection {
+    heading: string;
+    lines: string[];
+}
+/** The curated fixture for a tool, or a generic one for registry tools lacking sample data. */
+export declare function resolveFixture(name: string): GalleryFixture;
+/**
+ * Render a single tool/state pair to lines. Builds a fresh component, drives it
+ * to the requested state, settles any async edit preview, then snapshots the
+ * render and stops all animation timers.
+ */
+export declare function renderGalleryState(name: string, fixture: GalleryFixture, state: GalleryState, width: number, expanded?: boolean): Promise<readonly string[]>;
+/**
+ * Render the gallery. Iterates the renderer registry (or a single tool),
+ * printing each requested lifecycle state under a labeled section — or, with
+ * `screenshot`, capturing the rendered output as PNG(s) via VHS.
+ */
+export declare function runGalleryCommand(args: GalleryCommandArgs): Promise<void>;

package/dist/types/cli/gallery-fixtures/agentic.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const agenticFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/codeintel.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the code-intelligence tools (lsp, debug). */
+import type { GalleryFixture } from "./types";
+export declare const codeintelFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/edit.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the edit tools (edit, apply_patch, ast_edit). */
+import type { GalleryFixture } from "./types";
+export declare const editFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/fs.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const fsFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export declare const galleryFixtures: {
+    [x: string]: import("./types").GalleryFixture;
+};

package/dist/types/cli/gallery-fixtures/interaction.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the todo / ask / resolve interaction tools. */
+import type { GalleryFixture } from "./types";
+export declare const interactionFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/memory.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const memoryFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/misc.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the ask / resolve / ssh / github / inspect_image tools. */
+import type { GalleryFixture } from "./types";
+export declare const miscFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/search.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the search tools (search, search_tool_bm25, ast_grep). */
+import type { GalleryFixture } from "./types";
+export declare const searchFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/shell.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the shell tools (bash, eval). */
+import type { GalleryFixture } from "./types";
+export declare const shellFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Types for `prometheus gallery` sample data. See {@link ./index} for the aggregated
+ * fixture registry and the contract each fixture must satisfy.
+ */
+import type { EditMode } from "../../edit";
+/** A tool result snapshot, matching the shape `ToolExecutionComponent` consumes. */
+export interface GalleryResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+}
+export type GalleryFixtureState = "streaming" | "progress" | "success" | "error";
+export interface GalleryFixture {
+    /** Display label for the tool header (defaults to the tool name). */
+    label?: string;
+    /** Edit mode for edit-like tools so the streaming preview dispatches correctly. */
+    editMode?: EditMode;
+    /**
+     * Custom gallery-only renderer for fixtures that are not one ToolExecutionComponent
+     * (for example the read-group transcript component).
+     */
+    renderState?: (state: GalleryFixtureState, width: number, expanded: boolean) => readonly string[] | Promise<readonly string[]>;
+    /**
+     * Set for tools whose real `AgentTool` attaches `renderCall`/`renderResult`
+     * directly on the instance (e.g. `task`). The harness then attaches
+     * the registry renderer onto the fake tool so the component routes through
+     * the custom-tool branch — the same path production takes — instead of the
+     * built-in registry branch. The two branches can diverge, so exercising the
+     * real one keeps the gallery honest for these tools.
+     */
+    customRendered?: boolean;
+    /**
+     * Renderer-registry key to use when the fixture key is a variant of a tool
+     * (e.g. `irc_wait` → `irc`). Defaults to the fixture key.
+     */
+    renderer?: string;
+    /**
+     * Arguments shown during the streaming state — a partial view of {@link args}
+     * as if the tool-call JSON were still arriving. May include `__partialJson`
+     * for renderers (bash, edit) that surface fields before the object closes.
+     * Defaults to {@link args} when omitted.
+     */
+    streamingArgs?: unknown;
+    /** Complete arguments shown for the in-progress, success, and error states. */
+    args: unknown;
+    /** Successful result. */
+    result: GalleryResult;
+    /** Failed result. Falls back to a generic error when omitted. */
+    errorResult?: GalleryResult;
+}

package/dist/types/cli/gallery-fixtures/web.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const webFixtures: Record<string, GalleryFixture>;