@vib-rato/ai 0.16.0

package/dist/types/utils/event-stream.d.ts

@@ -0,0 +1,41 @@
+import type { AssistantMessage, AssistantMessageEvent } from "../types";
+export declare class EventStream<T, R = T> implements AsyncIterable<T> {
+    #private;
+    waiting: Array<{
+        resolve: (value: IteratorResult<T>) => void;
+        reject: (err: unknown) => void;
+    }>;
+    done: boolean;
+    finalResultPromise: Promise<R>;
+    resolveFinalResult: (result: R) => void;
+    rejectFinalResult: (err: unknown) => void;
+    isComplete: (event: T) => boolean;
+    extractResult: (event: T) => R;
+    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R, onConsumerClose?: () => void);
+    /**
+     * Read-only snapshot of the not-yet-consumed events. Always a fresh copy:
+     * external code can never mutate internal queue state or observe head-index
+     * tombstones or private consumer-drain sentinels, so the deque cannot desynchronize.
+     */
+    get queue(): T[];
+    /** Read-only test seam for outstanding consumer-drain waiters. */
+    get pendingConsumerDrainCountForTests(): number;
+    /** Whether an async iterator is currently consuming this stream. */
+    get hasActiveConsumer(): boolean;
+    push(event: T): void;
+    deliver(event: T): void;
+    /**
+     * Resolves after every event enqueued before this call has been yielded and
+     * the consumer asks the iterator for its next node. The private sentinel is
+     * never exposed through the async iterator.
+     */
+    waitForConsumerDrain(signal: AbortSignal): Promise<void>;
+    end(result?: R): void;
+    endWaiting(): void;
+    fail(err: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    result(): Promise<R>;
+}
+export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+    constructor(onConsumerClose?: () => void);
+}

package/dist/types/utils/fallback-transport.d.ts

@@ -0,0 +1,110 @@
+export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "unknown" | "other";
+/**
+ * Refinement of an `auth` trigger.
+ *
+ * The transport deliberately collapses HTTP 401 and 403 into a single `auth`
+ * class, but the two demand opposite handling: a credential problem may be
+ * recoverable by trying a different stored credential, whereas a plain
+ * `forbidden` is an authorization or configuration defect that rotation would
+ * only hide — it would cycle and block every otherwise-healthy credential.
+ *
+ * This is a refinement rather than a new {@link FallbackTriggerClass} member so
+ * every existing `trigger.class === "auth"` consumer keeps compiling and keeps
+ * its current behavior until it explicitly opts into the distinction.
+ */
+export type AuthDisposition = "credential" | "forbidden";
+export interface FallbackTrigger {
+    class: FallbackTriggerClass;
+    retryAfterMs?: number;
+    /** Present only when `class === "auth"`. */
+    authDisposition?: AuthDisposition;
+}
+/** Stable code for streams that time out before producing semantic progress. */
+export declare const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
+/** Stable code for a nominally successful response with no content or token usage. */
+export declare const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
+ * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the
+ * code itself is the only structured evidence of the failure and must survive
+ * the existence gate below. It is always compared case-sensitively.
+ */
+export declare const SERVER_OVERLOADED_PROVIDER_CODE = "server_is_overloaded";
+export type TransportHeaders = Headers | Record<string, string | undefined>;
+/**
+ * Structured facts from an upstream HTTP or transport failure. Retry decisions
+ * must use these facts rather than provider- or application-owned error text.
+ *
+ * `headers` is always a plain record limited to the retained retry-signal
+ * entries: facts travel on persisted `AssistantMessage`s and through
+ * `structuredClone` snapshots (managed fallback attempt staging), so they must
+ * never carry a live `Headers` instance — cloning one throws `DataCloneError`
+ * ("The object can not be cloned.") and masks the real provider failure.
+ */
+export interface TransportFailureFacts {
+    kind: "transport";
+    status?: number;
+    /** Canonical provider error code used for fallback classification. */
+    providerCode?: string;
+    /** Anthropic's typed `error.type`, preserved separately at the transport boundary. */
+    anthropicErrorType?: string;
+    /** OpenAI's typed `error.code`, preserved separately at the transport boundary. */
+    openaiErrorCode?: string;
+    headers?: Record<string, string>;
+    /** Safe request-size observation for retry amplification policy. Never contains body content. */
+    requestBytes?: number;
+    /** Time spent waiting for the first semantic stream event on the failed request. */
+    firstEventElapsedMs?: number;
+    /** Configured first-event window before any bounded endpoint grace. */
+    firstEventTimeoutMs?: number;
+    /** Coarse endpoint class; deliberately excludes host, path, credentials, and query parameters. */
+    endpointClass?: "canonical" | "custom";
+    /** Provider-supplied ceiling for total attempts, including the initial request. */
+    retryMaxAttempts?: number;
+}
+/** Opaque per-invocation marker required by managed fallback transport calls. */
+export interface FallbackAttemptToken {
+    readonly modelKey: string;
+    readonly attemptId: string | number;
+}
+/**
+ * Marks a single outer fallback invocation. Accounting belongs to the caller;
+ * this token prevents managed transport calls from silently bypassing it.
+ */
+export declare function beginAttempt(modelKey: string, attemptId: string | number): FallbackAttemptToken;
+export declare function assertManagedAttempt(options: {
+    fallbackManaged?: boolean;
+    fallbackAttempt?: FallbackAttemptToken;
+} | undefined): void;
+/**
+ * Compatibility input for callers that have not yet wrapped their HTTP facts
+ * in the discriminated form. Only its structured fields are inspected.
+ */
+export interface FallbackTriggerInput {
+    status?: number;
+    providerCode?: string;
+    code?: string;
+    headers?: TransportHeaders;
+    response?: {
+        status?: number;
+        headers?: TransportHeaders;
+    };
+    error?: {
+        code?: string;
+        type?: string;
+    };
+}
+/** Extracts only explicit HTTP/transport metadata; it never parses error text. */
+export declare function transportFailureFacts(error: unknown, capturedResponse?: {
+    status?: number;
+    headers?: TransportHeaders;
+}): TransportFailureFacts | undefined;
+/** Classifies only typed upstream transport facts without consuming response bodies. */
+export declare function classifyFallbackTrigger(errorOrFacts: TransportFailureFacts | FallbackTriggerInput | unknown): FallbackTrigger;
+/**
+ * True when a failure is an `auth` failure that must NOT rotate credentials.
+ *
+ * Callers that mutate credential state on auth failures should consult this
+ * first so a plain `forbidden` cannot block otherwise-healthy credentials.
+ */
+export declare function isForbiddenAuthFailure(errorOrFacts: TransportFailureFacts | FallbackTriggerInput | unknown): boolean;

package/dist/types/utils/fireworks-model-id.d.ts

@@ -0,0 +1,10 @@
+export declare function toFireworksPublicModelId(modelId: string): string;
+export declare function toFireworksWireModelId(modelId: string): string;
+/**
+ * Fire Pass exposes its Kimi K2.6 Turbo subscription through a dedicated router
+ * endpoint at `accounts/fireworks/routers/<id>` rather than the `models/` namespace.
+ * We keep a friendly public id (e.g. `kimi-k2.6-turbo`) in the catalog and translate
+ * to the wire form (`accounts/fireworks/routers/kimi-k2p6-turbo`) at request time.
+ */
+export declare function toFirepassPublicModelId(modelId: string): string;
+export declare function toFirepassWireModelId(modelId: string): string;

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

@@ -0,0 +1,11 @@
+/**
+ * Whether Anthropic requests run in Foundry gateway mode.
+ *
+ * Resolved from trusted environment sources only. Enabling Foundry switches the
+ * request base URL and injects TLS client material, so whatever can set this
+ * redirects authenticated traffic. `$env` merges the caller's `cwd/.env`, so
+ * reading it there would let repository content flip the mode; resolve it the
+ * same way the credentials themselves are (launching shell plus Vibrato/user-owned
+ * `.env` files, never the project `.env`).
+ */
+export declare function isFoundryEnabled(): boolean;

package/dist/types/utils/h2-fetch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Patch `globalThis.fetch` to advertise HTTP/2 in TLS ALPN, with transparent
+ * HTTP/1.1 fallback when the server doesn't negotiate `h2`.
+ *
+ * Bun's HTTP/2 client is gated on `BUN_FEATURE_FLAG_EXPERIMENTAL_HTTP2_CLIENT`,
+ * read by the native runtime before any JS executes; assigning to
+ * `process.env` from inside JS is a no-op. Per-request `protocol: "http2"`
+ * activates h2 over TLS ALPN and rejects with `error.code === "HTTP2Unsupported"`
+ * if the server picks anything else, so we catch and retry without the hint.
+ *
+ * Some HTTPS endpoints (e.g. corporate API gateways behind reverse proxies)
+ * advertise h2 via ALPN but then refuse or reset the connection at the HTTP/2
+ * framing layer. Bun surfaces these as `ConnectionRefused`, `ConnectionReset`,
+ * or `ConnectionClosed` rather than `HTTP2Unsupported`, so we treat those
+ * codes as h2-fallback triggers as well.
+ *
+ * Bun negotiates h2 via ALPN over TLS only (no h2c), so plain `http://` URLs
+ * skip the attempt entirely — avoids the throw/retry round-trip for localhost.
+ *
+ * Idempotent.
+ */
+export declare function installH2Fetch(): void;

package/dist/types/utils/http-inspector.d.ts

@@ -0,0 +1,59 @@
+export type RawHttpRequestDump = {
+    provider: string;
+    api: string;
+    model: string;
+    method?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    diagnostics?: Record<string, unknown>;
+};
+export type CapturedHttpErrorResponse = {
+    status: number;
+    headers?: Headers;
+    bodyText?: string;
+    bodyJson?: unknown;
+};
+/** Whether `message` (from a 400 response) signals an unavailable/unknown model. */
+export declare function isModelUnavailableError(message: string, error: unknown): boolean;
+/** Actionable guidance for selecting an available model/provider. */
+export declare function formatModelUnavailableGuidance(dump: RawHttpRequestDump | undefined): string;
+/** Directory holding the retained HTTP 400 dumps. */
+export declare function httpRequestDumpDir(): string;
+/**
+ * Drop the oldest dumps beyond the cap. Best-effort: diagnostics must never turn
+ * a request failure into a second failure, so every step swallows its error.
+ *
+ * File names are `${Date.now()}-${hash}.json`, so a lexical sort is chronological
+ * for the millisecond timestamps this writer produces.
+ */
+export declare function pruneHttpRequestDumps(dir?: string): Promise<number>;
+export declare function appendRawHttpRequestDumpFor400(message: string, error: unknown, dump: RawHttpRequestDump | undefined): Promise<string>;
+/**
+ * Name the failed connection when the request never produced an HTTP status.
+ *
+ * Bun raises DNS and socket failures as a bare `Error` whose message is a
+ * standalone hint ("Was there a typo in the url or port?", "Unable to connect.
+ * Is the computer able to access the url?") while the actionable facts live on
+ * `code` and `path`. Those properties are dropped when only `message` reaches
+ * the assistant message, so a provider outage, a local DNS failure, and a
+ * mistyped custom base URL all render as the same context-free sentence.
+ * Appending the code and the target URL tells the user which host failed and
+ * whether the fault is theirs.
+ */
+export declare function appendTransportFailureContext(message: string, error: unknown, rawRequestDump: RawHttpRequestDump | undefined): string;
+export declare function finalizeErrorMessage(error: unknown, rawRequestDump: RawHttpRequestDump | undefined, capturedErrorResponse?: CapturedHttpErrorResponse): Promise<string>;
+export declare function withHttpStatus(error: unknown, status: number): Error;
+/**
+ * Rewrite error message for GitHub Copilot request failures.
+ * Must run AFTER finalizeErrorMessage since it replaces the message entirely.
+ *
+ * 400 `model_not_supported` = Copilot routing rollout gap for our OAuth client.
+ *        A preview model (gpt-5.3-OpenAI code backend, gpt-5.4*, ...) flaps between 200 and
+ *        400 because only some of Copilot's backends have the model. After the
+ *        in-request retry exhausts, surface guidance rather than the raw error.
+ * 401 = token invalid/expired → credential removal is safe, prompt re-login.
+ * 403 = token valid but access denied (plan, model policy, org restriction) →
+ *       do NOT reuse the auth-failed string (which triggers credential removal).
+ */
+export declare function rewriteCopilotError(errorMessage: string, error: unknown, provider: string): string;

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

@@ -0,0 +1,122 @@
+export declare function getProviderStreamIdleTimeoutFallbackMs(provider: string): number | undefined;
+export declare function isGrokModelId(modelId: string | undefined): boolean;
+export declare function getProviderFirstEventTimeoutFallbackMs(provider: string): number | undefined;
+/**
+ * Returns the idle timeout used for provider streaming transports.
+ *
+ * `VIB_OPENAI_STREAM_IDLE_TIMEOUT_MS` is honored first; `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` is a backward-compatible alias.
+ * Set `PI_STREAM_IDLE_TIMEOUT_MS=0` to disable the watchdog.
+ *
+ * Providers that legitimately stream much slower than the global default can pass
+ * `fallbackMs` to widen the floor used when neither env var nor caller option is set.
+ * Caller options still take precedence; env overrides still trump the fallback.
+ */
+export declare function getStreamIdleTimeoutMs(fallbackMs?: number): number | undefined;
+/**
+ * Returns the idle timeout used for OpenAI-family streaming transports.
+ *
+ * Honors `VIB_OPENAI_STREAM_IDLE_TIMEOUT_MS` first (`PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` is the legacy alias). Set `=0` to disable.
+ * When `provider` is given, long-reasoning hosts (xAI Grok and Grok Build) use that floor instead of the 120s default.
+ * Grok models reached through other OpenAI-compatible hosts (`openrouter/x-ai/grok-*`, kilo, litellm, …) get the
+ * same floor keyed on the model id, because long-reasoning silence is a property of the model (#4797).
+ */
+export declare function getOpenAIStreamIdleTimeoutMs(provider?: string, modelId?: string): number | undefined;
+/**
+ * Returns the timeout used while waiting for the first stream event.
+ * The first token can legitimately take longer than later inter-event gaps,
+ * so the default never undershoots the steady-state idle timeout.
+ *
+ * Set `PI_STREAM_FIRST_EVENT_TIMEOUT_MS=0` to disable the watchdog.
+ *
+ * Providers whose first response can legitimately take longer (heavy reasoning,
+ * slow cold-start proxies) can pass `fallbackMs` to widen the floor used when
+ * neither env var nor caller option is set. Caller options still take precedence;
+ * env overrides still trump the fallback.
+ */
+export declare function getStreamFirstEventTimeoutMs(idleTimeoutMs?: number, fallbackMs?: number): number | undefined;
+/**
+ * Resolves the OpenAI SDK client `timeout` so stalled-before-headers requests are
+ * bounded by the same first-event window the transport watchdog uses after
+ * `create()` returns. Without this, providers that only arm
+ * `iterateWithIdleTimeout` post-setup can wait the full SDK default (10 minutes
+ * per attempt) before any provider-owned watchdog exists.
+ *
+ * - Explicit `0` disables the request timeout (the SDK treats `timeout: 0` as an
+ *   immediate failure, so callers that disable the first-event watchdog must not
+ *   pass a timeout).
+ * - Providers with a first-event fallback (Alibaba, Kimi) honor an explicit
+ *   nonzero override as-is, even when shorter than the fallback.
+ * - Other providers floor an explicit override at the env/default first-event
+ *   window so a short post-connect first-event budget cannot kill legitimate
+ *   slow setup.
+ */
+export declare function resolveOpenAISdkRequestTimeoutMs(provider: string, streamFirstEventTimeoutOverride?: number, modelId?: string): number | undefined;
+/**
+ * Resolves the Anthropic SDK client `timeout` so stalled-before-headers requests
+ * are bounded. The Anthropic first-event watchdog deliberately arms only once
+ * response headers have arrived (setup latency must not consume the first-event
+ * budget), which left the connect/headers phase governed solely by the SDK
+ * default of 10 minutes per attempt — multiplied by SDK-internal retries, a
+ * connection that silently died right after a completed tool call could spin
+ * with no user-visible error for the better part of an hour.
+ *
+ * - Explicit `0` disables the request timeout, matching a disabled first-event
+ *   watchdog.
+ * - An explicit nonzero override is floored at the env/default first-event
+ *   window (which itself never undershoots the provider idle window) so a short
+ *   post-connect first-event budget cannot kill legitimate slow setup.
+ */
+export declare function resolveAnthropicSdkRequestTimeoutMs(provider: string, streamFirstEventTimeoutOverride?: number, streamIdleTimeoutOverride?: number): number | undefined;
+export type Watchdog = NodeJS.Timeout | undefined;
+export interface FirstEventTimeoutFacts {
+    requestBytes?: number;
+    firstEventElapsedMs?: number;
+    firstEventTimeoutMs?: number;
+    endpointClass?: "canonical" | "custom";
+    retryMaxAttempts?: number;
+}
+export declare class FirstEventTimeoutError extends Error {
+    readonly providerCode = "stream_first_event_timeout";
+    readonly requestBytes?: number;
+    readonly firstEventElapsedMs?: number;
+    readonly firstEventTimeoutMs?: number;
+    readonly endpointClass?: "canonical" | "custom";
+    readonly retryMaxAttempts?: number;
+    constructor(message: string, facts?: FirstEventTimeoutFacts);
+}
+/**
+ * Starts a watchdog that aborts a request if no first stream event arrives in time.
+ * Call `markFirstEventReceived()` as soon as the first event is observed.
+ */
+export declare function createWatchdog(timeoutMs: number | undefined, onTimeout: () => void): Watchdog;
+export interface IdleTimeoutIteratorOptions {
+    watchdog?: Watchdog;
+    idleTimeoutMs?: number;
+    firstItemTimeoutMs?: number;
+    errorMessage: string;
+    firstItemErrorMessage?: string;
+    onIdle?: () => void;
+    onFirstItemTimeout?: () => void;
+    /**
+     * Optional semantic-progress predicate. Non-progress items are still yielded,
+     * but they do not reset the idle deadline. This prevents provider
+     * keepalive/no-op events from keeping a stalled tool call alive forever.
+     */
+    isProgressItem?: (item: unknown) => boolean;
+    /**
+     * Cancel iteration as soon as this signal aborts. Required for caller-driven
+     * cancellation (ESC) when the underlying transport does not surface signal
+     * aborts to the iterator (HTTP/2 proxies, native sockets, mocked fetch).
+     * Without this, the consumer sleeps on iterator.next() until the idle/first
+     * -event watchdog fires — observable as the issue #912 "Working… forever"
+     * symptom on the github-copilot provider.
+     */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Yields items from an async iterable while enforcing a maximum idle gap between items.
+ *
+ * The first item may use a shorter timeout so stuck requests can be aborted and retried
+ * before any user-visible content has streamed.
+ */
+export declare function iterateWithIdleTimeout<T>(iterable: AsyncIterable<T>, options: IdleTimeoutIteratorOptions): AsyncGenerator<T>;

package/dist/types/utils/json-parse.d.ts

@@ -0,0 +1,98 @@
+export interface UnicodeEscapePositionEvidence {
+    /** UTF-16 offset of the escape's leading backslash in the raw JSON. */
+    readonly offset: number;
+    /** Process-keyed tag of the encoded scalar; never the recoverable character. */
+    readonly scalarTag: string;
+    /** Process-keyed tag of the unambiguous array-index-free path; never raw field names. */
+    readonly pathTag: string;
+    /** Escapes in object keys are structural and can never be display-safe. */
+    readonly location: "key" | "value";
+    /** Ordinal of this string among values sharing the array-index-free path. */
+    readonly valueOrdinal: number;
+    /** UTF-16 offset of the decoded scalar inside that string value. */
+    readonly valueOffset: number;
+}
+export interface UnicodeEscapeEvidence {
+    readonly positions: readonly UnicodeEscapePositionEvidence[];
+    /** Total qualifying escapes observed, including positions omitted by the cap. */
+    readonly totalPositions: number;
+    /** More qualifying escapes existed than the bounded evidence can carry. */
+    readonly truncated: boolean;
+    /** The raw JSON could not be mapped exactly and unambiguously; validation must fail closed. */
+    readonly malformed: boolean;
+    /** Process-local HMAC binding the complete collector-produced envelope. */
+    readonly integrity: string;
+}
+interface UnicodeEscapeEvidenceTarget {
+    escapedNonAsciiArguments?: boolean;
+    escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;
+}
+/** Stable, payload-free identity for an unambiguous array-index-free argument path. */
+export declare function unicodeEscapePathTag(path: readonly string[]): string;
+/** Process-keyed scalar identity used without retaining recoverable argument text. */
+export declare function unicodeEscapeScalarTag(codePoint: number): string;
+/** Verify that an evidence envelope is complete and was produced in this process. */
+export declare function verifyUnicodeEscapeEvidence(evidence: UnicodeEscapeEvidence): boolean;
+export declare function repairJson(json: string): string;
+/**
+ * First unnecessary `\uXXXX` escape in a JSON document, or `undefined` when the
+ * document contains none.
+ *
+ * "Unnecessary" means the escape encodes a printable character JSON can carry
+ * literally, including ASCII. ASCII must remain observable because one mistyped
+ * nibble can move a non-ASCII escape into ASCII (`\u00b7` → `\u0077`). Control
+ * characters (< U+0020), DEL, and unpaired surrogates are excluded. A `\\uXXXX`
+ * sequence is a literal backslash followed by `u` — the
+ * intended source syntax when the model is writing code or a nested JSON
+ * document — and is skipped, which is why this scans the raw text with the same
+ * string/escape state machine as {@link repairJson} instead of using a regex.
+ *
+ * Models that spell text as hand-written hex instead of literal characters
+ * mistype the digits, and every mistyped nibble silently decodes to a different
+ * but perfectly valid character (`\uc7a5` vs `\uc7a4`). The resulting arguments
+ * parse cleanly and cannot be repaired after the fact, so the escape itself is
+ * the only observable evidence that the payload is untrustworthy.
+ */
+export declare function findUnnecessaryUnicodeEscape(json: string): string | undefined;
+/**
+ * Bounded raw-position/scalar evidence for every suspicious `\uXXXX` escape.
+ *
+ * Scalars and paths are carried only as process-keyed HMAC tags, so terminal
+ * validation can match them against decoded arguments without retaining
+ * recoverable characters, keys, or values in messages, diagnostics, or durable
+ * session artifacts. Array indices are
+ * intentionally omitted to preserve `questions.question`-style field matching.
+ */
+export declare function collectUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined;
+/**
+ * Return evidence only when decoded tool arguments are unsafe to execute.
+ *
+ * Valid JSON escapes and literal UTF-8 have the same canonical decoded value,
+ * including a valid scalar whose hex digits differ from what a caller intended:
+ * runtime syntax validation cannot infer author intent after decoding.
+ * Malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and
+ * unpaired UTF-16 surrogates keep the fail-closed path.
+ */
+export declare function collectUnsafeUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined;
+/** Attach unsafe raw evidence while preserving the existing call-level guard flag. */
+export declare function captureUnicodeEscapeEvidence(target: UnicodeEscapeEvidenceTarget, json: string): boolean;
+/** Attach evidence as transient, non-enumerable metadata excluded from serialization. */
+export declare function attachUnicodeEscapeEvidence(target: UnicodeEscapeEvidenceTarget, evidence: UnicodeEscapeEvidence): void;
+export declare function parseJsonWithRepair<T>(json: string): T;
+/**
+ * Attempts to parse potentially incomplete JSON during streaming.
+ * Always returns a valid object, even if the JSON is incomplete.
+ *
+ * @param partialJson The partial JSON string from streaming
+ * @returns Parsed object or empty object if parsing fails
+ */
+export declare function parseStreamingJson<T = Record<string, unknown>>(partialJson: string | undefined): T;
+/**
+ * Whether a string is a complete, well-formed JSON document (strict parse, no
+ * repair). Used to distinguish a tool-call argument blob that finished cleanly
+ * from one that was cut off mid-stream (truncation). An empty / whitespace-only
+ * string is treated as complete: a tool invoked with no arguments legitimately
+ * streams an empty buffer and must not be flagged as truncated.
+ */
+export declare function isCompleteJson(text: string | undefined): boolean;
+export {};

package/dist/types/utils/oauth/alibaba-token-plan.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Alibaba Token Plan login flow.
+ *
+ * Alibaba Token Plan provides OpenAI-compatible models via
+ * https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1.
+ *
+ * This is not OAuth - it's a simple API key flow:
+ * 1. Open browser to Alibaba Cloud Model Studio console
+ * 2. User copies their API key
+ * 3. User pastes the API key into the CLI
+ */
+import type { OAuthController } from "./types";
+/**
+ * Login to Alibaba Token Plan.
+ *
+ * Opens browser to API keys page, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export declare function loginAlibabaTokenPlan(options: OAuthController): Promise<string>;

package/dist/types/utils/oauth/anthropic.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Anthropic OAuth flow (Anthropic model Pro/Max)
+ */
+import { OAuthCallbackFlow } from "./callback-server";
+import type { OAuthController, OAuthCredentials } from "./types";
+/**
+ * Redirect target for the paste-a-code login. Anthropic renders the
+ * authorization code on this page instead of redirecting into this machine, so
+ * a vib running over SSH, in a container, or on a headless box can be paired
+ * from a browser that has no route back to `localhost:54545`.
+ *
+ * Deliberately a hard-coded constant rather than an env/config override: this
+ * is where the authorization code is delivered, so making it injectable would
+ * turn any writable environment into an auth-code exfiltration channel.
+ */
+export declare const ANTHROPIC_MANUAL_REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
+export interface AnthropicOAuthFlowOptions {
+    /**
+     * Pair by pasting the code Anthropic displays instead of waiting on a local
+     * `localhost:54545` callback. Use when the browser completing the login has
+     * no network route back to the machine running vib.
+     */
+    manualCode?: boolean;
+}
+export declare class AnthropicOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController, options?: AnthropicOAuthFlowOptions);
+    generateAuthUrl(state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string, state: string, redirectUri: string): Promise<OAuthCredentials>;
+}
+/**
+ * Login with Anthropic OAuth
+ */
+export declare function loginAnthropic(ctrl: OAuthController, options?: AnthropicOAuthFlowOptions): Promise<OAuthCredentials>;
+/**
+ * Refresh Anthropic OAuth token
+ */
+export declare function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials>;

package/dist/types/utils/oauth/api-key-login.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared factory for API-key-paste "login" flows.
+ *
+ * Several providers (Cerebras, Synthetic, Moonshot, Together, NanoGPT, ZenMux,
+ * Command Code GOAT)
+ * don't actually implement OAuth — they just ask the user to paste an API key,
+ * optionally validate it, and return the trimmed key.
+ */
+import type { OAuthController } from "./types";
+type ChatCompletionsValidation = {
+    kind: "chat-completions";
+    provider: string;
+    baseUrl: string;
+    model: string;
+    requireInferenceResponse?: boolean;
+};
+type ModelsEndpointValidation = {
+    kind: "models-endpoint";
+    provider: string;
+    modelsUrl: string;
+};
+export type ApiKeyLoginConfig = {
+    /** Display name used in error messages, e.g. "Cerebras", "NanoGPT". */
+    providerLabel: string;
+    /** URL opened in browser for the user to grab their key. */
+    authUrl: string;
+    /** Instructions shown with the onAuth callback. */
+    instructions: string;
+    /** Prompt message shown when asking for the key paste. */
+    promptMessage: string;
+    /** Placeholder string for the prompt (e.g. "sk-...", "csk-..."). */
+    placeholder: string;
+    /** Validation strategy, or `null` to skip validation. */
+    validation: ChatCompletionsValidation | ModelsEndpointValidation | null;
+    validationProgressMessage?: string;
+};
+export declare function createApiKeyLogin(config: ApiKeyLoginConfig): (options: OAuthController) => Promise<string>;
+export {};

package/dist/types/utils/oauth/api-key-validation.d.ts

@@ -0,0 +1,39 @@
+type OpenAICompatibleValidationOptions = {
+    provider: string;
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    signal?: AbortSignal;
+    fetch?: typeof globalThis.fetch;
+    requireInferenceResponse?: boolean;
+    timeoutMs?: number;
+};
+type ModelListValidationOptions = {
+    provider: string;
+    apiKey: string;
+    modelsUrl: string;
+    signal?: AbortSignal;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+};
+/**
+ * Validate an API key against an OpenAI-compatible chat completions endpoint.
+ *
+ * Performs a minimal request to verify credentials and endpoint access.
+ */
+export declare function validateOpenAICompatibleApiKey(options: OpenAICompatibleValidationOptions): Promise<void>;
+/**
+ * Validate a provider models endpoint's reachability and response shape.
+ *
+ * Useful for providers where access to specific models may vary by plan and
+ * should not block login; an available model list is not proof that an
+ * authenticated inference request will succeed for the supplied key.
+ *
+ * A 200 status alone is NOT accepted: a captive portal, misrouting proxy, or
+ * broken gateway can answer 200 with an HTML page or an empty JSON object.
+ * The body must parse as JSON and carry a recognizable model list before the
+ * endpoint is considered reachable. This catalog check is not proof that
+ * authenticated inference is entitled to use the supplied key.
+ */
+export declare function validateApiKeyAgainstModelsEndpoint(options: ModelListValidationOptions): Promise<void>;
+export {};

package/dist/types/utils/oauth/bizrouter.d.ts

@@ -0,0 +1 @@
+export declare const loginBizRouter: (options: import("./types").OAuthController) => Promise<string>;