@oh-my-pi/pi-ai 16.1.23 → 16.2.1

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [16.2.0] - 2026-06-27
+
+### Breaking Changes
+
+- Removed the `@oh-my-pi/pi-ai/utils/json-parse` module. The JSON repair and parsing helpers (`repairJson`, `parseJsonWithRepair`, `parseStreamingJson`, `parseStreamingJsonThrottled`) have been moved to `@oh-my-pi/pi-utils` to be shared across utilities.
+
+### Added
+
+- Added the GitLab Duo Agent provider (`gitlab-duo-agent`) and built-in implementation, renaming the existing AI Gateway proxy provider to "GitLab Duo Non-Agentic" (`gitlab-duo`).
+- Added GitLab Duo Workflow provider support, featuring OAuth login via the official VS Code OAuth application, automatic project discovery, and automatic session-time namespace Duo settings enablement.
+- Added runaway detection for Gemini models to interrupt streams stuck in excessive planning steps.
+- Added a per-provider in-flight request limiter for LLM streams, shared across local OMP processes and configurable via `maxInFlightRequests`.
+- Added a `credits` field to `UsageResetCredits` to display when banked rate-limit resets expire, with support for OpenAI Codex usage details.
+
+### Changed
+
+- Optimized GitLab Duo Agent and Workflow providers to use an inline custom "ambient" flow with MCP-only agent privileges, registering MCP tools under their bare names.
+- Improved GitLab Duo Agent context management and auto-compaction by lowering the soft overflow threshold to 1 MB and stripping redundant bytes (such as tool-call UUIDs and escaped JSON) from the goal transcript.
+- Enhanced GitLab Duo Agent prompt engineering to render replayed tool calls as past-tense records, reducing model confusion and preventing the model from mimicking historical markers.
+- Added caching for discovered GitLab Duo Agent root namespaces per account to avoid redundant discovery requests.
+
+### Fixed
+
+- Fixed various GitLab Duo Agent and Workflow stability issues, including infinite tool-call loops, connection hangs on half-open WebSockets, and unhandled step-limit or generic server-side failures.
+- Improved GitLab Duo Workflow routing, namespace resolution, and project-path handling, ensuring correct numeric ID resolution and support for self-managed GitLab relative install base paths.
+- Fixed GitLab Duo Workflow checkpoint streaming to correctly map reasoning entries to thinking blocks, preserve tool boundaries, and accurately report token usage.
+- Fixed `AuthStorage.login` to only synthesize manual-code paste prompts for paste-code providers, preventing terminal-blocking races on loopback OAuth flows.
+- Fixed llama.cpp compatibility by downgrading named forced `tool_choice` objects to the string `"required"` in the chat-completions encoder.
+- Fixed `omp usage` omitting Ollama and Ollama Cloud accounts by registering placeholder usage providers.
+- Fixed Gemini reasoning-runaway detection to expose a dedicated thought-summary header guard to interrupt streams stuck in planning loops.
+
+### Removed
+
+- Removed legacy GitLab Duo Workflow `chat` and `software_development` flow paths and the non-MCP action bridge in favor of the inline custom `ambient` flow.
+
 ## [16.1.23] - 2026-06-26
 
 ### Added

package/dist/types/auth-broker/wire-schemas.d.ts

@@ -331,6 +331,11 @@ export declare const usageResponseSchema: import("arktype/internal/variants/obje
         }[];
         resetCredits?: {
             availableCount: number;
+            credits?: {
+                grantedAt?: string | undefined;
+                expiresAt?: string | undefined;
+                status?: string | undefined;
+            }[] | undefined;
         } | undefined;
         notes?: string[] | undefined;
         metadata?: {

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ export * from "./providers/anthropic-client";
 export * from "./providers/azure-openai-responses";
 export type * from "./providers/cursor";
 export * from "./providers/gitlab-duo";
+export * from "./providers/gitlab-duo-workflow";
 export type * from "./providers/google";
 export type * from "./providers/google-gemini-cli";
 export type * from "./providers/google-vertex";
@@ -34,6 +35,7 @@ export * from "./usage/github-copilot";
 export * from "./usage/google-antigravity";
 export * from "./usage/kimi";
 export * from "./usage/minimax-code";
+export * from "./usage/ollama";
 export * from "./usage/openai-codex";
 export * from "./usage/openai-codex-reset";
 export * from "./usage/opencode-go";

package/dist/types/providers/anthropic-messages-server-schema.d.ts

@@ -103,6 +103,17 @@ export declare const userMessageSchema: import("arktype/internal/variants/object
         type: string;
     })[];
 }, {}>;
+export declare const systemMessageSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    role: "system";
+    content: string | {
+        type: "text";
+        text: string;
+        cache_control?: {
+            type: "ephemeral";
+            ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[];
+}, {}>;
 export declare const assistantMessageSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     role: "assistant";
     content: string | ({
@@ -204,6 +215,16 @@ export declare const messageSchema: import("arktype/internal/variants/object.ts"
     } | {
         type: string;
     })[];
+} | {
+    role: "system";
+    content: string | {
+        type: "text";
+        text: string;
+        cache_control?: {
+            type: "ephemeral";
+            ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[];
 } | {
     role: "assistant";
     content: string | ({
@@ -344,6 +365,16 @@ export declare const anthropicMessagesRequestSchema: import("arktype/internal/va
         } | {
             type: string;
         })[];
+    } | {
+        role: "system";
+        content: string | {
+            type: "text";
+            text: string;
+            cache_control?: {
+                type: "ephemeral";
+                ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        }[];
     } | {
         role: "assistant";
         content: string | ({

package/dist/types/providers/gitlab-duo-workflow.d.ts

@@ -0,0 +1,254 @@
+import { type GitLabDuoWorkflowNamespaceSelection } from "@oh-my-pi/pi-catalog/discovery/gitlab-duo-workflow";
+import type { AssistantMessage, Context, FetchImpl, Model, ProviderSessionState, StreamFunction, StreamOptions, Tool, ToolChoice, ToolResultMessage } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+export declare const GITLAB_DUO_WORKFLOW_PROVIDER_ID = "gitlab-duo-agent";
+export declare const GITLAB_DUO_WORKFLOW_API = "gitlab-duo-agent";
+export declare const GITLAB_DUO_WORKFLOW_DEFINITION = "ambient";
+export type GitLabDuoWorkflowDefinition = "ambient" | (string & {});
+export declare const GITLAB_DUO_WORKFLOW_CLIENT_CAPABILITIES: readonly ["incremental_streaming", "read_file_chunked", "shell_command", "command_timeout", "tool_call_approval"];
+export interface GitLabMcpToolArgs {
+    name?: string;
+    tool_name?: string;
+    toolName?: string;
+    providerIdentifier?: string;
+    provider_identifier?: string;
+    toolCallId?: string;
+    tool_call_id?: string;
+    args?: Record<string, unknown> | string;
+    arguments?: Record<string, unknown> | string;
+}
+export interface GitLabPlainTextResponse {
+    response?: string;
+    error?: string;
+}
+export type PlainTextResponse = GitLabPlainTextResponse;
+export interface GitLabDuoWorkflowOptions extends StreamOptions {
+    rootNamespaceId?: string;
+    namespaceId?: string;
+    projectId?: string;
+    projectPath?: string;
+    workflowDefinition?: GitLabDuoWorkflowDefinition;
+    workflowId?: string;
+    workflowToken?: string;
+    cwd?: string;
+    webSocketFactory?: GitLabDuoWorkflowWebSocketFactory;
+    /** Idle WebSocket deadline (ms) before aborting and resuming; defaults to {@link GITLAB_DUO_WORKFLOW_IDLE_TIMEOUT_MS}. */
+    idleTimeoutMs?: number;
+    /**
+     * Tool-choice override forwarded from the stream layer. Only `"none"` is
+     * acted on: a side-request (e.g. handoff) keeps tool definitions in the cache
+     * prefix but disables tool use, so the provider must not advertise them to Duo.
+     */
+    toolChoice?: ToolChoice;
+}
+export interface GitLabDuoWorkflowWebSocketLike {
+    readyState?: number;
+    binaryType?: string;
+    onopen: ((event: Event) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+}
+export interface GitLabDuoWorkflowWebSocketFactoryOptions {
+    headers: Record<string, string>;
+    protocols?: string[];
+}
+export type GitLabDuoWorkflowWebSocketFactory = (url: string, options: GitLabDuoWorkflowWebSocketFactoryOptions) => GitLabDuoWorkflowWebSocketLike;
+export interface GitLabDirectAccessResponse {
+    token?: string;
+    access_token?: string;
+    jwt?: string;
+    workflow_token?: string;
+    duo_workflow_access_token?: string;
+    duo_workflow_service?: {
+        token?: string;
+        base_url?: string;
+        headers?: Record<string, string>;
+    };
+    gitlab_rails?: {
+        token?: string;
+    };
+    [key: string]: unknown;
+}
+interface GitLabDuoWorkflowCreateBodyOptions {
+    projectId?: string;
+    goal?: string;
+    workflowDefinition?: GitLabDuoWorkflowDefinition;
+}
+interface GitLabDuoWorkflowStartMetadataOptions {
+    projectId?: string;
+    projectPath?: string;
+    namespaceId?: string;
+    rootNamespaceId?: string;
+    workflowDefinition?: GitLabDuoWorkflowDefinition;
+    inlineFlow?: boolean;
+}
+export interface GitLabMcpToolDefinition {
+    name: string;
+    originalToolName: string;
+    serverName: string;
+    description: string;
+    inputSchema: string;
+    isApproved: boolean;
+}
+export interface GitLabDuoWorkflowAdditionalContextItem {
+    id: string;
+    category: "agent_user_environment" | "user_rule";
+    content: string;
+    metadata: {
+        title: string;
+        enabled: boolean;
+        subType: "snippet";
+        icon: string;
+        secondaryText: string;
+        subTypeLabel: string;
+    };
+}
+export interface GitLabDuoWorkflowStartRequest {
+    workflowID: string;
+    clientVersion: "1.0";
+    workflowDefinition: GitLabDuoWorkflowDefinition;
+    goal: string;
+    workflowMetadata: string;
+    additional_context: readonly GitLabDuoWorkflowAdditionalContextItem[];
+    approval?: {
+        approval?: Record<string, never>;
+        rejection?: {
+            message?: string;
+        };
+    };
+    clientCapabilities: readonly (typeof GITLAB_DUO_WORKFLOW_CLIENT_CAPABILITIES)[number][];
+    mcpTools: GitLabMcpToolDefinition[];
+    preapproved_tools: string[];
+    flowConfigSchemaVersion?: "v1";
+    flowConfigId?: string;
+    flowVersion?: string;
+    flowConfig?: GitLabDuoWorkflowInlineFlowConfig;
+}
+export interface GitLabDuoWorkflowInlineFlowComponent {
+    name: string;
+    type: "AgentComponent";
+    prompt_id: string;
+    toolset: string[];
+    inputs: {
+        from: string;
+        as: string;
+    }[];
+    ui_log_events: string[];
+}
+export interface GitLabDuoWorkflowInlineFlowPrompt {
+    name: string;
+    prompt_id: string;
+    unit_primitives: string[];
+    prompt_template: {
+        system: string;
+        user: string;
+        placeholder: string;
+    };
+}
+export interface GitLabDuoWorkflowInlineFlowConfig {
+    version: "v1";
+    environment: "ambient";
+    flow: {
+        entry_point: string;
+    };
+    components: GitLabDuoWorkflowInlineFlowComponent[];
+    routers: {
+        from: string;
+        to: string;
+    }[];
+    prompts: GitLabDuoWorkflowInlineFlowPrompt[];
+}
+export interface GitLabDuoWorkflowActionResponse {
+    actionResponse: {
+        requestID: string;
+        plainTextResponse?: GitLabPlainTextResponse;
+    };
+}
+interface GitLabDuoWorkflowActionDescriptor {
+    requestID: string;
+    name: string;
+    args: unknown;
+}
+export interface GitLabDuoWorkflowActiveSession {
+    workflowId: string;
+    startPayload: GitLabDuoWorkflowStartRequest;
+    ws: GitLabDuoWorkflowWebSocketLike;
+    stop?: () => void;
+    pendingActions?: GitLabDuoWorkflowActionDescriptor[];
+    checkpointAgentContentByKey?: Record<string, string>;
+    checkpointAgentContentSignatures?: Record<string, true>;
+    paused?: boolean;
+    pauseBuffer?: unknown[];
+    lastToolBoundaryContentLength?: number;
+}
+export interface GitLabDuoWorkflowProviderSessionState extends ProviderSessionState {
+    active?: GitLabDuoWorkflowActiveSession;
+}
+export interface GitLabDuoWorkflowStreamState {
+    stream: AssistantMessageEventStream;
+    output: AssistantMessage;
+    activeTextIndex?: number;
+    activeThinkingIndex?: number;
+    activeCheckpointMessageKey?: string;
+    started: boolean;
+    checkpointAgentContentByKey?: Record<string, string>;
+    checkpointAgentContentSignatures?: Record<string, true>;
+    pauseRequested?: boolean;
+    stepLimitRequested?: boolean;
+    retryableErrorRequested?: boolean;
+    lastCheckpointContentLength?: number;
+    stalledRequested?: boolean;
+    providerSessionState?: GitLabDuoWorkflowProviderSessionState;
+    lastApprovalStatus?: string;
+    goalOverflowMessage?: string;
+}
+type GitLabDuoWorkflowSocketResult = "closed" | "terminal" | "approval" | "action" | "pause" | "timeout" | "step_limit" | "retryable_error" | "stalled";
+export interface GitLabAvailableModel {
+    name?: string | null;
+    ref?: string | null;
+}
+export interface GitLabAvailableModelsPayload {
+    pinnedModel?: GitLabAvailableModel | null;
+    selectedModel?: GitLabAvailableModel | null;
+    defaultModel?: GitLabAvailableModel | null;
+    selectableModels?: GitLabAvailableModel[] | null;
+}
+export declare const streamGitLabDuoWorkflow: StreamFunction<"gitlab-duo-agent">;
+export declare function buildGitLabDuoWorkflowDirectAccessBody(rootNamespaceId: string, projectId?: string, workflowDefinition?: GitLabDuoWorkflowDefinition): Record<string, string>;
+export declare function buildGitLabDuoWorkflowCreateBody(namespaceId?: string, options?: GitLabDuoWorkflowCreateBodyOptions): Record<string, string | boolean | string[] | number[]>;
+export declare function buildGitLabDuoWorkflowStopBody(): Record<string, string>;
+export declare function buildGitLabDuoWorkflowWebSocketUrl(baseUrl: string, options?: {
+    projectId?: string;
+    namespaceId?: string;
+    rootNamespaceId?: string;
+    selectedModelIdentifier?: string;
+    workflowDefinition?: GitLabDuoWorkflowDefinition;
+    serviceEndpoint?: boolean;
+}): string;
+export declare function buildGitLabDuoWorkflowWebSocketHeaders(options: {
+    token: string;
+    baseUrl?: string;
+    projectId?: string;
+    namespaceId?: string;
+    rootNamespaceId?: string;
+    extraHeaders?: Record<string, string>;
+}): Record<string, string>;
+export declare function buildGitLabDuoWorkflowStartRequest(workflowId: string, model: Model<"gitlab-duo-agent">, context: Context, tools?: Tool[] | undefined, availableModels?: GitLabAvailableModelsPayload | null, metadataOptions?: GitLabDuoWorkflowStartMetadataOptions): GitLabDuoWorkflowStartRequest;
+export declare function buildGitLabDuoWorkflowInlineFlowConfig(systemPrompt: string): GitLabDuoWorkflowInlineFlowConfig;
+export declare function buildGitLabDuoWorkflowClientAdditionalContext(): GitLabDuoWorkflowAdditionalContextItem[];
+export declare function buildGitLabDuoWorkflowMcpTools(tools: Tool[] | undefined): GitLabMcpToolDefinition[];
+export declare function selectGitLabDuoWorkflowModelRef(selectedModel: string, availableModels?: GitLabAvailableModelsPayload | null): string;
+export declare function buildGitLabPlainTextFromToolResult(toolResult: ToolResultMessage): GitLabPlainTextResponse;
+export declare function gitLabDuoWorkflowErrorText(error: unknown): string;
+export declare function buildGitLabDuoWorkflowSettingsBody(): Record<string, unknown>;
+export declare function runGitLabDuoWorkflowSocket(ws: GitLabDuoWorkflowWebSocketLike, startPayload: GitLabDuoWorkflowStartRequest, state: GitLabDuoWorkflowStreamState, options: GitLabDuoWorkflowOptions, resumeResponse?: GitLabDuoWorkflowActionResponse | readonly GitLabDuoWorkflowActionResponse[], replayMessages?: readonly unknown[]): Promise<GitLabDuoWorkflowSocketResult>;
+export declare function buildGitLabDuoWorkflowApprovalStartRequest(startPayload: GitLabDuoWorkflowStartRequest): GitLabDuoWorkflowStartRequest;
+export declare function describeGitLabDuoWorkflowSocketEvent(event: unknown): string;
+export declare function traceGitLabDuoWorkflow(event: string, data?: Record<string, unknown>): void;
+export declare function extractGitLabWorkflowToken(payload: GitLabDirectAccessResponse): string | undefined;
+export declare function resolveGitLabDuoWorkflowNamespaceSelection(model: Model<"gitlab-duo-agent">, options: GitLabDuoWorkflowOptions, apiKey: string, baseUrl: string, fetchImpl: FetchImpl): Promise<GitLabDuoWorkflowNamespaceSelection>;
+export declare function resolveGitLabDuoWorkflowRootNamespaceId(model: Model<"gitlab-duo-agent">, options: GitLabDuoWorkflowOptions, apiKey: string, baseUrl: string, fetchImpl: FetchImpl): Promise<string>;
+export {};

package/dist/types/registry/gitlab-duo-workflow.d.ts

@@ -0,0 +1,10 @@
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+export declare const gitLabDuoWorkflowProvider: {
+    readonly id: "gitlab-duo-agent";
+    readonly name: "GitLab Duo Agent";
+    readonly envKeys: "GITLAB_TOKEN";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<OAuthCredentials>;
+    readonly refreshToken: (credentials: OAuthCredentials) => Promise<OAuthCredentials>;
+    readonly callbackPort: 8080;
+    readonly pasteCodeFlow: true;
+};

package/dist/types/registry/gitlab-duo.d.ts

@@ -1,7 +1,7 @@
 import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
 export declare const gitlabDuoProvider: {
     readonly id: "gitlab-duo";
-    readonly name: "GitLab Duo";
+    readonly name: "GitLab Duo Non-Agentic";
     readonly login: (cb: OAuthLoginCallbacks) => Promise<OAuthCredentials>;
     readonly refreshToken: (credentials: OAuthCredentials) => Promise<OAuthCredentials>;
     readonly callbackPort: 8080;

package/dist/types/registry/oauth/gitlab-duo-workflow.d.ts

@@ -0,0 +1,6 @@
+import type { FetchImpl } from "../../types";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
+export declare const GITLAB_DUO_WORKFLOW_OAUTH_CLIENT_ID = "36f2a70cddeb5a0889d4fd8295c241b7e9848e89cf9e599d0eed2d8e5350fbf5";
+export declare const GITLAB_DUO_WORKFLOW_OAUTH_REDIRECT_URI = "vscode://gitlab.gitlab-workflow/authentication";
+export declare function loginGitLabDuoWorkflow(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
+export declare function refreshGitLabDuoWorkflowToken(credentials: OAuthCredentials, fetchImpl?: FetchImpl): Promise<OAuthCredentials>;

package/dist/types/registry/registry.d.ts

@@ -71,7 +71,15 @@ declare const ALL: ({
     readonly refreshToken: (credentials: import("./oauth").OAuthCredentials) => Promise<import("./oauth").OAuthCredentials>;
 } | {
     readonly id: "gitlab-duo";
-    readonly name: "GitLab Duo";
+    readonly name: "GitLab Duo Non-Agentic";
+    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<import("./oauth").OAuthCredentials>;
+    readonly refreshToken: (credentials: import("./oauth").OAuthCredentials) => Promise<import("./oauth").OAuthCredentials>;
+    readonly callbackPort: 8080;
+    readonly pasteCodeFlow: true;
+} | {
+    readonly id: "gitlab-duo-agent";
+    readonly name: "GitLab Duo Agent";
+    readonly envKeys: "GITLAB_TOKEN";
     readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<import("./oauth").OAuthCredentials>;
     readonly refreshToken: (credentials: import("./oauth").OAuthCredentials) => Promise<import("./oauth").OAuthCredentials>;
     readonly callbackPort: 8080;

package/dist/types/stream.d.ts

@@ -5,6 +5,14 @@ import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
 import type { Api, AssistantMessage, Context, Model, OptionsForApi, SimpleStreamOptions, ToolChoice } from "./types";
 import { AssistantMessageEventStream } from "./utils/event-stream";
+export declare function configureProviderMaxInFlightRequests(limits: Record<string, number> | undefined): void;
+export declare const __providerInFlightForTesting: {
+    setRoot(root: string | undefined): void;
+    providerDir(provider: string): string;
+    lockDir(provider: string): string;
+    captureStaleLockRelease(provider: string): Promise<(() => Promise<void>) | null>;
+    captureLockDirRelease(provider: string): Promise<(() => Promise<void>) | null>;
+};
 /**
  * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
  *

package/dist/types/types.d.ts

@@ -12,6 +12,7 @@ import type { StopDetails } from "./providers/anthropic-wire";
 import type { AzureOpenAIResponsesOptions } from "./providers/azure-openai-responses";
 import type { CursorOptions } from "./providers/cursor";
 import type { DevinOptions } from "./providers/devin";
+import type { GitLabDuoWorkflowOptions } from "./providers/gitlab-duo-workflow";
 import type { GoogleOptions } from "./providers/google";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
@@ -47,6 +48,7 @@ export interface ApiOptionsMap {
     "google-vertex": GoogleVertexOptions;
     "ollama-chat": OllamaChatOptions;
     "cursor-agent": CursorOptions;
+    "gitlab-duo-agent": GitLabDuoWorkflowOptions;
     "devin-agent": DevinOptions;
 }
 export type OptionsForApi<TApi extends Api> = StreamOptions | (TApi extends keyof ApiOptionsMap ? ApiOptionsMap[TApi] : never);
@@ -201,6 +203,14 @@ export interface StreamOptions {
      * Providers can use this to persist transport/session state between turns.
      */
     providerSessionState?: Map<string, ProviderSessionState>;
+    /**
+     * Optional per-provider concurrent request cap for LLM stream calls. Keys are
+     * provider ids (`model.provider`); positive numeric values cap in-flight
+     * requests across local OMP processes that share the same config root. Omitted
+     * providers are unlimited. Non-chat provider APIs that bypass stream helpers
+     * are not covered.
+     */
+    maxInFlightRequests?: Record<string, number>;
     /**
      * Optional callback for inspecting or replacing provider payloads before sending.
      * Return undefined to keep the payload unchanged.
@@ -261,6 +271,8 @@ export interface StreamOptions {
      * channel) silently ignore the override.
      */
     fetch?: FetchImpl;
+    /** Current session working directory for providers that need workspace-scoped discovery. */
+    cwd?: string;
     /** Cursor exec/MCP tool handlers (cursor-agent only). */
     execHandlers?: CursorExecHandlers;
 }

package/dist/types/usage/ollama.d.ts

@@ -0,0 +1,5 @@
+import type { UsageProvider } from "../usage";
+/** Registers Ollama accounts with usage views even though no quota endpoint is exposed. */
+export declare const ollamaUsageProvider: UsageProvider;
+/** Registers Ollama Cloud accounts with usage views until a quota endpoint is available. */
+export declare const ollamaCloudUsageProvider: UsageProvider;

package/dist/types/usage/openai-codex-base-url.d.ts

@@ -0,0 +1 @@
+export declare function normalizeCodexBaseUrl(baseUrl?: string): string;

package/dist/types/usage/openai-codex.d.ts

@@ -1,4 +1,3 @@
 import type { CredentialRankingStrategy, UsageProvider } from "../usage";
-export declare function normalizeCodexBaseUrl(baseUrl?: string): string;
 export declare const openaiCodexUsageProvider: UsageProvider;
 export declare const codexRankingStrategy: CredentialRankingStrategy;

package/dist/types/usage.d.ts

@@ -50,6 +50,22 @@ export interface UsageLimit {
     status?: UsageStatus;
     notes?: string[];
 }
+/**
+ * Per-credit detail for a saved/banked rate-limit reset.
+ *
+ * Populated when the provider's listing endpoint returns individual credit
+ * metadata (e.g. OpenAI Codex `wham/rate-limit-reset-credits`). Callers that
+ * only need the count can ignore this; display layers use `expiresAt` to show
+ * when banked resets expire ([#3339](https://github.com/can1357/oh-my-pi/issues/3339)).
+ */
+export interface UsageResetCreditDetail {
+    /** ISO timestamp when the credit was granted. */
+    grantedAt?: string;
+    /** ISO timestamp when the credit expires and can no longer be redeemed. */
+    expiresAt?: string;
+    /** Backend status, e.g. `available`, `redeemed`. */
+    status?: string;
+}
 /**
  * Saved/banked rate-limit resets an account can redeem on demand.
  *
@@ -60,6 +76,8 @@ export interface UsageLimit {
 export interface UsageResetCredits {
     /** Number of resets available to redeem right now. */
     availableCount: number;
+    /** Individual credit details (expiry dates, etc.) when the provider exposes them. */
+    credits?: UsageResetCreditDetail[];
 }
 /** Aggregated usage report for a provider. */
 export interface UsageReport {
@@ -188,8 +206,18 @@ export declare const usageLimitSchema: import("arktype/internal/variants/object.
     status?: "exhausted" | "ok" | "unknown" | "warning" | undefined;
     notes?: string[] | undefined;
 }, {}>;
+export declare const usageResetCreditDetailSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    grantedAt?: string | undefined;
+    expiresAt?: string | undefined;
+    status?: string | undefined;
+}, {}>;
 export declare const usageResetCreditsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     availableCount: number;
+    credits?: {
+        grantedAt?: string | undefined;
+        expiresAt?: string | undefined;
+        status?: string | undefined;
+    }[] | undefined;
 }, {}>;
 export declare const usageReportSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     provider: string;
@@ -226,6 +254,11 @@ export declare const usageReportSchema: import("arktype/internal/variants/object
     }[];
     resetCredits?: {
         availableCount: number;
+        credits?: {
+            grantedAt?: string | undefined;
+            expiresAt?: string | undefined;
+            status?: string | undefined;
+        }[] | undefined;
     } | undefined;
     notes?: string[] | undefined;
     metadata?: {

package/dist/types/utils/thinking-loop.d.ts

@@ -4,6 +4,15 @@ import { AssistantMessageEventStream } from "./event-stream";
  *  message also carries "stream stall" so the session + transport retry
  *  classifiers treat it as a transient (retryable) stop without bespoke rules. */
 export declare const THINKING_LOOP_ERROR_MARKER = "Thinking loop detected";
+/**
+ * True when `model` is a Gemini model whose native thinking stream surfaces the
+ * "thought summary" titles this module's header guard counts.
+ *
+ * OpenAI-compat transports can serve Gemini under an arbitrary provider/id, so they
+ * carry the explicit `compat.enableGeminiThinkingLoopGuard` flag; direct Gemini
+ * transports carry a clearly shaped id/provider, so a string match is sufficient.
+ */
+export declare function isGeminiThinkingModel(model: Model<Api>): boolean;
 /**
  * True when `model` should be guarded for thinking/response loops (Gemini & DeepSeek).
  *
@@ -27,6 +36,43 @@ export declare class ThinkingLoopDetector {
      *  which may be the one that completes a duplicate cluster — is not dropped. */
     flush(): string | null;
 }
+/**
+ * Consecutive Gemini thought-summary headers in one uninterrupted reasoning
+ * stream that trips the tool-call reminder. Gemini occasionally narrates a long
+ * chain of titled summaries ("Examining Result Handling", "Refining Result
+ * Rendering", …) without ever calling a tool, burning the whole budget on
+ * planning; at this many distinct titles it has almost certainly stalled. This
+ * is the over-planning shape {@link ThinkingLoopDetector} misses — those titles
+ * are stripped before its similarity analysis precisely because their wording
+ * keeps changing, so a genuinely-distinct planning runaway never trips it.
+ */
+export declare const GEMINI_HEADER_RUNAWAY_THRESHOLD = 10;
+/**
+ * True when a single trimmed line is a Gemini reasoning-summary title: a markdown
+ * ATX heading (`## …`) or a whole-line bold / bold-italic run (`**Title**`,
+ * `***Title***`). Inline emphasis inside prose never matches — the bold run must
+ * span the entire line. Mirrors the title shapes {@link ThinkingLoopDetector}
+ * strips before similarity analysis.
+ */
+export declare function isReasoningSummaryHeader(line: string): boolean;
+/**
+ * Counts consecutive Gemini reasoning-summary headers across a streamed thinking
+ * block. {@link push} returns true exactly once — when the running header count
+ * first reaches {@link GEMINI_HEADER_RUNAWAY_THRESHOLD} — and the caller then
+ * interrupts the stream and reminds the model to issue a tool call. Paragraph
+ * lines between titles do NOT reset the run (Gemini emits header + paragraph per
+ * thought, so the run IS the number of summaries); leaving the reasoning channel
+ * does, via {@link reset} on a new thinking block / prose / tool call.
+ */
+export declare class GeminiHeaderRunDetector {
+    #private;
+    /** Feed a thinking delta. Returns true the first time the run hits the threshold. */
+    push(delta: string): boolean;
+    /** Number of summary titles counted in the current run (for the reminder/log). */
+    get count(): number;
+    /** Re-arm for a fresh reasoning block: clears the buffer, count, and latch. */
+    reset(): void;
+}
 /**
  * Wrap a provider stream with the loop guard. `controller` is the guard's own
  * abort handle: aborting it (after wiring it into the provider's signal via

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.1.23",
+	"version": "16.2.1",
 	"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.0",
-		"@oh-my-pi/pi-catalog": "16.1.23",
-		"@oh-my-pi/pi-utils": "16.1.23",
-		"@oh-my-pi/pi-wire": "16.1.23",
+		"@oh-my-pi/pi-catalog": "16.2.1",
+		"@oh-my-pi/pi-utils": "16.2.1",
+		"@oh-my-pi/pi-wire": "16.2.1",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/api-registry.ts

@@ -27,6 +27,7 @@ const BUILTIN_API_IDS = [
 	"google-vertex",
 	"ollama-chat",
 	"cursor-agent",
+	"gitlab-duo-agent",
 	"devin-agent",
 ] as const satisfies readonly KnownApi[];