@oh-my-pi/pi-ai 16.1.22 → 16.2.0

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 ## [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
+
+- Added a third streaming thinking-loop detection heuristic to catch "progress-lexicon stalls" where models endlessly reshuffle motivational filler without introducing new vocabulary or concrete technical references
+- Added branded wordmark and logo animation to authentication flow
+- Added a third streaming thinking-loop detection shape — a *progress-lexicon stall* — alongside verbatim tail repetition and near-duplicate (trigram) segments. It catches reasoning-summarizer loops that reshuffle the same motivational filler ("just doing it, pushing ahead, maintaining momentum") into fresh word order every paragraph: word-trigrams never cluster, but a run of substantial segments that recycle the recent vocabulary and introduce no *new* concrete reference (path / identifier / code-span) trips the guard. Summarizer title/heading lines (`**Bold Title**`, `## Heading`) are stripped before analysis so their ever-changing wording cannot mask the stall by inflating novelty. Calibrated against 537k real non-Gemini reasoning blocks (zero false positives at novelty floor 0.2 / run length 8; the real loop sustains runs of 10+).
+- Added CoreWeave Serverless Inference provider login support via `COREWEAVE_API_KEY` and `WANDB_API_KEY` fallback.
+
+### Changed
+
+- Redesigned the OAuth callback page (`oauth.html`) to match the oh-my-pi web brand language: OKLCH purple-tinted dark neutrals, magenta→iris→cyan brand gradient on the wordmark, frosted-glass card over an ascii grid backdrop, and a colored status halo around the success/error icon. All assets are inlined; the `__OAUTH_STATE__` injection contract and success/error JS logic are unchanged.
+
+### Fixed
+
+- Fixed local llama.cpp (and any local OpenAI-compatible server rendering the Qwen3.6+ chat template) re-processing the full prompt every new user message even with `replayReasoningContent` enabled (#3541 follow-up to #3528). Sending `reasoning_content` alone wasn't enough: Qwen3's chat template strips `<think>...</think>` from any assistant turn whose index is `<= last_query_index`, so the moment a new user message (the user's next prompt, or the auto-learn capture-at-stop nudge) lands, every prior assistant turn becomes "older" and is re-rendered without the `<think>` block — diverging from the generation tokens still in the slot's KV cache. The chat-completions encoder now emits `preserve_thinking: true` for Qwen thinking dialects on local servers, route-split the same way the existing `enable_thinking` emission is: the `qwen` dialect rides the top-level field (llama.cpp's `--jinja` hook and Alibaba Cloud Model Studio's compatible-mode), the `qwen-chat-template` dialect (NVIDIA NIM, vLLM/SGLang's chat-template-kwargs path) rides only `chat_template_kwargs.preserve_thinking` because NIM's request schema is `additionalProperties: false` and rejects unknown top-level fields (#2299). The emission is hoisted above the `reasoning.enabled` gate so it fires for THREE cases the original gating missed: (1) runtime-discovered local Qwen models that ship with `reasoning: false` because the upstream `/v1/models` doesn't advertise the capability (same gotcha #3532 fixed for `replayReasoningContent`), (2) caller-disabled reasoning (`/think off`) — the kwarg is a history-rendering knob, not a per-turn thinking switch, and the slot still holds `<think>` tokens from earlier turns, and (3) forced-tool-choice / DeepSeek-style auto-disable. Qwen3.6+ then renders `<think>...</think>` for every assistant turn regardless of position, and the next-turn render matches the cached generation tokens. ([#3541](https://github.com/can1357/oh-my-pi/issues/3541))
+
 ## [16.1.22] - 2026-06-26
 
 ### Fixed

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/providers/openai-shared.d.ts

@@ -194,8 +194,10 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
         keep?: "all";
     };
     enable_thinking?: boolean;
+    preserve_thinking?: boolean;
     chat_template_kwargs?: {
-        enable_thinking: boolean;
+        enable_thinking?: boolean;
+        preserve_thinking?: boolean;
     };
     reasoning?: {
         effort?: string;

package/dist/types/registry/api-key-login.d.ts

@@ -22,6 +22,7 @@ type ModelsEndpointValidation = {
     kind: "models-endpoint";
     provider: string;
     modelsUrl: string;
+    headers?: Record<string, string> | (() => Record<string, string> | undefined);
 };
 export type ApiKeyLoginConfig = {
     /** Display name used in error messages, e.g. "Cerebras", "NanoGPT". */

package/dist/types/registry/api-key-validation.d.ts

@@ -19,6 +19,7 @@ type ModelListValidationOptions = {
     provider: string;
     apiKey: string;
     modelsUrl: string;
+    headers?: Record<string, string> | (() => Record<string, string> | undefined);
     signal?: AbortSignal;
     fetch?: FetchImpl;
 };

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

@@ -0,0 +1,7 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+export declare const loginCoreWeave: (options: import("./oauth").OAuthController) => Promise<string>;
+export declare const coreWeaveProvider: {
+    readonly id: "coreweave";
+    readonly name: "CoreWeave Serverless Inference";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

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

@@ -37,6 +37,10 @@ declare const ALL: ({
     readonly id: "cloudflare-ai-gateway";
     readonly name: "Cloudflare AI Gateway";
     readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "coreweave";
+    readonly name: "CoreWeave Serverless Inference";
+    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "cursor";
     readonly name: "Cursor (Claude, GPT, etc.)";
@@ -67,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?: {