@thinwrap/llm 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitry Polyanovsky & contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @thinwrap/llm
+
+Unified, **zero-dependency** TypeScript facade over LLM chat-completion providers. One typed `Chat` facade; switch vendor by changing the provider id + model. Stateless, bring-your-own `fetch`, no vendor SDKs — the in-process, zero-egress complement to an LLM gateway.
+
+## Install
+
+```bash
+npm install @thinwrap/llm
+```
+
+Node ≥ 18 (native `fetch`).
+
+## Quick start
+
+```ts
+import { Chat } from '@thinwrap/llm';
+
+const chat = new Chat('openai', { apiKey: process.env.OPENAI_API_KEY! });
+
+const res = await chat.complete({
+  model: 'gpt-5.6',
+  messages: [{ role: 'user', content: 'Say hi in one word.' }],
+});
+console.log(res.message.content, res.usage);
+```
+
+Switching vendor is the provider id + model:
+
+```ts
+const chat = new Chat('anthropic', { apiKey: process.env.ANTHROPIC_API_KEY! });
+// same .complete(input) shape, same ChatResult
+```
+
+Streaming:
+
+```ts
+for await (const delta of new Chat('groq', { apiKey }).stream(input)) {
+  if (delta.contentDelta) process.stdout.write(delta.contentDelta);
+}
+```
+
+## Design
+
+Facade → connector dispatch → shared `OpenAICompatConnector` (or a native adapter). The normalized facade holds only the ≥90%-supported core; provider-specific features ride through `_passthrough` (request) / `raw` (result). See the contributor docs in `.ai/`.
+
+Per-provider docs (auth, config, quirks, rate-limit links, error mapping) live in
+[`src/providers/`](src/providers) — one README per provider.
+
+## Timeouts & cancellation
+
+The wrapper is stateless and holds no timeout of its own — it awaits whatever your `fetch` does. To bound a hung provider, bring your own timeout via the injected `fetch`:
+
+```ts
+const chat = new Chat('openai', {
+  apiKey: process.env.OPENAI_API_KEY,
+  fetch: (url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(30_000) }),
+});
+```
+
+An aborted request surfaces as a `ConnectorError` (`providerCode: 'invalid_request'`), same as every other failure.
+
+MIT © Dmitry Polyanovsky

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

@@ -0,0 +1,44 @@
+import { ConnectorError } from '../types';
+/**
+ * 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/cjs/base/base.connector.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseConnector = void 0;
+exports.transportErrorFrom = transportErrorFrom;
+exports.appendPassthroughQuery = appendPassthroughQuery;
+exports.parseSSEStream = parseSSEStream;
+const types_1 = require("../types");
+/**
+ * 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).
+ */
+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 types_1.ConnectorError({
+                message,
+                statusCode: status,
+                providerCode: 'provider_unavailable',
+                providerMessage: message,
+                cause: null,
+            });
+        }
+        return json;
+    }
+}
+exports.BaseConnector = BaseConnector;
+/**
+ * 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`.
+ */
+function transportErrorFrom(err) {
+    if (err instanceof types_1.ConnectorError)
+        return err;
+    const name = err?.name;
+    if (name === 'AbortError') {
+        return new types_1.ConnectorError({
+            message: err.message || 'Request cancelled',
+            statusCode: null,
+            providerCode: 'invalid_request',
+            cause: { raw: err },
+        });
+    }
+    return new types_1.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.
+ */
+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.
+ */
+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 types_1.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/cjs/facades/chat.facade.d.ts

@@ -0,0 +1,17 @@
+import type { LlmProviderId, ChatInput, ChatResult, ChatStreamDelta, IChatConnector, ProviderConfigMap } from '../types';
+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/cjs/facades/chat.facade.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = void 0;
+const openai_compat_connector_1 = require("../providers/_shared/openai-compat.connector");
+const spec_1 = require("../providers/_shared/spec");
+const anthropic_1 = require("../providers/anthropic");
+const bedrock_1 = require("../providers/bedrock");
+const gemini_1 = require("../providers/gemini");
+const types_1 = require("../types");
+/**
+ * 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.
+ */
+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 types_1.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 anthropic_1.AnthropicConnector(config);
+            return;
+        }
+        if (providerId === 'bedrock') {
+            this.connector = new bedrock_1.BedrockConnector(config);
+            return;
+        }
+        if (providerId === 'gemini') {
+            this.connector = new gemini_1.GeminiConnector(config);
+            return;
+        }
+        const spec = spec_1.SPECS[providerId];
+        if (!spec) {
+            throw new types_1.ConnectorError({
+                message: `Unsupported LLM provider: ${String(providerId)}`,
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        this.connector = new openai_compat_connector_1.OpenAICompatConnector(spec, config);
+    }
+    complete(input) {
+        return this.connector.complete(input);
+    }
+    stream(input) {
+        return this.connector.stream(input);
+    }
+}
+exports.Chat = Chat;

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

@@ -0,0 +1,23 @@
+import type { EmbeddingsInput, EmbeddingsResult, IEmbeddingsConnector, OpenAICompatConfig } from '../types';
+/**
+ * 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/cjs/facades/embeddings.facade.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embeddings = exports.EMBEDDINGS_PROVIDER_IDS = void 0;
+const openai_compat_embeddings_connector_1 = require("../providers/_shared/openai-compat.embeddings.connector");
+const spec_1 = require("../providers/_shared/spec");
+const types_1 = require("../types");
+/**
+ * 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).
+ */
+exports.EMBEDDINGS_PROVIDER_IDS = [
+    'openai',
+    'azure-openai',
+    'openrouter',
+    'together',
+    'fireworks',
+    'mistral',
+    'deepinfra',
+    'cloudflare',
+    'vllm',
+    'ollama',
+    'lmstudio',
+];
+const SUPPORTED = new Set(exports.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`.
+ */
+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 types_1.ConnectorError({
+                message: `Provider '${String(providerId)}' has no OpenAI-compatible embeddings surface`,
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        if (!config) {
+            throw new types_1.ConnectorError({
+                message: 'Embeddings facade requires `config` when constructed with a provider id',
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        this.connector = new openai_compat_embeddings_connector_1.OpenAICompatEmbeddingsConnector(spec_1.SPECS[providerId], config);
+    }
+    create(input) {
+        return this.connector.create(input);
+    }
+}
+exports.Embeddings = Embeddings;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,35 @@
+"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 });
+exports.GeminiConnector = exports.BedrockConnector = exports.AnthropicConnector = exports.SPECS = exports.OpenAICompatEmbeddingsConnector = exports.OpenAICompatConnector = exports.EMBEDDINGS_PROVIDER_IDS = exports.Embeddings = exports.Chat = void 0;
+var chat_facade_1 = require("./facades/chat.facade");
+Object.defineProperty(exports, "Chat", { enumerable: true, get: function () { return chat_facade_1.Chat; } });
+var embeddings_facade_1 = require("./facades/embeddings.facade");
+Object.defineProperty(exports, "Embeddings", { enumerable: true, get: function () { return embeddings_facade_1.Embeddings; } });
+Object.defineProperty(exports, "EMBEDDINGS_PROVIDER_IDS", { enumerable: true, get: function () { return embeddings_facade_1.EMBEDDINGS_PROVIDER_IDS; } });
+var openai_compat_connector_1 = require("./providers/_shared/openai-compat.connector");
+Object.defineProperty(exports, "OpenAICompatConnector", { enumerable: true, get: function () { return openai_compat_connector_1.OpenAICompatConnector; } });
+var openai_compat_embeddings_connector_1 = require("./providers/_shared/openai-compat.embeddings.connector");
+Object.defineProperty(exports, "OpenAICompatEmbeddingsConnector", { enumerable: true, get: function () { return openai_compat_embeddings_connector_1.OpenAICompatEmbeddingsConnector; } });
+var spec_1 = require("./providers/_shared/spec");
+Object.defineProperty(exports, "SPECS", { enumerable: true, get: function () { return spec_1.SPECS; } });
+var anthropic_1 = require("./providers/anthropic");
+Object.defineProperty(exports, "AnthropicConnector", { enumerable: true, get: function () { return anthropic_1.AnthropicConnector; } });
+var bedrock_1 = require("./providers/bedrock");
+Object.defineProperty(exports, "BedrockConnector", { enumerable: true, get: function () { return bedrock_1.BedrockConnector; } });
+var gemini_1 = require("./providers/gemini");
+Object.defineProperty(exports, "GeminiConnector", { enumerable: true, get: function () { return gemini_1.GeminiConnector; } });
+__exportStar(require("./types"), exports);

package/dist/cjs/package.json

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

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

@@ -0,0 +1,23 @@
+import { BaseConnector } from '../../base/base.connector';
+import type { ChatInput, ChatResult, ChatStreamDelta, IChatConnector, OpenAICompatConfig } from '../../types';
+import type { OpenAICompatSpec } from './spec';
+/**
+ * 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;
+}