@thinwrap/llm 1.0.0

package/dist/cjs/types/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error.types"), exports);
+__exportStar(require("./passthrough.type"), exports);
+__exportStar(require("./chat.types"), exports);
+__exportStar(require("./embeddings.types"), exports);
+__exportStar(require("./provider-id.enum"), exports);
+__exportStar(require("./config-map.type"), exports);
+__exportStar(require("./provider.interface"), exports);

package/dist/cjs/types/passthrough.type.d.ts

@@ -0,0 +1,15 @@
+export interface Passthrough {
+    /**
+     * Merged into the outbound request JSON body; overrides connector-built fields
+     * on key collision. Never transformed or validated — if you populate this from
+     * untrusted input, sanitize it yourself (you own the keys that reach the wire).
+     */
+    body?: Record<string, unknown>;
+    /** Merged into request headers. */
+    headers?: Record<string, string>;
+    /** Appended to the request URL query string. */
+    query?: Record<string, string>;
+}
+export type WithPassthrough<T> = T & {
+    _passthrough?: Passthrough;
+};

package/dist/cjs/types/passthrough.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/provider-id.enum.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Provider ids implemented so far — the 15 first-class OpenAI-compatible
+ * providers (one shared connector) plus native-adapter providers as they land
+ * (`anthropic`). Remaining natives (bedrock, gemini, vertex, cohere) are added
+ * when their adapters ship.
+ */
+export declare const LLM_PROVIDER_IDS: readonly ["openai", "azure-openai", "openrouter", "groq", "together", "fireworks", "deepseek", "xai", "mistral", "perplexity", "deepinfra", "cloudflare", "vllm", "ollama", "lmstudio", "anthropic", "bedrock", "gemini"];
+export type LlmProviderId = (typeof LLM_PROVIDER_IDS)[number];

package/dist/cjs/types/provider-id.enum.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLM_PROVIDER_IDS = void 0;
+/**
+ * Provider ids implemented so far — the 15 first-class OpenAI-compatible
+ * providers (one shared connector) plus native-adapter providers as they land
+ * (`anthropic`). Remaining natives (bedrock, gemini, vertex, cohere) are added
+ * when their adapters ship.
+ */
+exports.LLM_PROVIDER_IDS = [
+    'openai',
+    'azure-openai',
+    'openrouter',
+    'groq',
+    'together',
+    'fireworks',
+    'deepseek',
+    'xai',
+    'mistral',
+    'perplexity',
+    'deepinfra',
+    'cloudflare',
+    'vllm',
+    'ollama',
+    'lmstudio',
+    'anthropic',
+    'bedrock',
+    'gemini',
+];

package/dist/cjs/types/provider.interface.d.ts

@@ -0,0 +1,7 @@
+import type { ChatInput, ChatResult, ChatStreamDelta } from './chat.types';
+/** The contract every chat connector satisfies — shared-compat or native adapter. */
+export interface IChatConnector {
+    readonly id: string;
+    complete(input: ChatInput): Promise<ChatResult>;
+    stream(input: ChatInput): AsyncIterable<ChatStreamDelta>;
+}

package/dist/cjs/types/provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/base/base.connector.d.ts

@@ -0,0 +1,44 @@
+import { ConnectorError } from '../types/index.js';
+/**
+ * Shared HTTP plumbing for every connector. Holds the BYO `fetch` and maps
+ * transport-level failures (abort, network) to `ConnectorError`. Applies no
+ * automatic key transformation and holds no state (umbrella invariants).
+ */
+export declare abstract class BaseConnector {
+    protected readonly fetchImpl: typeof fetch;
+    protected constructor(fetchImpl?: typeof fetch);
+    protected sendPostJson(url: string, body: unknown, headers: Record<string, string>, signal?: AbortSignal): Promise<Response>;
+    protected invokeFetch(url: string, init: RequestInit): Promise<Response>;
+    /**
+     * Guard a decoded 2xx body: a `null` here means the body was empty or not
+     * JSON (a proxy/captive-portal HTML page, a truncated read). Parsing that into
+     * an empty "successful" result is silent data loss, so raise instead.
+     */
+    protected requireDecodedBody<T>(json: T | null, status: number): T;
+}
+/**
+ * Map a caught transport-layer failure to a `ConnectorError`. Shared by the
+ * request path (`invokeFetch`) and the streaming read loop (`parseSSEStream`) so
+ * a mid-stream TCP drop / abort surfaces with the same taxonomy as a failure
+ * before the first byte — never a raw `TypeError`/`DOMException`.
+ *
+ * A manual `AbortController.abort()` raises an `AbortError` (consumer cancelled
+ * → `invalid_request`); `AbortSignal.timeout()` raises a distinct `TimeoutError`
+ * (the provider failed to respond in time → `provider_unavailable`). Any other
+ * rejection (network reset, DNS) is `provider_unavailable`.
+ */
+export declare function transportErrorFrom(err: unknown): ConnectorError;
+/**
+ * Append `_passthrough.query` params to a request URL. EVERY request path must
+ * honor this — not just OpenAI-compat chat — because some providers require a
+ * query param the facade doesn't model (e.g. Azure OpenAI's `api-version`).
+ * Preserves any query string the URL already carries.
+ */
+export declare function appendPassthroughQuery(url: string, query?: Record<string, string>): string;
+/**
+ * Parse a Server-Sent-Events response body into a sequence of JSON-decoded
+ * `data:` payloads. Skips comments/blank lines, stops at the `[DONE]` sentinel,
+ * and ignores any `data:` line that isn't valid JSON. Transport-agnostic over
+ * `\n\n` and `\r\n\r\n` event boundaries.
+ */
+export declare function parseSSEStream(response: Response): AsyncGenerator<unknown>;

package/dist/esm/base/base.connector.js

@@ -0,0 +1,209 @@
+import { ConnectorError } from '../types/index.js';
+/**
+ * Shared HTTP plumbing for every connector. Holds the BYO `fetch` and maps
+ * transport-level failures (abort, network) to `ConnectorError`. Applies no
+ * automatic key transformation and holds no state (umbrella invariants).
+ */
+export class BaseConnector {
+    constructor(fetchImpl) {
+        const baseFetch = fetchImpl ?? globalThis.fetch;
+        // Force `redirect: 'error'` on every request at the transport seam so a 3xx
+        // can never silently re-send credentials to the redirect target. `fetch`
+        // strips only `Authorization`/`Cookie` cross-origin, so provider key headers
+        // (x-api-key, x-goog-api-key, api-key, …) would otherwise leak. No LLM
+        // endpoint legitimately redirects a POST.
+        this.fetchImpl = ((input, init) => baseFetch(input, { ...init, redirect: 'error' }));
+    }
+    async sendPostJson(url, body, headers, signal) {
+        return this.invokeFetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...headers },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    async invokeFetch(url, init) {
+        try {
+            return await this.fetchImpl(url, init);
+        }
+        catch (err) {
+            throw transportErrorFrom(err);
+        }
+    }
+    /**
+     * Guard a decoded 2xx body: a `null` here means the body was empty or not
+     * JSON (a proxy/captive-portal HTML page, a truncated read). Parsing that into
+     * an empty "successful" result is silent data loss, so raise instead.
+     */
+    requireDecodedBody(json, status) {
+        if (json === null) {
+            const message = 'Provider returned a successful status with an empty or non-JSON body';
+            throw new ConnectorError({
+                message,
+                statusCode: status,
+                providerCode: 'provider_unavailable',
+                providerMessage: message,
+                cause: null,
+            });
+        }
+        return json;
+    }
+}
+/**
+ * Map a caught transport-layer failure to a `ConnectorError`. Shared by the
+ * request path (`invokeFetch`) and the streaming read loop (`parseSSEStream`) so
+ * a mid-stream TCP drop / abort surfaces with the same taxonomy as a failure
+ * before the first byte — never a raw `TypeError`/`DOMException`.
+ *
+ * A manual `AbortController.abort()` raises an `AbortError` (consumer cancelled
+ * → `invalid_request`); `AbortSignal.timeout()` raises a distinct `TimeoutError`
+ * (the provider failed to respond in time → `provider_unavailable`). Any other
+ * rejection (network reset, DNS) is `provider_unavailable`.
+ */
+export function transportErrorFrom(err) {
+    if (err instanceof ConnectorError)
+        return err;
+    const name = err?.name;
+    if (name === 'AbortError') {
+        return new ConnectorError({
+            message: err.message || 'Request cancelled',
+            statusCode: null,
+            providerCode: 'invalid_request',
+            cause: { raw: err },
+        });
+    }
+    return new ConnectorError({
+        message: err?.message || 'Network error',
+        statusCode: null,
+        providerCode: 'provider_unavailable',
+        cause: { raw: err },
+    });
+}
+/**
+ * Append `_passthrough.query` params to a request URL. EVERY request path must
+ * honor this — not just OpenAI-compat chat — because some providers require a
+ * query param the facade doesn't model (e.g. Azure OpenAI's `api-version`).
+ * Preserves any query string the URL already carries.
+ */
+export function appendPassthroughQuery(url, query) {
+    if (!query || Object.keys(query).length === 0)
+        return url;
+    const sep = url.includes('?') ? '&' : '?';
+    return `${url}${sep}${new URLSearchParams(query).toString()}`;
+}
+/**
+ * Upper bound on the residual (not-yet-terminated) SSE buffer. A stream that
+ * never emits an event boundary would otherwise grow `buffer` without limit
+ * (memory-exhaustion DoS from a malicious/broken upstream). Generous enough for
+ * any single legitimate LLM event; complete events are drained before this is
+ * checked, so many-small-event streams never approach it.
+ */
+const MAX_SSE_EVENT_CHARS = 16 * 1024 * 1024;
+/**
+ * Parse a Server-Sent-Events response body into a sequence of JSON-decoded
+ * `data:` payloads. Skips comments/blank lines, stops at the `[DONE]` sentinel,
+ * and ignores any `data:` line that isn't valid JSON. Transport-agnostic over
+ * `\n\n` and `\r\n\r\n` event boundaries.
+ */
+export async function* parseSSEStream(response) {
+    const body = response.body;
+    if (!body)
+        return;
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let drained = false;
+    try {
+        for (;;) {
+            let done;
+            let value;
+            try {
+                ({ done, value } = await reader.read());
+            }
+            catch (err) {
+                // A mid-stream read rejection (TCP reset, abort, undici error) must
+                // surface with the ConnectorError taxonomy, not as a raw DOMException —
+                // streams are the failures consumers are least able to catch generically.
+                throw transportErrorFrom(err);
+            }
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let boundary;
+            while ((boundary = indexOfEventBoundary(buffer)) !== -1) {
+                const rawEvent = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary).replace(/^(?:\r\n|\r|\n)+/, '');
+                const payload = extractData(rawEvent);
+                if (payload === null)
+                    continue;
+                if (payload === '[DONE]') {
+                    // Leave `drained = false` so the `finally` cancels the reader. The
+                    // sentinel does NOT mean the body is fully consumed — every
+                    // OpenAI-compat stream ends here, and without a cancel undici can't
+                    // release the socket (leak on every successful stream).
+                    return;
+                }
+                const parsed = tryParseJson(payload);
+                if (parsed !== undefined)
+                    yield parsed;
+            }
+            if (buffer.length > MAX_SSE_EVENT_CHARS) {
+                throw new ConnectorError({
+                    message: `SSE event exceeded ${MAX_SSE_EVENT_CHARS} characters without a boundary`,
+                    statusCode: null,
+                    providerCode: 'provider_unavailable',
+                });
+            }
+        }
+        const tail = buffer.trim();
+        if (tail) {
+            const payload = extractData(tail);
+            if (payload !== null && payload !== '[DONE]') {
+                const parsed = tryParseJson(payload);
+                if (parsed !== undefined)
+                    yield parsed;
+            }
+        }
+        drained = true;
+    }
+    finally {
+        // If the consumer broke out early (or we threw), the body is not fully read —
+        // cancel it so the underlying connection is released instead of leaking.
+        if (!drained) {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        reader.releaseLock();
+    }
+}
+// An SSE event boundary is a blank line: two consecutive line terminators. The
+// spec permits CRLF, CR, or LF as a terminator, so accept any pairing
+// (`\n\n`, `\r\n\r\n`, `\r\r`, and mixed `\n\r\n` / `\r\n\n`) rather than only
+// the two common forms — a CR-only or mixed upstream would otherwise never
+// split and buffer until MAX_SSE_EVENT_CHARS.
+const EVENT_BOUNDARY_RE = /(?:\r\n|\r|\n)(?:\r\n|\r|\n)/;
+function indexOfEventBoundary(buffer) {
+    const m = EVENT_BOUNDARY_RE.exec(buffer);
+    return m ? m.index : -1;
+}
+function extractData(rawEvent) {
+    const dataParts = [];
+    for (const line of rawEvent.split(/\r\n|\r|\n/)) {
+        if (line.startsWith('data:')) {
+            dataParts.push(line.slice(5).replace(/^ /, ''));
+        }
+    }
+    return dataParts.length === 0 ? null : dataParts.join('\n');
+}
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/esm/facades/chat.facade.d.ts

@@ -0,0 +1,17 @@
+import type { LlmProviderId, ChatInput, ChatResult, ChatStreamDelta, IChatConnector, ProviderConfigMap } from '../types/index.js';
+export type ChatConfig<P extends LlmProviderId> = ProviderConfigMap[P];
+/**
+ * The chat-completion facade. Construct by provider id + config — the facade
+ * dispatches to the shared OpenAI-compatible connector (native adapters slot in
+ * here as they land) — or pass a connector instance directly for advanced use.
+ * Switching vendor is a change of provider id + `model` only; `ChatInput` /
+ * `ChatResult` are identical across providers.
+ */
+export declare class Chat<P extends LlmProviderId = LlmProviderId> {
+    readonly id: string;
+    private readonly connector;
+    constructor(providerId: P, config: ChatConfig<P>);
+    constructor(connector: IChatConnector);
+    complete(input: ChatInput): Promise<ChatResult>;
+    stream(input: ChatInput): AsyncIterable<ChatStreamDelta>;
+}

package/dist/esm/facades/chat.facade.js

@@ -0,0 +1,59 @@
+import { OpenAICompatConnector } from '../providers/_shared/openai-compat.connector.js';
+import { SPECS } from '../providers/_shared/spec.js';
+import { AnthropicConnector } from '../providers/anthropic/index.js';
+import { BedrockConnector } from '../providers/bedrock/index.js';
+import { GeminiConnector } from '../providers/gemini/index.js';
+import { ConnectorError } from '../types/index.js';
+/**
+ * The chat-completion facade. Construct by provider id + config — the facade
+ * dispatches to the shared OpenAI-compatible connector (native adapters slot in
+ * here as they land) — or pass a connector instance directly for advanced use.
+ * Switching vendor is a change of provider id + `model` only; `ChatInput` /
+ * `ChatResult` are identical across providers.
+ */
+export class Chat {
+    constructor(arg, config) {
+        if (typeof arg === 'object' && arg !== null) {
+            this.connector = arg;
+            this.id = arg.id;
+            return;
+        }
+        const providerId = arg;
+        this.id = providerId;
+        if (!config) {
+            throw new ConnectorError({
+                message: 'Chat facade requires `config` when constructed with a provider id',
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        // Native adapters — structurally different wire, same normalized surface.
+        if (providerId === 'anthropic') {
+            this.connector = new AnthropicConnector(config);
+            return;
+        }
+        if (providerId === 'bedrock') {
+            this.connector = new BedrockConnector(config);
+            return;
+        }
+        if (providerId === 'gemini') {
+            this.connector = new GeminiConnector(config);
+            return;
+        }
+        const spec = SPECS[providerId];
+        if (!spec) {
+            throw new ConnectorError({
+                message: `Unsupported LLM provider: ${String(providerId)}`,
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        this.connector = new OpenAICompatConnector(spec, config);
+    }
+    complete(input) {
+        return this.connector.complete(input);
+    }
+    stream(input) {
+        return this.connector.stream(input);
+    }
+}

package/dist/esm/facades/embeddings.facade.d.ts

@@ -0,0 +1,23 @@
+import type { EmbeddingsInput, EmbeddingsResult, IEmbeddingsConnector, OpenAICompatConfig } from '../types/index.js';
+/**
+ * First-class providers that expose an OpenAI-float-shaped `/embeddings`
+ * surface (FR-AI-E1). Deliberately excludes: providers with no native
+ * embeddings (deepseek, xai), quantized/non-float shapes (perplexity int8),
+ * unstable coverage (groq), and the native-adapter providers (Anthropic →
+ * Voyage; Bedrock/Gemini native embeddings have a different shape — a future
+ * per-connector embeddings surface).
+ */
+export declare const EMBEDDINGS_PROVIDER_IDS: readonly ["openai", "azure-openai", "openrouter", "together", "fireworks", "mistral", "deepinfra", "cloudflare", "vllm", "ollama", "lmstudio"];
+export type EmbeddingsProviderId = (typeof EMBEDDINGS_PROVIDER_IDS)[number];
+/**
+ * The embeddings facade — a separate operation from `Chat`. Construct by
+ * provider id + config, or with a connector instance. Only the OpenAI-float
+ * subset is accepted (type-restricted); other ids throw `ConnectorError`.
+ */
+export declare class Embeddings<P extends EmbeddingsProviderId = EmbeddingsProviderId> {
+    readonly id: string;
+    private readonly connector;
+    constructor(providerId: P, config: OpenAICompatConfig);
+    constructor(connector: IEmbeddingsConnector);
+    create(input: EmbeddingsInput): Promise<EmbeddingsResult>;
+}

package/dist/esm/facades/embeddings.facade.js

@@ -0,0 +1,59 @@
+import { OpenAICompatEmbeddingsConnector } from '../providers/_shared/openai-compat.embeddings.connector.js';
+import { SPECS } from '../providers/_shared/spec.js';
+import { ConnectorError } from '../types/index.js';
+/**
+ * First-class providers that expose an OpenAI-float-shaped `/embeddings`
+ * surface (FR-AI-E1). Deliberately excludes: providers with no native
+ * embeddings (deepseek, xai), quantized/non-float shapes (perplexity int8),
+ * unstable coverage (groq), and the native-adapter providers (Anthropic →
+ * Voyage; Bedrock/Gemini native embeddings have a different shape — a future
+ * per-connector embeddings surface).
+ */
+export const EMBEDDINGS_PROVIDER_IDS = [
+    'openai',
+    'azure-openai',
+    'openrouter',
+    'together',
+    'fireworks',
+    'mistral',
+    'deepinfra',
+    'cloudflare',
+    'vllm',
+    'ollama',
+    'lmstudio',
+];
+const SUPPORTED = new Set(EMBEDDINGS_PROVIDER_IDS);
+/**
+ * The embeddings facade — a separate operation from `Chat`. Construct by
+ * provider id + config, or with a connector instance. Only the OpenAI-float
+ * subset is accepted (type-restricted); other ids throw `ConnectorError`.
+ */
+export class Embeddings {
+    constructor(arg, config) {
+        if (typeof arg === 'object' && arg !== null) {
+            this.connector = arg;
+            this.id = arg.id;
+            return;
+        }
+        const providerId = arg;
+        this.id = providerId;
+        if (!SUPPORTED.has(providerId)) {
+            throw new ConnectorError({
+                message: `Provider '${String(providerId)}' has no OpenAI-compatible embeddings surface`,
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        if (!config) {
+            throw new ConnectorError({
+                message: 'Embeddings facade requires `config` when constructed with a provider id',
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        this.connector = new OpenAICompatEmbeddingsConnector(SPECS[providerId], config);
+    }
+    create(input) {
+        return this.connector.create(input);
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,15 @@
+export { Chat } from './facades/chat.facade.js';
+export type { ChatConfig } from './facades/chat.facade.js';
+export { Embeddings, EMBEDDINGS_PROVIDER_IDS } from './facades/embeddings.facade.js';
+export type { EmbeddingsProviderId } from './facades/embeddings.facade.js';
+export { OpenAICompatConnector } from './providers/_shared/openai-compat.connector.js';
+export { OpenAICompatEmbeddingsConnector } from './providers/_shared/openai-compat.embeddings.connector.js';
+export { SPECS } from './providers/_shared/spec.js';
+export type { OpenAICompatSpec, SpecId } from './providers/_shared/spec.js';
+export { AnthropicConnector } from './providers/anthropic/index.js';
+export type { AnthropicConfig } from './providers/anthropic/index.js';
+export { BedrockConnector } from './providers/bedrock/index.js';
+export type { BedrockConfig } from './providers/bedrock/index.js';
+export { GeminiConnector } from './providers/gemini/index.js';
+export type { GeminiConfig } from './providers/gemini/index.js';
+export * from './types/index.js';

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+export { Chat } from './facades/chat.facade.js';
+export { Embeddings, EMBEDDINGS_PROVIDER_IDS } from './facades/embeddings.facade.js';
+export { OpenAICompatConnector } from './providers/_shared/openai-compat.connector.js';
+export { OpenAICompatEmbeddingsConnector } from './providers/_shared/openai-compat.embeddings.connector.js';
+export { SPECS } from './providers/_shared/spec.js';
+export { AnthropicConnector } from './providers/anthropic/index.js';
+export { BedrockConnector } from './providers/bedrock/index.js';
+export { GeminiConnector } from './providers/gemini/index.js';
+export * from './types/index.js';

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/providers/_shared/openai-compat.connector.d.ts

@@ -0,0 +1,23 @@
+import { BaseConnector } from '../../base/base.connector.js';
+import type { ChatInput, ChatResult, ChatStreamDelta, IChatConnector, OpenAICompatConfig } from '../../types/index.js';
+import type { OpenAICompatSpec } from './spec.js';
+/**
+ * The single connector shared by every first-class OpenAI-compatible provider.
+ * It builds the `/chat/completions` request from the normalized `ChatInput`,
+ * parses the response (and SSE stream) into the normalized shapes, and maps
+ * vendor errors to `ConnectorError`. Provider differences are expressed by the
+ * `OpenAICompatSpec`, not by subclassing.
+ */
+export declare class OpenAICompatConnector extends BaseConnector implements IChatConnector {
+    readonly id: string;
+    private readonly baseUrl;
+    private readonly spec;
+    private readonly config;
+    constructor(spec: OpenAICompatSpec, config: OpenAICompatConfig);
+    complete(input: ChatInput): Promise<ChatResult>;
+    stream(input: ChatInput): AsyncGenerator<ChatStreamDelta>;
+    private buildRequest;
+    private parseResult;
+    private mapStreamChunk;
+    private mapVendorError;
+}