@prometheus-ai/agent 0.5.3 → 0.5.8

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

@@ -0,0 +1,35 @@
+import type { GallerySection } from "./gallery-cli";
+/** Nerd Font family so the gallery's icon glyphs (PUA) render instead of tofu. */
+export declare const DEFAULT_SCREENSHOT_FONT = "JetBrainsMono Nerd Font";
+export declare const DEFAULT_SCREENSHOT_FONT_SIZE = 18;
+export interface GalleryScreenshotOptions {
+    /** Gallery render width in columns (matches the ANSI line width). */
+    width: number;
+    /** VHS `FontFamily`. */
+    font?: string;
+    /** VHS `FontSize`. */
+    fontSize?: number;
+    /**
+     * Output destination. When omitted, PNGs land in a fresh temp directory.
+     * With multiple images the path is suffixed (`name-01.png`, `name-02.png`).
+     */
+    out?: string;
+}
+/**
+ * Capture the gallery sections as one or more PNGs and return their absolute
+ * paths. Tall galleries are split across images so no single capture exceeds
+ * the terminal-canvas height limit.
+ */
+export declare function captureGalleryScreenshots(sections: GallerySection[], options: GalleryScreenshotOptions): Promise<string[]>;
+/**
+ * Resolve a chunk's PNG path. A single image keeps the bare name (or the exact
+ * `out`); multiple images gain a zero-padded `-NN` suffix so they sort and never
+ * collide.
+ */
+export declare function resolveScreenshotOutputPath(out: string | undefined, baseDir: string, index: number, total: number): string;
+/**
+ * Group whole tool sections into chunks that stay under `rowBudget` rows. A
+ * single section larger than the budget gets its own (taller) image rather than
+ * being split mid-renderer.
+ */
+export declare function chunkGallerySections(sections: GallerySection[], rowBudget: number): GallerySection[][];

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

@@ -27,6 +27,7 @@ export interface GatewayCommandFlags {
     parseMode?: string;
     disableNotification?: boolean;
     telegramAllowedUsers?: string;
+    telegramAllowedChats?: string;
     telegramExpressionCatalog?: string;
 }
 export interface GatewayBindConfig {
@@ -48,6 +49,7 @@ export interface TelegramGatewayCliConfig {
     disableNotification?: boolean;
     preferLargeMedia?: boolean;
     allowedUserIds?: string[];
+    allowedChatIds?: string[];
     expressionEnabled?: boolean;
     expressionMinScore?: number;
     expressionCatalog?: TelegramExpressionCatalog;
@@ -62,6 +64,7 @@ export interface TelegramGatewaySettingsConfig {
     publicBaseUrl?: string;
     webhookPath?: string;
     allowedUsers?: string;
+    allowedChats?: string;
     groupScope?: string;
     threadScope?: string;
     parseMode?: TelegramGatewayParseModeSetting;
@@ -91,5 +94,6 @@ export declare function runGatewayCommand(cmd: GatewayCommandArgs): Promise<void
 export declare function buildGatewaySessionDir(rootSessionDir: string, sessionKey: string): string;
 export declare function encodeGatewaySessionKeySegment(sessionKey: string): string;
 export declare function parseTelegramAllowedUserIds(value: string | undefined): string[] | undefined;
+export declare function parseTelegramAllowedChatIds(value: string | undefined): string[] | undefined;
 export declare function normalizeTelegramBotUsername(value: string | undefined): string | undefined;
 export {};

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

@@ -32,6 +32,6 @@ export declare function cleanGrievances(options: CleanGrievancesOptions): Promis
  * ignoring the user-facing consent gate (manual push is the user's
  * explicit "yes ship these now" intent).
  *
- * Requires endpoint configuration (default `qa.prometheus.trivlab.com/v1/grievances`).
+ * Requires endpoint configuration (default `qa.prometheus.sh/v1/grievances`).
  */
 export declare function pushGrievances(options: PushGrievancesOptions): Promise<void>;

package/dist/types/cli/list-models.d.ts

@@ -1,11 +1,11 @@
-import type { ModelRegistry } from "../config/model-registry";
-/**
- * List available models, optionally filtered by search pattern
- */
-export declare function listModels(modelRegistry: ModelRegistry, searchPattern?: string): Promise<void>;
 /**
- * Options for the `--list-models` command entry point.
+ * Backward-compatible `--list-models` entry point.
+ *
+ * The supported model catalog surface is `prometheus models`; this wrapper keeps
+ * the legacy flag routed through the same renderer and extension discovery path.
  */
+import type { ModelRegistry } from "../config/model-registry";
+/** Options for the legacy `--list-models` command entry point. */
 export interface RunListModelsOptions {
     modelRegistry: ModelRegistry;
     cwd: string;
@@ -19,12 +19,4 @@ export interface RunListModelsOptions {
     disableExtensionDiscovery?: boolean;
     searchPattern?: string;
 }
-/**
- * Loads extensions (CLI `-e` paths and `settings.extensions`) and surfaces
- * any provider/model registrations on the supplied `modelRegistry` before
- * delegating to {@link listModels}. This is the single entry point used by
- * `--list-models` and exists to ensure extension-contributed providers are
- * visible in the listing (issue #905). The load is intentionally narrow:
- * no agent loop, no MCP servers, no custom-tool registration.
- */
 export declare function runListModelsCommand(options: RunListModelsOptions): Promise<void>;

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

@@ -0,0 +1,49 @@
+import { ModelRegistry } from "../config/model-registry";
+export type ModelsAction = "ls" | "find" | "refresh" | "canonical";
+export interface ModelsCommandArgs {
+    action: ModelsAction;
+    /** Search substring for `find`, or optional filter for `ls`. */
+    pattern?: string;
+    flags: {
+        json?: boolean;
+        /** CLI `-e <path>` extension paths to load before listing (issue #905). */
+        extensions?: string[];
+        /** Skip extension discovery; only load explicit `extensions`. */
+        noExtensions?: boolean;
+        /** Extra `config.yml` overlays to apply for this invocation. */
+        config?: string[];
+    };
+}
+/** Resolve the two positional args into an action + filter (provider names fall through to `ls`). */
+export declare function resolveModelsArgs(first: string | undefined, second: string | undefined): {
+    action: ModelsAction;
+    pattern: string | undefined;
+};
+/**
+ * Options for {@link runModelsListing}: render the catalog from a caller-supplied
+ * registry. Loads extensions (CLI `-e` paths and configured `settings.extensions`)
+ * and discovers their providers before rendering so extension-contributed models
+ * appear (issue #905). The caller is responsible for refreshing built-in providers.
+ */
+export interface RunModelsListingOptions {
+    modelRegistry: ModelRegistry;
+    cwd: string;
+    action?: ModelsAction;
+    pattern?: string;
+    json?: boolean;
+    /** CLI-supplied extension paths (e.g. from `-e <path>`). */
+    additionalExtensionPaths?: string[];
+    /** Extension paths configured under `extensions:` in user settings. */
+    settingsExtensions?: string[];
+    /** Disabled extension ids from settings (`disabledExtensions`). */
+    disabledExtensionIds?: string[];
+    /** When true, skip discovery and only load `additionalExtensionPaths`. */
+    disableExtensionDiscovery?: boolean;
+}
+export declare function runModelsListing(options: RunModelsListingOptions): Promise<void>;
+/**
+ * Entry point for the standalone `prometheus models` command: bootstraps auth storage,
+ * settings, and the model registry, force/cache-refreshes built-in providers per
+ * the chosen action, then delegates to {@link runModelsListing}.
+ */
+export declare function runModelsCommand(command: ModelsCommandArgs): Promise<void>;

package/dist/types/cli/session-picker.d.ts

@@ -1,4 +1,4 @@
-import { type SessionInfo } from "../session/session-manager";
+import type { SessionInfo } from "../session/session-listing";
 /**
  * Show the TUI session selector and return the selected session, or null if
  * cancelled. Tab toggles between current-folder and all-projects scope; the

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

@@ -1,4 +1,4 @@
-export type SetupComponent = "python" | "stt";
+export type SetupComponent = "python" | "speech";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {

package/dist/types/cli/setup-model-picker.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Standalone TUI model picker used by `prometheus setup speech`.
+ *
+ * Mirrors {@link ./session-picker.ts} for the standalone-TUI lifecycle: spin up
+ * a one-shot {@link TUI} over a {@link SelectList}, resolve on select/cancel, and
+ * tear the UI down. The standalone TUI auto-renders on input, so no manual
+ * render wiring is needed beyond `addChild`/`setFocus`/`start`.
+ */
+import { type SelectItem } from "@prometheus-ai/tui";
+/**
+ * Show a single-column model picker and resolve with the chosen item's value,
+ * or `null` if the user cancelled. `currentValue` pre-selects the matching row.
+ */
+export declare function selectSetupModel(title: string, items: SelectItem[], currentValue: string): Promise<string | null>;

package/dist/types/cli/startup-cwd.d.ts

@@ -0,0 +1,2 @@
+import type { Args } from "./args";
+export declare function applyStartupCwd(parsed: Args): Promise<void>;

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

@@ -1,11 +1,3 @@
-export interface ReleaseInfo {
-    tag: string;
-    version: string;
-}
-export interface SourceUpdateInfo {
-    upstream?: string;
-    behind?: number;
-}
 /** Result from running the installed binary and parsing its reported version. */
 export interface InstalledVersionVerification {
     ok: boolean;
@@ -20,10 +12,6 @@ export interface BinaryReplacementOptions {
     expectedVersion: string;
     verifyInstalledVersion: (expectedVersion: string) => Promise<InstalledVersionVerification>;
 }
-export interface SourceInstallCommand {
-    command: string;
-    args: string[];
-}
 /**
  * Parse update subcommand arguments.
  * Returns undefined if not an update command.
@@ -32,30 +20,13 @@ export declare function parseUpdateArgs(args: string[]): {
     force: boolean;
     check: boolean;
 } | undefined;
-export type UpdateTarget = {
-    method: "source";
-    sourceDir: string;
-} | {
-    method: "bun";
-} | {
-    method: "binary";
-    path: string;
-};
-type UpdateOptions = {
-    force: boolean;
-    check: boolean;
-};
-export interface UpdateCommandDependencies {
-    resolveUpdateTarget: () => Promise<UpdateTarget>;
-    getLatestRelease: () => Promise<ReleaseInfo>;
-    updateViaSource: (sourceDir: string, opts: UpdateOptions) => Promise<void>;
-    updateViaBun: (expectedVersion: string) => Promise<void>;
-    updateViaBinaryAt: (targetPath: string, expectedVersion: string) => Promise<void>;
-    exit: (code: number) => never;
+type UpdateMethod = "brew" | "mise" | "bun" | "binary";
+interface UpdateMethodResolutionOptions {
+    homebrewPrefix?: string;
+    miseBinDirs?: readonly string[];
+    miseDataDir?: string;
 }
-export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "binary";
-export declare function resolveSourceCheckoutFromPath(ompPath: string): string | undefined;
-export declare function resolveUpdateTargetForTest(ompPath: string | undefined, bunBinDir: string | undefined): UpdateTarget | undefined;
+export declare function resolveUpdateMethodForTest(prometheusPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */
@@ -91,14 +62,16 @@ export declare function replaceBinaryForUpdate(options: BinaryReplacementOptions
  * See #1824.
  */
 export declare function buildBunInstallArgs(expectedVersion: string, nativeTag?: string): string[];
-export declare function getSourceUpdateInfo(sourceDir: string): Promise<SourceUpdateInfo>;
-type CommandResolver = (command: string) => string | null;
-export declare function resolveSourceInstallCommandForTest(sourceDir: string, platform: NodeJS.Platform, resolveCommand: CommandResolver): SourceInstallCommand;
+export declare function buildHomebrewUpdateArgs(force: boolean): string[];
+export declare function buildMiseUpgradeArgs(): string[];
+export declare function buildMiseForceInstallArgs(expectedVersion: string): string[];
 /**
  * Run the update command.
  */
-export declare function runUpdateCommandWithDependencies(opts: UpdateOptions, deps: UpdateCommandDependencies): Promise<void>;
-export declare function runUpdateCommand(opts: UpdateOptions): Promise<void>;
+export declare function runUpdateCommand(opts: {
+    force: boolean;
+    check: boolean;
+}): Promise<void>;
 /**
  * Print update command help.
  */

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

@@ -0,0 +1,81 @@
+/**
+ * Usage CLI command handler.
+ *
+ * Handles `prometheus usage` — fetches provider usage reports for every
+ * authenticated account and prints a detailed per-account breakdown
+ * (limits, windows, reset times, plan metadata). Accounts whose
+ * credentials produced no usage report are listed too, so the output
+ * always covers the full credential pool.
+ */
+import { type UsageHistoryEntry, type UsageReport } from "@prometheus-ai/ai";
+export interface UsageCommandArgs {
+    json?: boolean;
+    provider?: string;
+    redact?: boolean;
+    /** Show recorded usage-limit history instead of a live snapshot. */
+    history?: boolean;
+    /** History window in days (with `history`). */
+    days?: number;
+}
+/** Identity slice of a stored credential, for "every account" coverage. */
+export interface UsageAccountIdentity {
+    provider: string;
+    type: "api_key" | "oauth";
+    email?: string;
+    accountId?: string;
+    projectId?: string;
+    enterpriseUrl?: string;
+}
+/**
+ * Minimal-reveal masks for identity strings (`--redact`).
+ *
+ * Every mask shows a two-character anchor. When two identities share the
+ * anchor, the mask additionally reveals the shortest "middle-out"
+ * differentiator — the shortest substring (closest to the string's middle on
+ * ties) that no colliding identity contains — as `an*`, `ca*9*`, `ca*nb*`.
+ * Prefix growth is deliberately avoided: it leaks the start of the local
+ * part (`can.boluk@*`) when a couple of mid-string characters suffice.
+ * Duplicate strings (same account on two providers) share a mask.
+ */
+export declare function buildRedactionMap(values: Iterable<string>): Map<string, string>;
+/**
+ * Stored credentials that no usage report could be attributed to.
+ *
+ * Conservative on purpose: when a provider's reports carry no identity at
+ * all (or the credential is an API key alongside existing reports), we
+ * can't attribute, so we don't claim the account is missing.
+ */
+export declare function collectUnreportedAccounts(reports: UsageReport[], accounts: UsageAccountIdentity[]): UsageAccountIdentity[];
+/** Per-window capacity stat: how much account quota is burned and left. */
+export interface ProviderWindowStat {
+    /** Compact window label, e.g. "5h", "7d". */
+    window: string;
+    durationMs?: number;
+    /** Accounts reporting a limit in this window. */
+    accounts: number;
+    /** Sum of each account's binding used fraction — accounts' worth of quota burned. */
+    usedAccounts: number;
+    /** Accounts' worth of quota still available across reporting accounts. */
+    remainingAccounts: number;
+}
+/**
+ * Aggregate one provider's reports into per-window quota capacity stats.
+ *
+ * Limits are bucketed by window duration (5h, 7d, ...). Within a bucket each
+ * account contributes its single highest used fraction — when an account has
+ * several meters on the same window (tiered/metered limits), the most-burned
+ * one is what binds.
+ */
+export declare function computeProviderWindowStats(reports: UsageReport[]): ProviderWindowStat[];
+/**
+ * Render the full text breakdown: per provider, per account, every limit
+ * with a bar, amounts, and reset times; unattributed credentials trail
+ * each provider section as "no usage data" rows.
+ */
+export declare function formatUsageBreakdown(reports: UsageReport[], accounts: UsageAccountIdentity[], nowMs: number, redaction?: Map<string, string>): string;
+/**
+ * Render recorded usage-limit history: per provider, per account, one
+ * peak-per-bucket sparkline per limit window plus latest/peak percentages.
+ */
+export declare function formatUsageHistory(entries: UsageHistoryEntry[], sinceMs: number, nowMs: number, redaction?: Map<string, string>): string;
+export declare function runUsageCommand(cmd: UsageCommandArgs): Promise<void>;

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

@@ -10,6 +10,7 @@
  */
 import type { CommandEntry } from "@prometheus-ai/utils/cli";
 export declare const commands: CommandEntry[];
+export declare function reservedTopLevelWordMessage(first: string | undefined, argc?: number): string | undefined;
 /**
  * Return true when `first` matches a registered subcommand name or alias.
  *
@@ -17,3 +18,14 @@ export declare const commands: CommandEntry[];
  * runner skips ahead to the default `launch` command.
  */
 export declare function isSubcommand(first: string | undefined): boolean;
+export type ResolvedCliArgv = {
+    argv: string[];
+} | {
+    error: string;
+};
+/**
+ * Decide what the CLI runner should do with raw argv: reject bare reserved
+ * management words, pass help/version through untouched, and route everything
+ * that is not a known subcommand to `launch`.
+ */
+export declare function resolveCliArgv(argv: string[]): ResolvedCliArgv;

package/dist/types/collab/crypto.d.ts

@@ -0,0 +1,7 @@
+import type { CollabFrame } from "./protocol";
+export declare function generateRoomKey(): Uint8Array;
+export declare function generateWriteToken(): Uint8Array;
+export declare function importRoomKey(raw: Uint8Array): Promise<CryptoKey>;
+export declare function seal(key: CryptoKey, frame: CollabFrame): Promise<Uint8Array>;
+/** Inverse of {@link seal}. Throws on auth failure or malformed input. */
+export declare function open(key: CryptoKey, data: Uint8Array): Promise<CollabFrame>;

package/dist/types/collab/guest.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Guest side of a collab live session.
+ *
+ * `/join <link>` writes the host's snapshot to a replica session file and
+ * drives it through the normal `/resume` machinery, then applies live frames:
+ * entries → SessionManager + agent.replaceMessages, events →
+ * EventController.handleEvent, state → status-line overrides plus real
+ * model/thinking state applied to the replica agent. The host's subagent
+ * ecosystem is mirrored too: agent snapshots populate a local AgentRegistry
+ * (Agent Hub), EventBus traffic (observer HUD) is republished, and hub
+ * actions (chat/kill/revive/transcript reads) round-trip over the wire.
+ * Everything renders through the same components, so ctrl+o, theming, and
+ * transcript behavior are native by construction.
+ */
+import type { ImageContent } from "@prometheus-ai/ai";
+import type { AgentHubRemote } from "../modes/components/agent-hub";
+import type { InteractiveModeContext } from "../modes/types";
+import { AgentRegistry } from "../registry/agent-registry";
+import { type CollabSessionState } from "./protocol";
+/** Commands a guest may run locally; everything else is host-only. */
+export declare const COLLAB_GUEST_ALLOWED_COMMANDS: Record<string, true>;
+export declare class CollabGuestLink {
+    #private;
+    state: CollabSessionState | null;
+    /** Local mirror of the host's agent ecosystem (refs carry `session: null`). */
+    readonly agentRegistry: AgentRegistry;
+    /** Agent Hub actions routed to the host over the wire. */
+    get hubRemote(): AgentHubRemote;
+    /** True when this guest joined through a read-only (view) link. */
+    get readOnly(): boolean;
+    constructor(ctx: InteractiveModeContext);
+    join(link: string): Promise<void>;
+    /** User-initiated leave (or post-disconnect cleanup): restore the previous session. */
+    leave(_reason: string): Promise<void>;
+    sendPrompt(text: string, images?: ImageContent[]): void;
+    sendAbort(): void;
+}

package/dist/types/collab/host.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Host side of a collab live session.
+ *
+ * Taps the host session's event stream and SessionManager append chokepoint,
+ * broadcasting entries/events/state to guests through the relay. Guests prompt
+ * and abort through us; the host machine runs the agent and tools. The host's
+ * subagent ecosystem is mirrored too: task EventBus traffic (observer HUD),
+ * agent-registry snapshots (Agent Hub table), hub chat/kill/revive commands,
+ * and incremental subagent-transcript reads.
+ */
+import type { InteractiveModeContext } from "../modes/types";
+import { type CollabParticipant } from "./protocol";
+/** Display name for this process's user in collab sessions. */
+export declare function collabDisplayName(ctx: InteractiveModeContext): string;
+export declare class CollabHost {
+    #private;
+    constructor(ctx: InteractiveModeContext);
+    get link(): string;
+    /** Browser deep link (`https://<relay>/#<link>`) — the relay serves the web client at `/`. */
+    get webLink(): string;
+    /** Read-only variant of {@link link}: bare room key, no write token. */
+    get viewLink(): string;
+    /** Read-only variant of {@link webLink}. */
+    get webViewLink(): string;
+    get participants(): CollabParticipant[];
+    start(relayUrl: string): Promise<void>;
+    /** Broadcast a goodbye, detach all taps, and close the socket. */
+    stop(reason: string): Promise<void>;
+}

package/dist/types/collab/protocol.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Collab live-session wire protocol.
+ *
+ * Hub topology: the host is authoritative, guests never peer. All session
+ * payloads (`CollabFrame`) travel AES-256-GCM sealed; the relay only sees the
+ * plaintext envelope (`[4B uint32 BE peerId][sealed payload]`) plus TEXT JSON
+ * control messages that carry no session data.
+ */
+import type { ImageContent, Model } from "@prometheus-ai/ai";
+import type { BusChannel, GuestFrame, ParsedCollabLink, Participant, SessionState, AgentSnapshot as WireAgentSnapshot } from "@prometheus-ai/wire";
+import { DEFAULT_RELAY_URL, ENVELOPE_HEADER_LENGTH, ROOM_ID_BYTES } from "@prometheus-ai/wire";
+import type { ContextUsage } from "../extensibility/extensions/types";
+import type { AgentSessionEvent } from "../session/agent-session";
+import type { SessionEntry, SessionHeader } from "../session/session-entries";
+export type { CollabPromptDetails, ParsedCollabLink, RelayControlMessage, RelayControlToGuest, RelayControlToHost, } from "@prometheus-ai/wire";
+export { COLLAB_PROMPT_MESSAGE_TYPE, COLLAB_PROTO } from "@prometheus-ai/wire";
+export { DEFAULT_RELAY_URL, ENVELOPE_HEADER_LENGTH, ROOM_ID_BYTES };
+export type CollabParticipant = Participant;
+export type AgentSnapshot = WireAgentSnapshot;
+/** Debounced footer snapshot broadcast by the host. */
+export type CollabSessionState = SessionState & {
+    /**
+     * Host model (full catalog object). Guests apply it to their replica
+     * agent state so model display and context-window math are native.
+     */
+    model?: Model;
+    /** Host status-line context numbers (guest system prompt/tools differ, so local estimates drift). */
+    contextUsage?: ContextUsage;
+};
+/**
+ * Encrypted payload frames (inside AES-GCM, JSON). The wire package pins the
+ * JSON skeleton (`WireFrame`); host-side frames carry the rich session types
+ * that serialize into those shapes.
+ */
+export type CollabFrame = Exclude<GuestFrame, {
+    t: "prompt";
+}> | {
+    t: "prompt";
+    text: string;
+    images?: ImageContent[];
+} | {
+    t: "welcome";
+    proto: number;
+    header: SessionHeader;
+    entries: SessionEntry[];
+    state: CollabSessionState;
+    agents: AgentSnapshot[];
+    /** True when this peer joined through a read-only (view) link. */
+    readOnly?: boolean;
+} | {
+    t: "entry";
+    entry: SessionEntry;
+} | {
+    t: "event";
+    event: AgentSessionEvent;
+} | {
+    t: "state";
+    state: CollabSessionState;
+}
+/** Mirrored EventBus traffic (task subagent lifecycle/progress channels only). */
+ | {
+    t: "bus";
+    channel: BusChannel;
+    data: unknown;
+}
+/** Full agent-registry snapshot (debounced on registry change). */
+ | {
+    t: "agents";
+    agents: AgentSnapshot[];
+}
+/** Targeted reply to fetch-transcript; `text` is decoded JSONL from `fromByte`, `newSize` the next offset base. */
+ | {
+    t: "transcript";
+    reqId: number;
+    text: string;
+    newSize: number;
+    error?: string;
+} | {
+    t: "bye";
+    reason: string;
+} | {
+    t: "error";
+    message: string;
+};
+export declare function packEnvelope(peerId: number, sealed: Uint8Array): Uint8Array;
+export declare function unpackEnvelope(data: Uint8Array): {
+    peerId: number;
+    payload: Uint8Array;
+} | null;
+/** Rewrite the peerId in place without copying the payload. */
+export declare function rewriteEnvelopePeer(data: Uint8Array, peerId: number): void;
+export declare function generateRoomId(): string;
+/**
+ * Render the shareable link. Compact forms: the default relay collapses to
+ * `<roomId>.<key>`, other wss relays drop the scheme (`host[:port]/r/…`);
+ * only localhost ws:// links keep their full URL so parsing cannot
+ * mis-infer wss.
+ *
+ * The room secret is dot-joined (`<roomId>.<key>`) rather than `#`-joined:
+ * RFC 3986 forbids a raw `#` inside a fragment, so strict URL stacks (macOS
+ * Foundation behind terminal click-to-open) percent-encode a second `#` to
+ * `%23` and break the link. Parsers still accept the legacy `#` form and the
+ * mangled `%23` form.
+ *
+ * Full links append the write token to the key
+ * (`base64url(key ∥ writeToken)`); read-only (view) links carry the bare
+ * 32-byte key, which is also the pre-token link format.
+ */
+export declare function formatCollabLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
+/**
+ * Render the browser deep link: `http(s)://<relay-host>/#<collab-link>`. The
+ * relay serves the web client at `/`, and the whole collab link (including the
+ * room key) rides in the fragment, so it never appears in any HTTP request.
+ * Terminals auto-link the https form, making it click-to-join.
+ */
+export declare function formatCollabWebLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
+export declare function parseCollabLink(link: string): ParsedCollabLink | {
+    error: string;
+};

package/dist/types/collab/relay-client.d.ts

@@ -0,0 +1,22 @@
+import type { CollabFrame, RelayControlMessage } from "./protocol";
+export interface CollabSocketOptions {
+    /** wss://host[:port]/r/<roomId> — no query string. */
+    wsUrl: string;
+    role: "host" | "guest";
+    key: CryptoKey;
+}
+export declare class CollabSocket {
+    #private;
+    /** Fires after every successful (re)connect. */
+    onOpen?: () => void;
+    onFrame?: (frame: CollabFrame, fromPeer: number) => void;
+    onControl?: (msg: RelayControlMessage) => void;
+    /** Fires once per terminal close (intentional, fatal code, or bad key). willReconnect=true for transient drops that will retry. */
+    onClose?: (reason: string, willReconnect: boolean) => void;
+    constructor(opts: CollabSocketOptions);
+    get isOpen(): boolean;
+    connect(): void;
+    send(frame: CollabFrame, targetPeer?: number): void;
+    /** Intentional close: clears any retry timer, suppresses reconnect. A later connect() starts fresh. */
+    close(): void;
+}

package/dist/types/commands/bench.d.ts

@@ -0,0 +1,29 @@
+import { Command } from "@prometheus-ai/utils/cli";
+export default class Bench extends Command {
+    static description: string;
+    static args: {
+        models: import("@prometheus-ai/utils/cli").ArgDescriptor & {
+            description: string;
+            required: true;
+            multiple: true;
+        };
+    };
+    static flags: {
+        runs: import("@prometheus-ai/utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+            default: number;
+        };
+        "max-tokens": import("@prometheus-ai/utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+            default: number;
+        };
+        prompt: import("@prometheus-ai/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        json: import("@prometheus-ai/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}