@oh-my-pi/pi-coding-agent 16.1.1 → 16.1.3

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

@@ -1,6 +1,6 @@
 import type { ResolvedThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
-import type { CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
+import { type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
 import { type CanonicalModelQueryOptions } from "../config/model-registry";
 import { Settings } from "../config/settings";
@@ -20,6 +20,7 @@ export interface BenchModelRegistry {
     resolveCanonicalModel?(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
     getCanonicalVariants?(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
     getCanonicalId?(model: Model<Api>): string | undefined;
+    hasConfiguredAuth?(model: Model<Api>): boolean;
 }
 export interface BenchRuntime {
     modelRegistry: BenchModelRegistry;

package/dist/types/config/model-resolver.d.ts

@@ -201,9 +201,9 @@ export declare function resolveModelScope(patterns: string[], modelRegistry: Pic
  * the result to models matching those patterns.
  *
  * Returns the unfiltered available list when `enabledModels` is empty.
- * Returns an empty list when `enabledModels` is configured but no available
- * model matches any pattern — callers MUST treat this as "no usable model"
- * rather than falling back to the global default (see issue #1022).
+ * Returns an empty list when `enabledModels` is configured but no model matches
+ * any pattern — callers MUST treat this as "no usable model" rather than
+ * falling back to the global default (see issue #1022).
  */
 export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">, settings: Settings | undefined, preferences?: ModelMatchPreferences): Promise<Model<Api>[]>;
 /**

package/dist/types/config/settings-schema.d.ts

@@ -874,7 +874,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly inlineToolDescriptors: {
         readonly type: "boolean";
-        readonly default: true;
+        readonly default: false;
         readonly ui: {
             readonly tab: "model";
             readonly group: "Prompt";

package/dist/types/main.d.ts

@@ -54,6 +54,8 @@ export declare class SessionResolutionError extends Error {
 }
 /** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: SessionPrompt, askToMoveSession?: SessionPrompt): Promise<SessionManager | undefined>;
+/** Apply resolved CLI/discovered prompt files without bypassing system prompt templates. */
+export declare function applyResolvedSystemPromptInputs(options: CreateAgentSessionOptions, resolvedSystemPrompt: string | undefined, resolvedAppendPrompt: string | undefined): void;
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;

package/dist/types/mnemopi/embed-client.d.ts

@@ -0,0 +1,70 @@
+import type { Subprocess } from "bun";
+import type { MnemopiEmbedModelId, MnemopiEmbedWorkerInbound, MnemopiEmbedWorkerOutbound } from "./embed-protocol";
+/**
+ * Abstraction over the mnemopi embeddings subprocess. The runtime
+ * implementation is a Bun child process so `onnxruntime-node`'s NAPI
+ * constructor + finalizer never run inside the main agent address space —
+ * those destructors segfault Bun on Windows when mnemopi's local embedding
+ * provider loads fastembed in the main process (issue #3031; the mnemopi
+ * sibling of the tiny-model fix from #1606 / #1607).
+ */
+export interface MnemopiEmbedWorkerHandle {
+    send(message: MnemopiEmbedWorkerInbound): void;
+    onMessage(handler: (message: MnemopiEmbedWorkerOutbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+/**
+ * Hidden subcommand on the main CLI that boots the mnemopi embeddings worker
+ * in the spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
+ */
+export declare const MNEMOPI_EMBED_WORKER_ARG = "__omp_worker_mnemopi_embed";
+interface SpawnedSubprocess {
+    proc: Subprocess<"ignore", "ignore", "ignore">;
+    inbound: Set<(message: MnemopiEmbedWorkerOutbound) => void>;
+    errors: Set<(error: Error) => void>;
+    /**
+     * Flipped to `true` right before the deliberate SIGKILL so `onExit` can
+     * distinguish the expected hard-kill from a crash (SIGSEGV from a native
+     * fault, OOM SIGKILL, operator `kill -9`). Only the latter surfaces as a
+     * worker error so callers don't await forever.
+     */
+    intentionalExit: {
+        value: boolean;
+    };
+}
+/**
+ * Spawn the mnemopi embeddings worker as a subprocess. Exported for tests and
+ * the smoke probe; production callers go through {@link spawnMnemopiEmbedWorker}.
+ */
+export declare function createMnemopiEmbedSubprocess(): SpawnedSubprocess;
+/**
+ * Per-model wrapper produced by {@link MnemopiEmbedClient.initialize}.
+ * `embed()` round-trips one batch of texts through the worker subprocess and
+ * yields the resulting vectors in a single asynchronous batch — fastembed's
+ * own iterator was emitting batches that we collect on the child side anyway,
+ * and serializing per-batch over IPC would not improve throughput.
+ */
+export interface MnemopiSubprocessEmbeddingModel {
+    embed(texts: string[], batchSize?: number): AsyncIterable<number[][]>;
+}
+export declare class MnemopiEmbedClient {
+    #private;
+    constructor(spawnWorker?: () => MnemopiEmbedWorkerHandle);
+    /**
+     * Load the named fastembed model inside the subprocess. Resolves to a
+     * thin wrapper whose `embed()` round-trips through the same worker, or
+     * `null` when the worker cannot init the model (missing peer, native
+     * load failure, etc.). Multiple calls with the same model reuse the
+     * single in-flight worker; calling with a different model loads it on
+     * the child without restarting the process.
+     */
+    initialize(model: MnemopiEmbedModelId, cacheDir: string | undefined): Promise<MnemopiSubprocessEmbeddingModel | null>;
+    terminate(): Promise<void>;
+}
+export declare const mnemopiEmbedClient: MnemopiEmbedClient;
+export declare function shutdownMnemopiEmbedClient(): Promise<void>;
+export declare function smokeTestMnemopiEmbedWorker({ timeoutMs, }?: {
+    timeoutMs?: number;
+}): Promise<void>;
+export {};

package/dist/types/mnemopi/embed-protocol.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Wire types between the parent (`MnemopiEmbedClient`) and the local
+ * embeddings subprocess. The parent owns the subprocess lifecycle (graceful
+ * work, hard `SIGKILL` on shutdown); the protocol carries no explicit close
+ * handshake — once the parent decides to terminate, it signals the OS to reap
+ * the child so `onnxruntime-node`'s NAPI finalizer never runs in the main
+ * agent address space (it crashes Bun on Windows shutdown — issue #3031, the
+ * mnemopi sibling of the tiny-model fix from #1606/#1607). See
+ * `embed-client.ts` for the spawn/kill glue.
+ */
+/** Identifier of the fastembed model the worker should load (e.g. `fast-bge-base-en-v1.5`). */
+export type MnemopiEmbedModelId = string;
+export type MnemopiEmbedWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "init";
+    id: string;
+    model: MnemopiEmbedModelId;
+    cacheDir?: string;
+} | {
+    type: "embed";
+    id: string;
+    model: MnemopiEmbedModelId;
+    cacheDir?: string;
+    texts: string[];
+    batchSize?: number;
+};
+export type MnemopiEmbedWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "ready";
+    id: string;
+} | {
+    type: "vectors";
+    id: string;
+    vectors: number[][];
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+};
+export interface MnemopiEmbedTransport {
+    send(message: MnemopiEmbedWorkerOutbound): void;
+    onMessage(handler: (message: MnemopiEmbedWorkerInbound) => void): () => void;
+}

package/dist/types/mnemopi/embed-worker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mnemopi local-embeddings worker. Loaded inside the dedicated subprocess
+ * spawned by `embed-client.ts` (re-entered through the agent CLI's hidden
+ * `__omp_worker_mnemopi_embed` selector). The whole point of this module is
+ * that `loadFastembed()` — and therefore `onnxruntime-node`'s NAPI
+ * constructor + finalizer — only ever runs in this child address space. The
+ * parent `SIGKILL`s us on shutdown so the destructor that crashes Bun on
+ * Windows shutdown (issue #3031, mnemopi sibling of #1606/#1607) never runs
+ * in either process.
+ */
+import type { MnemopiEmbedTransport } from "./embed-protocol";
+export declare function startMnemopiEmbedWorker(transport: MnemopiEmbedTransport): void;

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

@@ -4,7 +4,15 @@ import type { Mnemopi, RecallResult } from "@oh-my-pi/pi-mnemopi";
 import type * as MnemopiCoreNs from "@oh-my-pi/pi-mnemopi/core";
 import type { AgentSession } from "../session/agent-session";
 import type { MnemopiBackendConfig } from "./config";
-/** Lazily load `@oh-my-pi/pi-mnemopi` (memoized). */
+/**
+ * Lazily load `@oh-my-pi/pi-mnemopi` (memoized) and route fastembed loads
+ * through the dedicated embeddings subprocess. The override is installed once
+ * — before any consumer gets the chance to call `embed()` — so
+ * `onnxruntime-node`'s NAPI constructor + finalizer never run inside the
+ * agent's address space (issue #3031). Test seams that swap the initializer
+ * with `setLocalModelInitializerForTests` still win because both go through
+ * the same module-level slot.
+ */
 export declare function loadMnemopi(): Promise<typeof MnemopiNs>;
 /** Lazily load `@oh-my-pi/pi-mnemopi/core` (memoized). */
 export declare function loadMnemopiCore(): Promise<typeof MnemopiCoreNs>;

package/dist/types/modes/components/assistant-message.d.ts

@@ -28,6 +28,18 @@ export declare class AssistantMessageComponent extends Container {
      */
     setErrorPinned(pinned: boolean): void;
     isTranscriptBlockFinalized(): boolean;
+    /**
+     * Whether this still-live block's scrolled-off rows may be committed to
+     * immutable native scrollback (the {@link TranscriptContainer} durable-
+     * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
+     * table — re-lays-out its body as source arrives (the diagram reshapes, the
+     * table re-aligns its columns), so committing an intermediate layout strands
+     * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
+     * clear. While such content is still streaming the block therefore stays
+     * wholly in the repaintable live region and commits once, at its final
+     * layout, when the turn finalizes.
+     */
+    isTranscriptBlockCommitStable(): boolean;
     getTranscriptBlockVersion(): number;
     markTranscriptBlockFinalized(): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;

package/dist/types/modes/components/welcome.d.ts

@@ -9,7 +9,7 @@ export declare const WELCOME_SESSION_SLOTS = 4;
  * the box height is constant regardless of how many servers a project has.
  */
 export declare const WELCOME_LSP_SLOTS = 4;
-export declare function renderWelcomeTip(tip: string, boxWidth: number): string[];
+export declare function renderWelcomeTip(tip: string, boxWidth: number, phase?: number): string[];
 export interface RecentSession {
     name: string;
     timeAgo: string;

package/dist/types/sdk.d.ts

@@ -18,7 +18,7 @@ import { MCPManager, type MCPToolsLoadResult } from "./mcp";
 import type { MnemopiSessionState } from "./mnemopi/state";
 import { AgentRegistry } from "./registry/agent-registry";
 import { AgentSession } from "./session/agent-session";
-import { AuthStorage } from "./session/auth-storage";
+import type { AuthStorage } from "./session/auth-storage";
 import { SessionManager } from "./session/session-manager";
 import { type BuildSystemPromptResult } from "./system-prompt";
 import { type ConfiguredThinkingLevel } from "./thinking";
@@ -48,8 +48,12 @@ export interface CreateAgentSessionOptions {
         model: Model;
         thinkingLevel?: ThinkingLevel;
     }>;
-    /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */
+    /** Provider-facing system prompt override. Replaces the fully rendered default blocks. */
     systemPrompt?: string | string[] | ((defaultPrompt: string[]) => string | string[]);
+    /** Already-loaded custom prompt text rendered through the bundled custom system prompt template. */
+    customSystemPrompt?: string;
+    /** Already-loaded text appended through the bundled system prompt templates. */
+    appendSystemPrompt?: string;
     /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
      * Keeps persisted session files isolated while reusing provider-side caches. */
     providerSessionId?: string;
@@ -179,6 +183,15 @@ export interface CreateAgentSessionOptions {
      * `@opentelemetry/api` package returns a no-op tracer in that case.
      */
     telemetry?: AgentTelemetryConfig;
+    /**
+     * Fired once, when the agent loop hands its first request to the provider
+     * transport (i.e. the `streamFn` wrapper is first invoked). Used to measure
+     * subagent launch latency — the boundary between "session built" and "model
+     * call dispatched". This is the loop's dispatch point, slightly before the
+     * actual provider HTTP call (per-request prep, identical across all
+     * requests, follows it), which is the right granularity for launch timing.
+     */
+    onFirstChatDispatch?: () => void;
     /** Whether to auto-approve all tool calls (--auto-approve CLI flag). Default: false */
     autoApprove?: boolean;
 }
@@ -222,6 +235,9 @@ export { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HID
  * the client receives access tokens with `refresh = "__remote__"` and calls
  * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
  * override to re-mint access tokens when needed.
+ *
+ * Delegates to {@link ./session/auth-broker-config} so the TUI and the catalog
+ * generator share the same credential-discovery logic.
  */
 export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
 /**
@@ -287,6 +303,7 @@ export interface BuildSystemPromptOptions {
         content: string;
     }>;
     cwd?: string;
+    customPrompt?: string;
     appendPrompt?: string;
     inlineToolDescriptors?: boolean;
 }

package/dist/types/session/agent-storage.d.ts

@@ -16,6 +16,8 @@ export declare class AgentStorage {
      * @returns AgentStorage instance for the given path
      */
     static open(dbPath?: string): Promise<AgentStorage>;
+    /** @internal Reset all singletons and close their databases — test-only. */
+    static resetInstance(): void;
     /**
      * Reads legacy settings persisted in the agent.db `settings` table.
      * The canonical settings store is `config.yml`; this accessor only

package/dist/types/session/auth-broker-config.d.ts

@@ -1,9 +1,28 @@
-export interface AuthBrokerClientConfig {
-    url: string;
-    token: string;
-}
-/** Path to the local bearer token file. Created on the broker host by `omp auth-broker token`. */
-export declare function getAuthBrokerTokenFilePath(): string;
+/**
+ * Resolve auth-broker connection configuration for the local omp client.
+ *
+ * This is a thin coding-agent wrapper around the shared resolver in
+ * `@oh-my-pi/pi-ai/auth-broker/discover` that preserves the process-lifetime
+ * memoization expected by the CLI and injects the full `resolveConfigValue`
+ * (including `!command` config indirection) from coding-agent's config layer.
+ *
+ * Precedence (highest first):
+ *   1. `OMP_AUTH_BROKER_URL` / `OMP_AUTH_BROKER_TOKEN` env vars.
+ *   2. `auth.broker.url` / `auth.broker.token` in `~/.omp/agent/config.yml`
+ *      (hidden from the settings UI; `!command` resolution supported).
+ *   3. Token file `~/.omp/auth-broker.token` (paired with URL from env or config).
+ *
+ * Returns null when no broker URL is configured — caller falls back to the
+ * local SQLite store.
+ *
+ * Reads config.yml directly (instead of going through `Settings.init`) because
+ * `discoverAuthStorage` runs before the settings singleton is initialized in
+ * `runRootCommand`, and we want hand-edited config entries to be honoured at
+ * boot without forcing a startup reorder.
+ */
+import { type AuthBrokerClientConfig, type DiscoverAuthStorageOptions, getAuthBrokerTokenFilePath } from "@oh-my-pi/pi-ai/auth-broker/discover";
+import type { AuthStorage } from "./auth-storage";
+export { type AuthBrokerClientConfig, getAuthBrokerTokenFilePath };
 /**
  * Read broker configuration. Returns null when the URL is missing
  * (broker disabled — local store is used). Throws when URL is set but no
@@ -15,3 +34,12 @@ export declare function getAuthBrokerTokenFilePath(): string;
  * retried. Concurrent callers share one in-flight resolution.
  */
 export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null>;
+/**
+ * Create an AuthStorage instance, using the broker when configured and falling
+ * back to the local SQLite store otherwise. Delegates to the shared resolver in
+ * pi-ai so the CLI, subagents, and the catalog generator all see the same
+ * credentials.
+ *
+ * Default `agentDir` is the current configured agent directory.
+ */
+export declare function discoverAuthStorage(agentDir?: string, options?: Omit<DiscoverAuthStorageOptions, "agentDir" | "configValueResolver">): Promise<AuthStorage>;

package/dist/types/session/history-storage.d.ts

@@ -10,7 +10,7 @@ export declare class HistoryStorage {
     #private;
     private constructor();
     static open(dbPath?: string): HistoryStorage;
-    /** @internal Reset the singleton — test-only. */
+    /** @internal Reset the singleton and close its database — test-only. */
     static resetInstance(): void;
     /**
      * Register a resolver that supplies the current session ID for prompts added

package/dist/types/system-prompt.d.ts

@@ -48,13 +48,17 @@ export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTo
 export interface BuildSystemPromptOptions {
     /** Custom system prompt (replaces default). */
     customPrompt?: string;
+    /** Already-loaded custom system prompt text; bypasses path resolution. */
+    resolvedCustomPrompt?: string;
     /** Tools to include in prompt. */
     tools?: Map<string, SystemPromptToolMetadata>;
     /** Tool names to include in prompt. */
     toolNames?: string[];
     /** Text to append to system prompt. */
     appendSystemPrompt?: string;
-    /** Inline full tool descriptors in the system prompt. Default: true */
+    /** Already-loaded append prompt text; bypasses path resolution. */
+    resolvedAppendSystemPrompt?: string;
+    /** Inline full tool descriptors in the system prompt. Default: false */
     inlineToolDescriptors?: boolean;
     /**
      * Whether provider-native tool calling is active (no owned/in-band syntax).

package/dist/types/task/executor.d.ts

@@ -83,6 +83,16 @@ export interface ExecutorOptions {
     enableLsp?: boolean;
     signal?: AbortSignal;
     onProgress?: (progress: AgentProgress) => void;
+    /**
+     * Epochs (ms, `Date.now()`) bracketing the concurrency-semaphore wait:
+     * `invokedAt` is stamped at the spawn boundary before `acquire()`,
+     * `acquiredAt` immediately after. {@link runSubprocess} reports true queue
+     * wait (`acquiredAt - invokedAt`) and pre-run setup (`startTime - acquiredAt`)
+     * separately in the launch-timing debug log. Undefined for callers that
+     * bypass the semaphore path.
+     */
+    invokedAt?: number;
+    acquiredAt?: number;
     sessionFile?: string | null;
     persistArtifacts?: boolean;
     artifactsDir?: string;

package/dist/types/tools/find.d.ts

@@ -11,7 +11,6 @@ declare const findSchema: import("arktype/internal/variants/object.ts").ObjectTy
     hidden?: boolean | undefined;
     gitignore?: boolean | undefined;
     limit?: number | undefined;
-    timeout?: number | undefined;
 }, {}>;
 export type FindToolInput = typeof findSchema.infer;
 export interface FindToolDetails {
@@ -70,7 +69,6 @@ export declare class FindTool implements AgentTool<typeof findSchema, FindToolDe
         hidden?: boolean | undefined;
         gitignore?: boolean | undefined;
         limit?: number | undefined;
-        timeout?: number | undefined;
     }, {}>;
     readonly examples: readonly ToolExample<typeof findSchema.infer>[];
     readonly strict = true;

package/dist/types/tools/image-gen.d.ts

@@ -61,6 +61,6 @@ export declare function isImageProviderPreference(value: unknown): value is Imag
 /** Set the preferred image provider from settings */
 export declare function setPreferredImageProvider(provider: ImageProviderPreference): void;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
-export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
-export declare function getImageGenToolsWithRegistry(modelRegistry: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
+export declare function getImageGenTools(_modelRegistry?: ModelRegistry, _activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
+export declare function getImageGenToolsWithRegistry(_modelRegistry: ModelRegistry, _activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
 export {};

package/dist/types/tools/search.d.ts

@@ -8,7 +8,7 @@ import type { OutputMeta } from "./output-meta";
 declare const searchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     pattern: string;
     paths?: string | string[] | undefined;
-    i?: boolean | undefined;
+    case?: boolean | undefined;
     gitignore?: boolean | undefined;
     skip?: number | null | undefined;
 }, {}>;
@@ -67,7 +67,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         pattern: string;
         paths?: string | string[] | undefined;
-        i?: boolean | undefined;
+        case?: boolean | undefined;
         gitignore?: boolean | undefined;
         skip?: number | null | undefined;
     }, {}>;
@@ -78,7 +78,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
 interface SearchRenderArgs {
     pattern: string;
     paths?: string | string[];
-    i?: boolean;
+    case?: boolean;
     gitignore?: boolean;
     skip?: number;
 }

package/dist/types/utils/image-loading.d.ts

@@ -8,7 +8,7 @@ export declare const SUPPORTED_INPUT_IMAGE_MIME_TYPES: Set<string>;
  * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
  * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
  */
-export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api"> | undefined): boolean;
+export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api" | "imageInputDecoder"> | undefined): boolean;
 /**
  * `true` when `model` cannot decode WebP, otherwise `undefined` so the
  * `OMP_NO_WEBP` env fallback in {@link resizeImage} still applies. Feed straight

package/dist/types/utils/ipc.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Narrow a value to a thenable so a rejection handler can be attached.
+ *
+ * Mirrors the local helper in `mcp/transports/stdio.ts` (kept separate because
+ * that copy serves the FileSink stdin-write path and is battle-tested there).
+ * This shared copy is the home for the IPC `send()` sites.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+/**
+ * Send a message to a Bun subprocess over IPC, neutralizing both the
+ * synchronous throw ("cannot be used after the process has exited") and any
+ * asynchronous rejection (EPIPE from a pipe that broke between exit being
+ * observed and the next `send()`). The dead worker is detected separately via
+ * `onExit`/`onError` and respawned or disabled by the owning client; an
+ * un-awaited EPIPE rejection must not escape as a fatal unhandled rejection
+ * that takes down the whole session. See issue #2997.
+ *
+ * `label` prefixes the debug log on synchronous failure (e.g. "tts").
+ */
+export declare function safeSend(proc: {
+    send(message: unknown): unknown;
+}, message: unknown, label: string): void;

package/dist/types/web/search/providers/perplexity-auth.d.ts

@@ -0,0 +1,37 @@
+import type { AuthStorage, OAuthAccess } from "@oh-my-pi/pi-ai";
+export declare const PERPLEXITY_CHAT_BASE_URL = "https://api.perplexity.ai";
+export declare const PERPLEXITY_RESPONSES_BASE_URL = "https://api.perplexity.ai/v1";
+export declare const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+export declare const OAUTH_EXPIRY_BUFFER_MS: number;
+export interface ApiConfig {
+    type: "api_key";
+    apiKey: string;
+    provider: "perplexity" | "openrouter";
+    chatBaseUrl: string;
+    responsesBaseUrl: string;
+    modelPrefix: string;
+    useResponses: boolean;
+}
+export type PerplexityAuth = ApiConfig | {
+    type: "oauth";
+    access: OAuthAccess;
+} | {
+    type: "cookies";
+    cookies: string;
+} | {
+    type: "anonymous";
+};
+export interface PerplexityAuthOptions {
+    signal?: AbortSignal;
+    forceRefresh?: boolean;
+}
+/** Detect API-key endpoints to try in priority order (Perplexity direct, then OpenRouter). */
+export declare function getApiConfigs(authStorage: AuthStorage, sessionId: string | undefined, options?: PerplexityAuthOptions): Promise<ApiConfig[]>;
+/**
+ * Decode a Perplexity JWT's `exp` claim, in ms. Returns `undefined` when the
+ * token has no `exp` (which is the common case — Perplexity sessions are
+ * server-side and effectively non-expiring from the client's POV).
+ */
+export declare function jwtExpiryMs(token: string): number | undefined;
+/** Collect all available auth methods to try in priority order */
+export declare function getAvailableAuthMethods(authStorage: AuthStorage, sessionId: string | undefined, options?: PerplexityAuthOptions): Promise<PerplexityAuth[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.1",
+	"version": "16.1.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.1",
-		"@oh-my-pi/omp-stats": "16.1.1",
-		"@oh-my-pi/pi-agent-core": "16.1.1",
-		"@oh-my-pi/pi-ai": "16.1.1",
-		"@oh-my-pi/pi-catalog": "16.1.1",
-		"@oh-my-pi/pi-mnemopi": "16.1.1",
-		"@oh-my-pi/pi-natives": "16.1.1",
-		"@oh-my-pi/pi-tui": "16.1.1",
-		"@oh-my-pi/pi-utils": "16.1.1",
-		"@oh-my-pi/pi-wire": "16.1.1",
-		"@oh-my-pi/snapcompact": "16.1.1",
+		"@oh-my-pi/hashline": "16.1.3",
+		"@oh-my-pi/omp-stats": "16.1.3",
+		"@oh-my-pi/pi-agent-core": "16.1.3",
+		"@oh-my-pi/pi-ai": "16.1.3",
+		"@oh-my-pi/pi-catalog": "16.1.3",
+		"@oh-my-pi/pi-mnemopi": "16.1.3",
+		"@oh-my-pi/pi-natives": "16.1.3",
+		"@oh-my-pi/pi-tui": "16.1.3",
+		"@oh-my-pi/pi-utils": "16.1.3",
+		"@oh-my-pi/pi-wire": "16.1.3",
+		"@oh-my-pi/snapcompact": "16.1.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/measure-prompt-tokens.ts

@@ -0,0 +1,63 @@
+import { countTokens } from "@oh-my-pi/pi-agent-core";
+import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
+import { estimateToolSchemaTokens } from "@oh-my-pi/pi-coding-agent/modes/utils/context-usage";
+import { buildSystemPrompt } from "@oh-my-pi/pi-coding-agent/system-prompt";
+import { createTools, type Tool, type ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+
+function bytes(s: string): number {
+	return Buffer.byteLength(s, "utf-8");
+}
+function est(s: string): number {
+	return (bytes(s) + 3) >> 2;
+}
+
+await Settings.init({ inMemory: true, cwd: process.cwd() });
+const settings = Settings.isolated({});
+
+const session: ToolSession = {
+	cwd: process.cwd(),
+	hasUI: false,
+	getSessionFile: () => null,
+	getSessionSpawns: () => "*",
+	settings,
+} as ToolSession;
+
+const tools = await createTools(session);
+const toolsMap = new Map<string, Tool>(tools.map(t => [t.name, t]));
+
+console.log(`active tools (${tools.length}): ${tools.map(t => t.name).join(", ")}\n`);
+
+const rows: Array<{ name: string; descBytes: number; tok: number; schemaTok: number }> = [];
+for (const t of tools) {
+	const tok = estimateToolSchemaTokens([t as never]);
+	const descBytes = bytes(t.description ?? "");
+	const descTok = est(t.description ?? "");
+	rows.push({ name: t.name, descBytes, tok, schemaTok: tok - descTok });
+}
+rows.sort((a, b) => b.tok - a.tok);
+
+const totalTok = estimateToolSchemaTokens(tools as never);
+console.log("per-tool tokens (sorted): name | total tok | desc bytes | ~schema tok");
+for (const r of rows) {
+	console.log(
+		`  ${r.name.padEnd(20)} ${String(r.tok).padStart(6)}  ${String(r.descBytes).padStart(7)}  ${String(r.schemaTok).padStart(6)}`,
+	);
+}
+console.log(`\nTOOLS TOTAL tokens: ${totalTok}\n`);
+
+const built = await buildSystemPrompt({
+	tools: toolsMap as never,
+	toolNames: tools.map(t => t.name),
+	inlineToolDescriptors: false,
+	nativeTools: true,
+	cwd: process.cwd(),
+	skills: [],
+	contextFiles: [],
+	workspaceTree: { rootPath: process.cwd(), rendered: "", truncated: false, totalLines: 0, agentsMdFiles: [] },
+});
+const parts = built.systemPrompt;
+const part0 = parts[0] ?? "";
+const rest = parts.slice(1).join("\n");
+console.log(`system prompt parts: ${parts.length}`);
+console.log(`SYSTEM PROMPT tokens (part0, no skills): ${countTokens(part0)}  (bytes=${bytes(part0)})`);
+console.log(`SYSTEM CONTEXT tokens (parts[1..]): ${countTokens(rest)}  (bytes=${bytes(rest)})`);