@thinwrap/llm 1.0.0

package/dist/esm/providers/gemini/gemini.connector.js

@@ -0,0 +1,430 @@
+import { appendPassthroughQuery, BaseConnector, parseSSEStream } from '../../base/base.connector.js';
+import { ConnectorError } from '../../types/index.js';
+const DEFAULT_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
+/**
+ * Native adapter for the Google Gemini (AI Studio) `generateContent` API.
+ * Gemini uses `contents[]`/`parts[]` (roles `user`/`model`), a top-level
+ * `systemInstruction`, `functionDeclarations`, and keys tool results by
+ * function NAME (not id). This connector translates the normalized surface to
+ * that shape and back, emitting the identical `ChatResult`/`ChatStreamDelta`/
+ * `ConnectorError`. Unlike Bedrock, Gemini streaming IS SSE
+ * (`:streamGenerateContent?alt=sse`), so streaming is truly incremental.
+ *
+ * Passthrough/raw (not emulated): Gemini-3 `thought_signature` round-trip and
+ * reasoning CoT output (`raw`), prompt caching (`cachedContent` via
+ * `_passthrough`), safety settings / video params (`_passthrough`).
+ */
+export class GeminiConnector extends BaseConnector {
+    constructor(config) {
+        super(config.fetch);
+        this.id = 'gemini';
+        this.config = config;
+        this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+    }
+    async complete(input) {
+        const url = appendPassthroughQuery(`${this.baseUrl}/models/${encodeURIComponent(input.model)}:generateContent`, input._passthrough?.query);
+        const response = await this.sendPostJson(url, this.buildRequest(input), this.authHeaders(input), input.signal);
+        if (!response.ok) {
+            const errBody = await response.json().catch(() => null);
+            throw this.mapVendorError(response.status, errBody, response.headers);
+        }
+        const json = this.requireDecodedBody((await response.json().catch(() => null)), response.status);
+        return this.parseResult(json, input.model);
+    }
+    async *stream(input) {
+        const url = appendPassthroughQuery(`${this.baseUrl}/models/${encodeURIComponent(input.model)}:streamGenerateContent?alt=sse`, input._passthrough?.query);
+        const response = await this.invokeFetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'text/event-stream', ...this.authHeaders(input) },
+            body: JSON.stringify(this.buildRequest(input)),
+            signal: input.signal,
+        });
+        if (!response.ok) {
+            const errBody = await response.json().catch(() => null);
+            throw this.mapVendorError(response.status, errBody, response.headers);
+        }
+        let sawFunctionCall = false;
+        // Gemini yields each functionCall part in its own chunk, so assign a
+        // monotonically-incrementing tool-call index (mirrors Anthropic's
+        // `nextToolIndex++` and the non-stream `idx`) — a hardcoded 0 would make a
+        // consumer keyed on `index` merge parallel/multiple calls into one.
+        let nextToolIndex = 0;
+        // Gemini's `usageMetadata` is cumulative and can appear on more than one
+        // chunk. Buffer the latest and emit a SINGLE terminal `usage` delta at
+        // stream end (matching the OpenAI-compat `include_usage` trailer and
+        // Anthropic's single `message_delta`) so a consumer summing `delta.usage`
+        // across the stream never double-counts.
+        let latestUsage;
+        let latestUsageChunk;
+        for await (const raw of parseSSEStream(response)) {
+            const chunk = raw;
+            // A provider error emitted mid-stream arrives as an `{"error": …}` frame —
+            // throw instead of silently ending the stream with no finishReason.
+            if (chunk.error != null) {
+                throw this.mapVendorError(errorFrameStatus(chunk.error), chunk, new Headers());
+            }
+            // A prompt-level safety block on a stream arrives as a chunk with no
+            // candidate and only promptFeedback — emit a content_filter finish so the
+            // consumer sees the block instead of a silent, empty end.
+            if (chunk.candidates?.[0] == null && chunk.promptFeedback?.blockReason) {
+                yield { finishReason: 'content_filter', raw: chunk };
+                continue;
+            }
+            const cand = chunk.candidates?.[0];
+            for (const p of cand?.content?.parts ?? []) {
+                if (p.thought === true) {
+                    continue; // reasoning CoT, not answer content (available via raw)
+                }
+                else if (typeof p.text === 'string' && p.text.length > 0) {
+                    yield { contentDelta: p.text, raw: chunk };
+                }
+                else if (p.functionCall) {
+                    sawFunctionCall = true;
+                    yield {
+                        toolCallDelta: {
+                            index: nextToolIndex++,
+                            id: p.functionCall.id ?? `call_${p.functionCall.name ?? ''}`,
+                            functionName: p.functionCall.name,
+                            argumentsDelta: JSON.stringify(p.functionCall.args ?? {}),
+                        },
+                        raw: chunk,
+                    };
+                }
+            }
+            if (chunk.usageMetadata) {
+                latestUsage = chunk.usageMetadata;
+                latestUsageChunk = chunk;
+            }
+            if (cand?.finishReason) {
+                yield {
+                    finishReason: sawFunctionCall ? 'tool_calls' : mapFinishReason(cand.finishReason),
+                    raw: chunk,
+                };
+            }
+        }
+        if (latestUsage)
+            yield { usage: mapUsage(latestUsage), raw: latestUsageChunk };
+    }
+    authHeaders(input) {
+        return {
+            'x-goog-api-key': this.config.apiKey,
+            ...this.config.headers,
+            ...input._passthrough?.headers,
+        };
+    }
+    buildRequest(input) {
+        const { systemInstruction, contents } = splitMessages(input.messages);
+        const body = { contents };
+        if (systemInstruction)
+            body.systemInstruction = systemInstruction;
+        if (input.tools && input.tools.length > 0) {
+            body.tools = [
+                {
+                    functionDeclarations: input.tools.map((t) => ({
+                        name: t.function.name,
+                        ...(t.function.description ? { description: t.function.description } : {}),
+                        ...(t.function.parameters ? { parameters: t.function.parameters } : {}),
+                    })),
+                },
+            ];
+            const fc = mapFunctionCallingConfig(input.toolChoice);
+            if (fc)
+                body.toolConfig = { functionCallingConfig: fc };
+        }
+        const generationConfig = {};
+        const maxTok = input.maxOutputTokens ?? this.config.defaultMaxTokens;
+        if (maxTok !== undefined)
+            generationConfig.maxOutputTokens = maxTok;
+        if (input.temperature !== undefined)
+            generationConfig.temperature = input.temperature;
+        if (input.topP !== undefined)
+            generationConfig.topP = input.topP;
+        if (input.stop !== undefined) {
+            generationConfig.stopSequences = Array.isArray(input.stop) ? input.stop : [input.stop];
+        }
+        applyResponseFormat(generationConfig, input.responseFormat);
+        if (input.reasoning) {
+            generationConfig.thinkingConfig = { thinkingBudget: effortBudget(input.reasoning.effort) };
+        }
+        if (Object.keys(generationConfig).length > 0)
+            body.generationConfig = generationConfig;
+        if (input._passthrough?.body)
+            Object.assign(body, input._passthrough.body);
+        return body;
+    }
+    parseResult(json, requestedModel) {
+        const cand = json?.candidates?.[0];
+        const parts = cand?.content?.parts ?? [];
+        let text = '';
+        const toolCalls = [];
+        let idx = 0;
+        for (const p of parts) {
+            if (p.thought === true) {
+                continue; // reasoning CoT, not answer content (available via raw)
+            }
+            else if (typeof p.text === 'string') {
+                text += p.text;
+            }
+            else if (p.functionCall) {
+                toolCalls.push({
+                    id: p.functionCall.id ?? `call_${idx}`,
+                    type: 'function',
+                    function: {
+                        name: p.functionCall.name ?? '',
+                        arguments: JSON.stringify(p.functionCall.args ?? {}),
+                    },
+                });
+                idx++;
+            }
+        }
+        // No candidate came back: a prompt-level safety block reports only
+        // `promptFeedback.blockReason`. Surface it as content_filter rather than a
+        // silent empty completion with finishReason unknown.
+        const finishReason = toolCalls.length > 0
+            ? 'tool_calls'
+            : cand?.finishReason == null && json?.promptFeedback?.blockReason
+                ? 'content_filter'
+                : mapFinishReason(cand?.finishReason);
+        return {
+            message: {
+                role: 'assistant',
+                content: text.length > 0 ? text : null,
+                ...(toolCalls.length > 0 ? { toolCalls } : {}),
+            },
+            finishReason,
+            usage: mapUsage(json?.usageMetadata),
+            model: json?.modelVersion ?? requestedModel,
+            raw: json,
+        };
+    }
+    mapVendorError(status, body, headers) {
+        const message = extractGeminiError(body) ?? `HTTP ${status}`;
+        const providerCode = mapStatusToProviderCode(status, message);
+        const cause = { raw: body ?? null };
+        const retryAfter = headers.get('retry-after');
+        if (retryAfter != null) {
+            cause.retryAfter = retryAfter;
+            const secs = Number(retryAfter);
+            if (Number.isFinite(secs))
+                cause.retryAfterSeconds = secs;
+        }
+        // Gemini has no rate-limit headers — retry timing lives in the 429 body's RetryInfo.
+        if (cause.retryAfterSeconds === undefined) {
+            const bodySecs = extractRetryDelaySeconds(body);
+            if (bodySecs != null)
+                cause.retryAfterSeconds = bodySecs;
+        }
+        return new ConnectorError({
+            message,
+            statusCode: status,
+            providerCode,
+            providerMessage: message,
+            cause,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Mappers
+// ---------------------------------------------------------------------------
+function splitMessages(messages) {
+    const nameById = new Map();
+    for (const m of messages) {
+        if (m.role === 'assistant' && m.toolCalls) {
+            for (const tc of m.toolCalls)
+                nameById.set(tc.id, tc.function.name);
+        }
+    }
+    let systemText = '';
+    const contents = [];
+    for (const m of messages) {
+        if (m.role === 'system') {
+            const t = contentToText(m.content);
+            systemText = systemText ? `${systemText}\n\n${t}` : t;
+            continue;
+        }
+        if (m.role === 'tool') {
+            const name = m.name ?? (m.toolCallId ? nameById.get(m.toolCallId) : undefined) ?? m.toolCallId ?? 'tool';
+            const part = {
+                functionResponse: { name, response: { result: parseJsonOrString(contentToText(m.content)) } },
+            };
+            const last = contents[contents.length - 1];
+            if (last && last.role === 'user' && isFunctionResponseParts(last.parts)) {
+                last.parts.push(part);
+            }
+            else {
+                contents.push({ role: 'user', parts: [part] });
+            }
+            continue;
+        }
+        contents.push({ role: m.role === 'assistant' ? 'model' : 'user', parts: mapParts(m) });
+    }
+    return {
+        systemInstruction: systemText ? { parts: [{ text: systemText }] } : undefined,
+        contents,
+    };
+}
+function contentToText(content) {
+    if (content === null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    return content
+        .filter((p) => p.type === 'text')
+        .map((p) => p.text)
+        .join('');
+}
+function mapParts(m) {
+    const parts = [];
+    if (typeof m.content === 'string') {
+        if (m.content.length > 0)
+            parts.push({ text: m.content });
+    }
+    else if (Array.isArray(m.content)) {
+        for (const p of m.content) {
+            parts.push(p.type === 'text'
+                ? { text: p.text }
+                : { inlineData: { mimeType: p.mediaType, data: p.base64 } });
+        }
+    }
+    if (m.role === 'assistant' && m.toolCalls) {
+        for (const tc of m.toolCalls) {
+            parts.push({ functionCall: { name: tc.function.name, args: safeJsonParse(tc.function.arguments) } });
+        }
+    }
+    if (parts.length === 0)
+        parts.push({ text: '' });
+    return parts;
+}
+function isFunctionResponseParts(parts) {
+    return (parts.length > 0 &&
+        typeof parts[0] === 'object' &&
+        parts[0] !== null &&
+        'functionResponse' in parts[0]);
+}
+function mapFunctionCallingConfig(tc) {
+    if (tc === undefined)
+        return null;
+    if (tc === 'auto')
+        return { mode: 'AUTO' };
+    if (tc === 'required')
+        return { mode: 'ANY' };
+    if (tc === 'none')
+        return { mode: 'NONE' };
+    if (typeof tc === 'object' && tc.type === 'function') {
+        return { mode: 'ANY', allowedFunctionNames: [tc.function.name] };
+    }
+    return null;
+}
+function applyResponseFormat(generationConfig, rf) {
+    if (!rf)
+        return;
+    if (rf.type === 'json_object') {
+        generationConfig.responseMimeType = 'application/json';
+    }
+    else if (rf.type === 'json_schema') {
+        generationConfig.responseMimeType = 'application/json';
+        generationConfig.responseSchema = rf.jsonSchema.schema;
+    }
+}
+function mapFinishReason(fr) {
+    switch (fr) {
+        case 'STOP':
+            return 'stop';
+        case 'MAX_TOKENS':
+            return 'length';
+        case 'SAFETY':
+        case 'RECITATION':
+        case 'BLOCKLIST':
+        case 'PROHIBITED_CONTENT':
+        case 'SPII':
+            return 'content_filter';
+        default:
+            return 'unknown';
+    }
+}
+function mapUsage(u) {
+    const inputTokens = u?.promptTokenCount ?? 0;
+    const outputTokens = u?.candidatesTokenCount ?? 0;
+    return { inputTokens, outputTokens, totalTokens: u?.totalTokenCount ?? inputTokens + outputTokens };
+}
+function effortBudget(effort) {
+    switch (effort) {
+        case 'low':
+            return 1024;
+        case 'medium':
+            return 8192;
+        case 'high':
+            return 24576;
+    }
+}
+function safeJsonParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return {};
+    }
+}
+function parseJsonOrString(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+function extractGeminiError(body) {
+    if (typeof body === 'string')
+        return body;
+    if (!body || typeof body !== 'object')
+        return null;
+    const b = body;
+    if (b.error && typeof b.error === 'object') {
+        const em = b.error.message;
+        if (typeof em === 'string')
+            return em;
+    }
+    if (typeof b.message === 'string')
+        return b.message;
+    return null;
+}
+function extractRetryDelaySeconds(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const err = body.error;
+    if (!err || typeof err !== 'object')
+        return null;
+    const details = err.details;
+    if (!Array.isArray(details))
+        return null;
+    for (const d of details) {
+        const rd = d?.retryDelay;
+        if (typeof rd === 'string') {
+            const match = rd.match(/^(\d+(?:\.\d+)?)s$/);
+            if (match)
+                return Math.round(Number(match[1]));
+        }
+    }
+    return null;
+}
+/** HTTP status for a mid-stream Gemini `{"error": …}` frame — Gemini's `error.code` IS the HTTP status. */
+function errorFrameStatus(error) {
+    const code = error?.code;
+    return typeof code === 'number' && code >= 400 && code <= 599 ? code : 500;
+}
+function mapStatusToProviderCode(status, message) {
+    if (status === 401 || status === 403)
+        return 'auth_failed';
+    if (status === 429)
+        return 'rate_limited';
+    if (status >= 500)
+        return 'provider_unavailable';
+    if (status === 400 || status === 404 || status === 422) {
+        const msg = message.toLowerCase();
+        if (msg.includes('too long') || msg.includes('context') || msg.includes('token count')) {
+            return 'context_length_exceeded';
+        }
+        return 'invalid_request';
+    }
+    return 'unknown';
+}

package/dist/esm/providers/gemini/index.d.ts

@@ -0,0 +1,2 @@
+export { GeminiConnector } from './gemini.connector.js';
+export type { GeminiConfig } from './gemini.config.js';

package/dist/esm/providers/gemini/index.js

@@ -0,0 +1 @@
+export { GeminiConnector } from './gemini.connector.js';

package/dist/esm/types/chat.types.d.ts

@@ -0,0 +1,115 @@
+import type { Passthrough } from './passthrough.type.js';
+export type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
+export interface TextPart {
+    type: 'text';
+    text: string;
+}
+export interface ImagePart {
+    type: 'image';
+    /** Raw base64 payload (no `data:` prefix). Canonical image input; the connector encodes for the vendor wire. */
+    base64: string;
+    /** e.g. `image/png`, `image/jpeg`. */
+    mediaType: string;
+}
+export type ContentPart = TextPart | ImagePart;
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        /** JSON-encoded arguments string. */
+        arguments: string;
+    };
+}
+export interface ChatMessage {
+    role: ChatRole;
+    content: string | ContentPart[] | null;
+    /** Present on assistant turns that invoked tools. */
+    toolCalls?: ToolCall[];
+    /** Required on `role: 'tool'` messages — the id of the tool call being answered. */
+    toolCallId?: string;
+    /** Optional author / tool name. */
+    name?: string;
+}
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        /** JSON Schema object describing the arguments. */
+        parameters?: Record<string, unknown>;
+    };
+}
+export type ToolChoice = 'auto' | 'none' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+};
+export type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    jsonSchema: {
+        name: string;
+        schema: Record<string, unknown>;
+    };
+};
+/** Minimal normalized reasoning control (D2). CoT output is NOT normalized — read it from `ChatResult.raw`. */
+export interface ReasoningOptions {
+    effort: 'low' | 'medium' | 'high';
+}
+export interface ChatInput {
+    model: string;
+    messages: ChatMessage[];
+    tools?: ToolDefinition[];
+    toolChoice?: ToolChoice;
+    responseFormat?: ResponseFormat;
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+    stop?: string | string[];
+    reasoning?: ReasoningOptions;
+    /** Optional cancellation signal, forwarded to the underlying `fetch` for both `complete()` and `stream()`. */
+    signal?: AbortSignal;
+    /** Escape hatch for sub-baseline / provider-specific request fields. Never emulated. */
+    _passthrough?: Passthrough;
+}
+export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'unknown';
+export interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface ChatResult {
+    message: {
+        role: 'assistant';
+        content: string | null;
+        toolCalls?: ToolCall[];
+    };
+    finishReason: FinishReason;
+    usage: Usage;
+    /** The model id the provider reported serving (may differ from the requested id). */
+    model: string;
+    /** Verbatim vendor response body — reasoning CoT, cached-token counts, cost, etc. live here. */
+    raw: unknown;
+}
+export interface ChatStreamDelta {
+    /** Incremental assistant text. */
+    contentDelta?: string;
+    /** Incremental tool-call fragment (concatenate `argumentsDelta` per `index`). */
+    toolCallDelta?: {
+        index: number;
+        id?: string;
+        functionName?: string;
+        argumentsDelta?: string;
+    };
+    /** Present on the terminal chunk. */
+    finishReason?: FinishReason;
+    /** Present on the final usage chunk, when the provider reports it. */
+    usage?: Usage;
+    /** Verbatim vendor chunk. */
+    raw?: unknown;
+}

package/dist/esm/types/chat.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/config-map.type.d.ts

@@ -0,0 +1,29 @@
+import type { LlmProviderId } from './provider-id.enum.js';
+import type { AnthropicConfig } from '../providers/anthropic/anthropic.config.js';
+import type { BedrockConfig } from '../providers/bedrock/bedrock.config.js';
+import type { GeminiConfig } from '../providers/gemini/gemini.config.js';
+export interface OpenAICompatConfig {
+    /** Bearer API key. Optional for self-host providers (vLLM / Ollama / LM Studio) that run without auth. */
+    apiKey?: string;
+    /**
+     * Override the provider's default base URL (e.g. `https://api.openai.com/v1`).
+     * Required for providers with no fixed public default: `azure-openai`,
+     * `cloudflare`, and self-host providers on a non-default host.
+     */
+    baseUrl?: string;
+    /** Bring-your-own fetch. Defaults to `globalThis.fetch`. */
+    fetch?: typeof fetch;
+    /** Extra headers merged onto every request (e.g. OpenRouter `HTTP-Referer` / `X-Title`). */
+    headers?: Record<string, string>;
+}
+/**
+ * Per-provider config type. The 15 first-class providers share
+ * `OpenAICompatConfig`; native-adapter providers carry their own config.
+ */
+export type ProviderConfigMap = {
+    [K in Exclude<LlmProviderId, 'anthropic' | 'bedrock' | 'gemini'>]: OpenAICompatConfig;
+} & {
+    anthropic: AnthropicConfig;
+    bedrock: BedrockConfig;
+    gemini: GeminiConfig;
+};

package/dist/esm/types/config-map.type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/embeddings.types.d.ts

@@ -0,0 +1,29 @@
+import type { Passthrough } from './passthrough.type.js';
+export interface EmbeddingsInput {
+    model: string;
+    /** A single string or a batch of strings. */
+    input: string | string[];
+    /** Optional output dimensionality (providers that support `dimensions` / Matryoshka). */
+    dimensions?: number;
+    /** Optional cancellation signal, forwarded to the underlying `fetch`. */
+    signal?: AbortSignal;
+    /** Escape hatch for provider-specific request fields (e.g. `input_type`). Never emulated. */
+    _passthrough?: Passthrough;
+}
+export interface EmbeddingsUsage {
+    inputTokens: number;
+    totalTokens: number;
+}
+export interface EmbeddingsResult {
+    /** One float vector per input, in input order. */
+    embeddings: number[][];
+    usage: EmbeddingsUsage;
+    /** The model id the provider reported serving. */
+    model: string;
+    /** Verbatim vendor response body. */
+    raw: unknown;
+}
+export interface IEmbeddingsConnector {
+    readonly id: string;
+    create(input: EmbeddingsInput): Promise<EmbeddingsResult>;
+}

package/dist/esm/types/embeddings.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/error.types.d.ts

@@ -0,0 +1,20 @@
+export type ProviderCode = 'rate_limited' | 'auth_failed' | 'provider_unavailable' | 'invalid_request' | 'context_length_exceeded' | 'content_filtered' | 'unknown';
+/**
+ * Canonical error thrown by every connector on vendor HTTP non-2xx (and on
+ * network/abort failures). `providerCode` is narrowed to the `ProviderCode`
+ * union; the verbatim vendor error payload is preserved on `cause.raw`, and any
+ * retry hint on `cause.retryAfter` / `cause.retryAfterSeconds`. There is no
+ * top-level `retryAfterSeconds` field (umbrella invariant).
+ */
+export declare class ConnectorError extends Error {
+    readonly statusCode: number | null;
+    readonly providerCode?: ProviderCode;
+    readonly providerMessage: string | null;
+    constructor(options: {
+        message?: string;
+        statusCode: number | null;
+        providerCode?: ProviderCode;
+        providerMessage?: string | null;
+        cause?: unknown;
+    });
+}

package/dist/esm/types/error.types.js

@@ -0,0 +1,18 @@
+/**
+ * Canonical error thrown by every connector on vendor HTTP non-2xx (and on
+ * network/abort failures). `providerCode` is narrowed to the `ProviderCode`
+ * union; the verbatim vendor error payload is preserved on `cause.raw`, and any
+ * retry hint on `cause.retryAfter` / `cause.retryAfterSeconds`. There is no
+ * top-level `retryAfterSeconds` field (umbrella invariant).
+ */
+export class ConnectorError extends Error {
+    constructor(options) {
+        super(options.message ?? options.providerMessage ?? 'Connector error', {
+            cause: options.cause,
+        });
+        this.name = 'ConnectorError';
+        this.statusCode = options.statusCode;
+        this.providerCode = options.providerCode;
+        this.providerMessage = options.providerMessage ?? null;
+    }
+}

package/dist/esm/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './error.types.js';
+export * from './passthrough.type.js';
+export * from './chat.types.js';
+export * from './embeddings.types.js';
+export * from './provider-id.enum.js';
+export * from './config-map.type.js';
+export * from './provider.interface.js';

package/dist/esm/types/index.js

@@ -0,0 +1,7 @@
+export * from './error.types.js';
+export * from './passthrough.type.js';
+export * from './chat.types.js';
+export * from './embeddings.types.js';
+export * from './provider-id.enum.js';
+export * from './config-map.type.js';
+export * from './provider.interface.js';