@oh-my-pi/pi-ai 17.1.2 → 17.1.4

package/dist/types/types.d.ts

@@ -350,6 +350,13 @@ export interface StreamOptions {
      * and then to a 120s default.
      */
     streamIdleTimeoutMs?: number;
+    /**
+     * Optional cap on Codex SSE pre-response attempts, including the initial
+     * request. WebSocket retries and outer agent retries have separate budgets.
+     * Finite values below `1` and non-finite values are clamped to one request;
+     * omission preserves the provider default.
+     */
+    codexSseMaxAttempts?: number;
     /**
      * Optional retry delay hook for tests and transports that need custom scheduling.
      */
@@ -400,7 +407,14 @@ export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
     thinkingBudgets?: ThinkingBudgets;
     /** Cursor exec handlers for local tool execution */
     cursorExecHandlers?: CursorExecHandlers;
-    /** Hook to handle tool results from Cursor exec */
+    /**
+     * Optional rewrite of Cursor exec-channel tool results. May return a Promise.
+     *
+     * The Agent reserves the original result in its buffer before awaiting this
+     * hook, and the `message_end` drain waits for a still-pending rewrite, so an
+     * async transformer is honored even when the turn closes in the same chunk.
+     * A rejecting transformer is swallowed and the reserved payload stands in.
+     */
     cursorOnToolResult?: CursorToolResultHandler;
     /** Optional tool choice override for compatible providers */
     toolChoice?: ToolChoice;
@@ -715,7 +729,24 @@ export type CursorExecHandlerResult<T> = {
     result: T;
     toolResult?: ToolResultMessage;
 } | T | ToolResultMessage;
+/**
+ * Optional rewrite of a Cursor exec-channel tool result.
+ * May return a Promise. Returning `undefined` keeps the original result.
+ *
+ * The Agent reserves the original result in its buffer before awaiting this
+ * hook, and the `message_end` drain waits for a still-pending rewrite, so an
+ * async transformer is honored even when the turn closes in the same chunk.
+ * A rejecting transformer is swallowed and the reserved payload stands in.
+ */
 export type CursorToolResultHandler = (result: ToolResultMessage) => ToolResultMessage | undefined | Promise<ToolResultMessage | undefined>;
+/**
+ * Identifies the synthesized assistant block a Cursor exec call was filed
+ * under, so paths that produce no handler `toolResult` can still pair one.
+ */
+export interface CursorExecPairing {
+    toolCallId: string;
+    toolName: string;
+}
 export interface CursorMcpCall {
     name: string;
     providerIdentifier: string;
@@ -724,6 +755,43 @@ export interface CursorMcpCall {
     args: Record<string, unknown>;
     rawArgs: Record<string, Uint8Array>;
 }
+export interface CursorTodoSnapshotItem {
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "abandoned";
+}
+/**
+ * Authoritative todo list state settled by Cursor's server-side
+ * `update_todos` / `read_todos` tools.
+ */
+export interface CursorTodoSnapshot {
+    todos: CursorTodoSnapshotItem[];
+    /** True when the server reported the update as a merge. Presentation only. */
+    merged: boolean;
+}
+/**
+ * Settles a native todo call in the host.
+ *
+ * Called for every completed native todo call, not just successful ones: the
+ * interactive todo card only resolves on a matching `tool_execution_end`, so a
+ * refused or failed call that stayed silent would animate forever.
+ *
+ * `snapshot` is the server-confirmed list, or `null` when there is nothing to
+ * mirror — a server error (`error` set), or a benign refusal with `error` null:
+ * a filtered, truncated, or empty read, or a snapshot the local model cannot
+ * represent (two rows sharing content). Local state MUST be left untouched
+ * unless a snapshot is supplied.
+ *
+ * `toolCallId` is the id of the streamed native call, which is also the key the
+ * interactive transcript filed the visible block under. The host MUST reuse it
+ * when emitting the synthetic completion, or that block never resolves.
+ *
+ * Returns the result to persist for that block — always, since every settle
+ * needs a paired result or `buildSessionContext` strips the block as dangling.
+ * Only the host knows the phase grouping the todo renderer replays from, so the
+ * provider persists this value verbatim. When no handler is registered at all,
+ * the provider falls back to its own summary-only result.
+ */
+export type CursorTodoSyncHandler = (snapshot: CursorTodoSnapshot | null, toolCallId: string, error: string | null) => ToolResultMessage;
 export interface CursorShellStreamCallbacks {
     onStdout(data: string): void;
     onStderr(data: string): void;
@@ -738,6 +806,8 @@ export interface CursorExecHandlers {
     shellStream?: (args: ShellArgs, callbacks: CursorShellStreamCallbacks) => Promise<CursorExecHandlerResult<ShellResult>>;
     diagnostics?: (args: DiagnosticsArgs) => Promise<CursorExecHandlerResult<DiagnosticsResult>>;
     mcp?: (call: CursorMcpCall) => Promise<CursorExecHandlerResult<McpResult>>;
+    /** Mirror Cursor's server-owned todo list into local session state. */
+    todoSync?: CursorTodoSyncHandler;
     onToolResult?: CursorToolResultHandler;
 }
 /**

package/dist/types/usage/minimax-code.d.ts

@@ -1,2 +1,3 @@
 import type { UsageProvider } from "../usage.js";
+/** MiniMax Token Plan (international, `api.minimax.io`). */
 export declare const minimaxCodeUsageProvider: UsageProvider;

package/dist/types/usage.d.ts

@@ -401,6 +401,16 @@ export interface CredentialRankingStrategy {
      * not block unrelated families on the same OAuth credential.
      */
     blockScope?(context?: CredentialRankingContext): string | undefined;
+    /**
+     * Scopes that apply to a request, most specific first. With a context, the
+     * request's own scope plus any legacy catch-all scope whose blocks still
+     * apply to everything. Without one — reconciliation runs with no request —
+     * every scope whose blocks must be healed.
+     *
+     * A provider that scopes backoff by model family must implement this, or a
+     * block written under one scope is invisible to requests and to healing.
+     */
+    blockScopes?(context?: CredentialRankingContext): string[];
     /** Fallback window durations (ms) when limits don't specify durationMs. */
     windowDefaults: {
         primaryMs: number;

package/dist/types/utils/idle-iterator.d.ts

@@ -39,11 +39,13 @@ export declare function getStreamFirstEventTimeoutMs(idleTimeoutMs?: number, fal
  * `"0"` disable) wins outright. Otherwise the resolved idle (caller-supplied
  * `idleTimeoutMs` — which itself already encompasses per-call
  * `streamIdleTimeoutMs` or `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` resolved
- * upstream) floors the first-event budget so slow local OpenAI-compatible
- * servers are not undercut by a shorter `PI_STREAM_FIRST_EVENT_TIMEOUT_MS`
- * or the global default during prompt processing.
+ * upstream) floors the first-event budget so slow OpenAI-compatible servers
+ * are not undercut by a shorter `PI_STREAM_FIRST_EVENT_TIMEOUT_MS` or the
+ * global default during prompt processing. A zero per-provider fallback
+ * disables the first-event watchdog unless an environment override is set.
  *
- * Returns `undefined` when an explicit env knob disables the watchdog.
+ * Returns `0` when an explicit env knob or per-provider fallback disables the
+ * watchdog, preserving the sentinel through iterator timeout resolution.
  */
 export declare function getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs?: number, fallbackMs?: number): number | undefined;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.1.2",
+	"version": "17.1.4",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/pi-catalog": "17.1.2",
-		"@oh-my-pi/pi-utils": "17.1.2",
-		"@oh-my-pi/pi-wire": "17.1.2",
+		"@oh-my-pi/pi-catalog": "17.1.4",
+		"@oh-my-pi/pi-utils": "17.1.4",
+		"@oh-my-pi/pi-wire": "17.1.4",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},

package/src/auth-broker/client.ts

@@ -7,7 +7,7 @@
  */
 import { readSseEvents } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
-import type { AuthCredential } from "../auth-storage";
+import type { AuthCredential, DisabledCredentialSummary } from "../auth-storage";
 import type {
 	ClientUsageReportRequest,
 	ClientUsageReportResponse,
@@ -20,6 +20,7 @@ import type {
 	CredentialRefreshResponse,
 	CredentialUploadRequest,
 	CredentialUploadResponse,
+	DisabledCredentialsResponse,
 	HealthzResponse,
 	SnapshotResponse,
 	SnapshotStreamEvent,
@@ -35,6 +36,7 @@ import {
 	credentialDisableResponseSchema,
 	credentialRefreshResponseSchema,
 	credentialUploadResponseSchema,
+	disabledCredentialsResponseSchema,
 	healthzResponseSchema,
 	snapshotResponseSchema,
 	snapshotStreamEventSchema,
@@ -306,6 +308,27 @@ export class AuthBrokerClient {
 		});
 	}
 
+	/**
+	 * Disabled-credential tombstones (identity + cause, no token material).
+	 * Returns an empty list against brokers predating `GET
+	 * /v1/credentials/disabled` (404).
+	 */
+	async listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]> {
+		const params = new URLSearchParams();
+		if (provider) params.set("provider", provider);
+		const path = `/v1/credentials/disabled${params.size > 0 ? `?${params.toString()}` : ""}`;
+		try {
+			const response = await this.#request<DisabledCredentialsResponse>("GET", path, {
+				schema: disabledCredentialsResponseSchema,
+				signal,
+			});
+			return response.disabled;
+		} catch (error) {
+			if (error instanceof AuthBrokerError && error.status === 404) return [];
+			throw error;
+		}
+	}
+
 	async uploadCredential(
 		provider: string,
 		credential: AuthCredential,

package/src/auth-broker/remote-store.ts

@@ -14,6 +14,7 @@ import {
 	type AuthCredential,
 	type AuthCredentialSnapshotEntry,
 	type AuthCredentialStore,
+	type DisabledCredentialSummary,
 	type OAuthCredential,
 	REMOTE_REFRESH_SENTINEL,
 	type StoredAuthCredential,
@@ -471,6 +472,11 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		return out;
 	}
 
+	/** Broker-backed disabled tombstones; empty against brokers predating the endpoint. */
+	listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]> {
+		return this.#client.listDisabledCredentials(provider, signal);
+	}
+
 	getCredentialBlock(credentialId: number, providerKey: string, blockScope: string): number | undefined {
 		const nowMs = Date.now();
 		this.cleanExpiredCredentialBlocks(nowMs);
@@ -533,6 +539,12 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 			});
 	}
 
+	deleteCredentialBlock(_credentialId: number, _providerKey: string, _blockScope: string): void {
+		// The broker protocol only supports deleting every block for a credential.
+		// Keep scoped blocks until expiry rather than risk deleting unrelated or
+		// newer broker state through that broader operation.
+	}
+
 	deleteCredentialBlocks(credentialId: number): void {
 		this.#deleteSnapshotBlocks(credentialId);
 		for (const key of this.#credentialBlockReconcileAfter.keys()) {

package/src/auth-broker/server.ts

@@ -22,6 +22,7 @@ import type {
 	CredentialDisableResponse,
 	CredentialRefreshResponse,
 	CredentialUploadResponse,
+	DisabledCredentialsResponse,
 	HealthzResponse,
 	RefresherSchedule,
 	SnapshotEntry,
@@ -659,6 +660,12 @@ export function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServer
 						return json(500, { error: message });
 					}
 				}
+				if (req.method === "GET" && pathname === "/v1/credentials/disabled") {
+					const provider = url.searchParams.get("provider") ?? undefined;
+					const disabled = await opts.storage.listDisabledCredentials(provider, req.signal);
+					const body: DisabledCredentialsResponse = { generatedAt: Date.now(), disabled };
+					return json(200, body);
+				}
 				const refreshMatch = req.method === "POST" ? pathname.match(REFRESH_ROUTE) : null;
 				if (refreshMatch) {
 					const id = Number.parseInt(refreshMatch[1], 10);

package/src/auth-broker/types.ts

@@ -10,6 +10,7 @@ import type {
 	AuthCredential,
 	AuthCredentialSnapshot,
 	AuthCredentialSnapshotEntry,
+	DisabledCredentialSummary,
 	StoredCredentialBlock,
 } from "../auth-storage";
 import type { ClientUsageClientSummary, ClientUsageReport, UsageHistoryEntry, UsageReport } from "../usage";
@@ -86,6 +87,12 @@ export interface CredentialDisableResponse {
 	ok: boolean;
 }
 
+/** GET /v1/credentials/disabled response body — tombstones of auto-disabled rows. */
+export interface DisabledCredentialsResponse {
+	generatedAt: number;
+	disabled: DisabledCredentialSummary[];
+}
+
 /** POST /v1/credential/:id/block request body. */
 export type CredentialBlockRequest = CredentialBlockSnapshot;
 

package/src/auth-broker/wire-schemas.ts

@@ -34,6 +34,7 @@ export const oauthCredentialSchema = type({
 	"accountId?": "string",
 	"orgId?": "string",
 	"orgName?": "string",
+	"authorizedAt?": "number",
 });
 
 /** OAuth credential as it appears in broker snapshots — refresh replaced with sentinel. */
@@ -49,6 +50,7 @@ export const remoteOauthCredentialSchema = type({
 	"accountId?": "string",
 	"orgId?": "string",
 	"orgName?": "string",
+	"authorizedAt?": "number",
 });
 
 export const apiKeyCredentialSchema = type({
@@ -320,6 +322,27 @@ export const credentialDisableResponseSchema = type({
 	ok: "boolean",
 });
 
+/** One disabled-credential tombstone — identity + cause, never token material. */
+export const disabledCredentialSummarySchema = type({
+	"+": "reject",
+	id: "number.integer",
+	provider: type("string").atLeastLength(1),
+	type: "'oauth' | 'api_key'",
+	"email?": "string",
+	"accountId?": "string",
+	"orgId?": "string",
+	"orgName?": "string",
+	cause: "string",
+	"disabledAtMs?": "number",
+});
+
+/** Broker `GET /v1/credentials/disabled` response. */
+export const disabledCredentialsResponseSchema = type({
+	"+": "reject",
+	generatedAt: "number",
+	disabled: disabledCredentialSummarySchema.array(),
+});
+
 // ─── Credential blocks ──────────────────────────────────────────────────────
 
 export const credentialBlockRequestSchema = credentialBlockSnapshotSchema;