jeopi-ai 16.2.13

package/dist/types/providers/aws-sigv4.d.ts

@@ -0,0 +1,55 @@
+/**
+ * AWS Signature V4 signing for HTTP requests. WebCrypto-only — no node:crypto.
+ *
+ * Matches `@smithy/signature-v4` for our usage: header-based signing with a
+ * full SHA-256 payload hash (Bedrock requires `applyChecksum: true`).
+ *
+ * Returns the set of headers to attach to the request:
+ *  - `host`
+ *  - `x-amz-date`
+ *  - `x-amz-content-sha256`
+ *  - `x-amz-security-token` (only when credentials carry a sessionToken)
+ *  - `authorization`
+ */
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+export interface SignParams {
+    method: string;
+    /** Hostname only — used to build the `host` header and the canonical request. */
+    host: string;
+    /** URI path component, e.g. `/model/anthropic.claude/converse-stream`. */
+    path: string;
+    /** Optional pre-built query string (without leading `?`). */
+    query?: string;
+    /** Extra headers to sign in addition to `host`/`x-amz-*`. Names are case-insensitive. */
+    headers?: Record<string, string>;
+    body: Uint8Array;
+    region: string;
+    service: string;
+    credentials: AwsCredentials;
+    /** Override clock for deterministic tests. */
+    date?: Date;
+}
+export declare function toHex(bytes: Uint8Array): string;
+export declare function sha256(data: Uint8Array | string): Promise<Uint8Array>;
+export declare function sha256Hex(data: Uint8Array | string): Promise<string>;
+/**
+ * Derive a signing key: HMAC chain `kSecret → kDate → kRegion → kService → kSigning`.
+ */
+export declare function getSigningKey(secretAccessKey: string, shortDate: string, region: string, service: string): Promise<Uint8Array>;
+/** `YYYYMMDDTHHMMSSZ` + 8-char `YYYYMMDD`. */
+export declare function formatAmzDate(d: Date): {
+    longDate: string;
+    shortDate: string;
+};
+export interface SignedHeaders {
+    host: string;
+    "x-amz-date": string;
+    "x-amz-content-sha256": string;
+    authorization: string;
+    "x-amz-security-token"?: string;
+}
+export declare function signRequest(params: SignParams): Promise<SignedHeaders>;

package/dist/types/providers/azure-openai-responses.d.ts

@@ -0,0 +1,16 @@
+import type { ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types";
+export { parseAzureDeploymentNameMap } from "./openai-shared";
+export interface AzureOpenAIResponsesOptions extends StreamOptions {
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    azureApiVersion?: string;
+    azureResourceName?: string;
+    azureBaseUrl?: string;
+    azureDeploymentName?: string;
+    toolChoice?: ToolChoice;
+    serviceTier?: ServiceTier;
+}
+/**
+ * Generate function for Azure OpenAI Responses API
+ */
+export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses">;

package/dist/types/providers/cursor.d.ts

@@ -0,0 +1,91 @@
+import { type JsonValue } from "@bufbuild/protobuf";
+import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, TextContent, ThinkingContent, ToolCall, ToolResultMessage } from "../types";
+import { kStreamingBlockIndex, kStreamingBlockKind, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+export declare const CURSOR_API_URL = "https://api2.cursor.sh";
+export declare const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+export interface CursorOptions extends StreamOptions {
+    customSystemPrompt?: string;
+    conversationId?: string;
+    execHandlers?: CursorExecHandlers;
+    onToolResult?: CursorToolResultHandler;
+}
+export declare const streamCursor: StreamFunction<"cursor-agent">;
+export type ToolCallState = ToolCall & {
+    [kStreamingBlockIndex]: number;
+    [kStreamingPartialJson]?: string;
+    [kStreamingLastParseLen]?: number;
+    [kStreamingBlockKind]: "mcp" | "todo";
+};
+export interface BlockState {
+    currentTextBlock: (TextContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null;
+    currentThinkingBlock: (ThinkingContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null;
+    currentToolCall: ToolCallState | null;
+    firstTokenTime: number | undefined;
+    setTextBlock: (b: (TextContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null) => void;
+    setThinkingBlock: (b: (ThinkingContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null) => void;
+    setToolCall: (t: ToolCallState | null) => void;
+    setFirstTokenTime: () => void;
+}
+export interface UsageState {
+    sawTokenDelta: boolean;
+}
+/** Exported for tests: verifies handler is invoked with correct `this` when passed as bound. */
+export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult): Promise<{
+    execResult: TResult;
+    toolResult?: ToolResultMessage;
+}>;
+/**
+ * Merge the decoded completion-frame `McpArgs` map into the args assembled
+ * from streamed `args_text_delta` snapshots.
+ *
+ * The completion frame is authoritative for the scalars it carries — but it
+ * can omit oversized parameters entirely and can downgrade a structured value
+ * to its raw string fallback when `decodeMcpArgValue` cannot parse it as
+ * JSON. Overwriting the streamed args wholesale therefore loses data (e.g.
+ * the task tool's `tasks` array on multi-subagent dispatches, issue #2615).
+ *
+ * Rules per key:
+ * - completion key absent  → keep the streamed value.
+ * - completion is a string while the streamed value is structured (object or
+ *   array) → keep the streamed value (the completion frame downgraded it).
+ * - otherwise               → completion wins.
+ */
+export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unknown> | undefined, completion: Record<string, unknown> | undefined): Record<string, unknown>;
+/** Exported for tests: drives one Cursor interaction update through the streaming state machine. */
+export declare function processInteractionUpdate(update: any, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, usageState: UsageState): void;
+/**
+ * Build `ConversationStateStructure.rootPromptMessagesJson` blob IDs for the
+ * system prompt plus prior conversation history, as JSON blobs matching
+ * Cursor's internal Vercel-AI-SDK-shaped message format.
+ *
+ * Cursor's server uses `rootPromptMessagesJson` (not `turns[]`) to build the
+ * actual model prompt. `turns[]` is UI/display metadata. Without populating
+ * this field, multi-turn conversations lose prior context — the model sees
+ * only an empty placeholder where historical user turns should be.
+ * The active user message is excluded because it is sent in the action.
+ */
+/**
+ * Build one Cursor system-message JSON blob per ordered system prompt. Emitting separate blobs
+ * (rather than a single `\n\n`-joined string) lets Cursor's blob cache hit independently per
+ * entry: changing only the last prompt does not invalidate earlier blob ids, so the prefix
+ * up to the changed prompt remains cached on the server side.
+ *
+ * When no system prompts are provided, returns a single default greeting so we never emit
+ * an empty `rootPromptMessagesJson` head.
+ */
+export declare function buildCursorSystemPromptJsons(systemPrompt: readonly string[] | undefined): string[];
+/** Exported for tests: decodes Cursor history blobs built from conversation messages. */
+export declare function buildCursorHistoryForTest(messages: Message[], activeUserMessageIndex?: number): {
+    rootPromptMessagesJson: unknown[];
+    turnUserMessagesJson: JsonValue[];
+    turnStepMessagesJson: JsonValue[][];
+};

package/dist/types/providers/devin.d.ts

@@ -0,0 +1,12 @@
+import type { StreamFunction, StreamOptions } from "../types";
+/** Base host for Codeium/Windsurf's Cascade chat API (Connect protocol over HTTP/1.1). */
+export declare const DEVIN_API_URL = "https://server.codeium.com";
+export interface DevinOptions extends StreamOptions {
+    /** Cascade conversation id; reused as `cascade_id` so the server threads turns. */
+    conversationId?: string;
+    /** Falls back to `cascade_id` when no `conversationId` is supplied. */
+    sessionId?: string;
+    /** Wire model uid selected after thinking-effort routing. */
+    chatModelUid?: string;
+}
+export declare const streamDevin: StreamFunction<"devin-agent">;

package/dist/types/providers/error-message.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Model } from "../types";
+export declare function createProviderErrorMessage(model: Model<Api>, err: unknown): {
+    role: "assistant";
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    api: Api;
+    provider: string;
+    model: string;
+    usage: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        totalTokens: number;
+        cost: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+            total: number;
+        };
+    };
+    stopReason: "error";
+    timestamp: number;
+};

package/dist/types/providers/github-copilot-headers.d.ts

@@ -0,0 +1,40 @@
+import type { Message } from "../types";
+/**
+ * Infer whether the current request to Copilot is user-initiated or agent-initiated.
+ * Accepts `unknown[]` because providers may pass pre-converted message shapes.
+ */
+export type CopilotInitiator = "user" | "agent";
+export type CopilotPremiumRequests = number;
+export type CopilotDynamicHeaders = {
+    headers: Record<string, string>;
+    initiator: CopilotInitiator;
+    premiumRequests: CopilotPremiumRequests;
+};
+export declare function resolveGitHubCopilotBaseUrl(baseUrl: string | undefined, apiKey: string | undefined): string | undefined;
+export declare function inferCopilotInitiator(messages: unknown[]): CopilotInitiator;
+/** Check whether any message in the conversation contains image content. */
+export declare function hasCopilotVisionInput(messages: Message[]): boolean;
+/**
+ * Resolve an explicitly configured Copilot initiator header, if present.
+ * Handles case-insensitive X-Initiator keys and returns the last valid value.
+ */
+export declare function getCopilotInitiatorOverride(headers: Record<string, string> | undefined): CopilotInitiator | undefined;
+export type CopilotPlanTier = "free" | "paid";
+export declare function getCopilotPremiumMultiplier(premiumMultiplier: number | undefined, planTier?: string): number;
+export declare function getCopilotPremiumRequests(params: {
+    initiator: CopilotInitiator;
+    premiumMultiplier?: number;
+    planTier?: string;
+}): CopilotPremiumRequests;
+/**
+ * Build dynamic Copilot headers that vary per-request.
+ * Static headers (User-Agent, Editor-Version, etc.) come from model.headers.
+ */
+export declare function buildCopilotDynamicHeaders(params: {
+    messages: unknown[];
+    hasImages: boolean;
+    premiumMultiplier?: number;
+    headers?: Record<string, string>;
+    initiatorOverride?: CopilotInitiator;
+    planTier?: string;
+}): CopilotDynamicHeaders;

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

@@ -0,0 +1,254 @@
+import { type GitLabDuoWorkflowNamespaceSelection } from "jeopi-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/gitlab-duo.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Context, Model, SimpleStreamOptions } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+type GitLabProvider = "anthropic" | "openai";
+type GitLabOpenAIApiType = "chat" | "responses";
+export type GitLabModelMapping = {
+    provider: GitLabProvider;
+    model: string;
+    openaiApiType?: GitLabOpenAIApiType;
+    name: string;
+    reasoning: boolean;
+    input: ("text" | "image")[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+};
+export declare const MODEL_MAPPINGS: Record<string, GitLabModelMapping>;
+export declare function getModelMapping(modelId: string): GitLabModelMapping | undefined;
+export declare function getGitLabDuoModels(): Model<Api>[];
+export declare function clearGitLabDuoDirectAccessCache(): void;
+export declare function isGitLabDuoModel(model: Model<Api>): boolean;
+export declare function streamGitLabDuo(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+export {};

package/dist/types/providers/google-auth.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Application Default Credentials (ADC) resolution for Vertex AI.
+ *
+ * Replaces `google-auth-library` with a direct WebCrypto + REST implementation.
+ * Sources, in priority order:
+ *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
+ *     or `type: "authorized_user"` (refresh-token exchange).
+ *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
+ *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
+ *
+ * Tokens are cached per source key and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` before expiry
+ * (default 60s). Concurrent callers waiting on a refresh share the same in-flight promise.
+ */
+import type { FetchImpl } from "../types";
+/**
+ * Returns a Bearer access token suitable for the `Authorization` header on Vertex AI calls.
+ * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.
+ */
+export declare function getVertexAccessToken(options?: {
+    signal?: AbortSignal;
+    fetch?: FetchImpl;
+}): Promise<string>;
+/** Test seam: clears every cached token. */
+export declare function __resetVertexTokenCache(): void;
+/**
+ * Sync best-effort probe for a usable Vertex bearer credential source — an explicit access-token
+ * env var, `GOOGLE_APPLICATION_CREDENTIALS`, a user ADC file, or a GCP runtime whose metadata
+ * server can mint ADC (GCE/Cloud Run/App Engine/Functions). Lets callers prefer the bearer
+ * Interactions transport only when ADC is actually reachable, without paying the async
+ * metadata-probe cost for API-key-only setups.
+ */
+export declare function hasVertexBearerCredentialsHint(): boolean;