@thinwrap/llm 1.0.0

package/dist/cjs/providers/_shared/openai-compat.connector.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatConnector = void 0;
+const base_connector_1 = require("../../base/base.connector");
+const types_1 = require("../../types");
+/**
+ * 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.
+ */
+class OpenAICompatConnector extends base_connector_1.BaseConnector {
+    constructor(spec, config) {
+        super(config.fetch);
+        this.spec = spec;
+        this.id = spec.id;
+        this.config = config;
+        const baseUrl = config.baseUrl ?? spec.defaultBaseUrl;
+        if (!baseUrl) {
+            throw new types_1.ConnectorError({
+                message: `Provider '${spec.id}' requires an explicit \`baseUrl\` in config`,
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+    }
+    async complete(input) {
+        const { url, body, headers } = this.buildRequest(input, false);
+        const response = await this.sendPostJson(url, body, headers, 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, body, headers } = this.buildRequest(input, true);
+        const response = await this.invokeFetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+                ...headers,
+            },
+            body: JSON.stringify(body),
+            signal: input.signal,
+        });
+        if (!response.ok) {
+            const errBody = await response.json().catch(() => null);
+            throw this.mapVendorError(response.status, errBody, response.headers);
+        }
+        for await (const chunk of (0, base_connector_1.parseSSEStream)(response)) {
+            for (const delta of this.mapStreamChunk(chunk))
+                yield delta;
+        }
+    }
+    buildRequest(input, stream) {
+        const body = {
+            model: input.model,
+            messages: input.messages.map(mapMessage),
+        };
+        const toolsAllowed = this.spec.supportsTools !== false;
+        if (toolsAllowed && input.tools && input.tools.length > 0) {
+            body.tools = input.tools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.function.name,
+                    ...(t.function.description ? { description: t.function.description } : {}),
+                    ...(t.function.parameters ? { parameters: t.function.parameters } : {}),
+                },
+            }));
+        }
+        if (toolsAllowed && input.toolChoice !== undefined)
+            body.tool_choice = input.toolChoice;
+        if (input.responseFormat)
+            body.response_format = mapResponseFormat(input.responseFormat);
+        if (input.temperature !== undefined)
+            body.temperature = input.temperature;
+        if (input.topP !== undefined)
+            body.top_p = input.topP;
+        if (input.maxOutputTokens !== undefined) {
+            body[this.spec.maxTokensField ?? 'max_tokens'] = input.maxOutputTokens;
+        }
+        if (input.stop !== undefined)
+            body.stop = input.stop;
+        if (input.reasoning)
+            body.reasoning_effort = input.reasoning.effort;
+        if (stream) {
+            body.stream = true;
+            if (!this.spec.strictParams)
+                body.stream_options = { include_usage: true };
+        }
+        // Passthrough body is merged last and overrides connector-built fields.
+        if (input._passthrough?.body)
+            Object.assign(body, input._passthrough.body);
+        const headers = {
+            ...this.spec.buildAuthHeaders(this.config),
+            ...this.config.headers,
+            ...input._passthrough?.headers,
+        };
+        let url = `${this.baseUrl}/chat/completions`;
+        const query = input._passthrough?.query;
+        if (query && Object.keys(query).length > 0) {
+            url += `?${new URLSearchParams(query).toString()}`;
+        }
+        return { url, body, headers };
+    }
+    parseResult(json, requestedModel) {
+        const choice = json?.choices?.[0];
+        const msg = choice?.message;
+        const toolCalls = msg?.tool_calls?.map(mapToolCall);
+        return {
+            message: {
+                role: 'assistant',
+                content: msg?.content ?? null,
+                ...(toolCalls && toolCalls.length > 0 ? { toolCalls } : {}),
+            },
+            finishReason: mapFinishReason(choice?.finish_reason),
+            usage: mapUsage(json?.usage),
+            model: json?.model ?? requestedModel,
+            raw: json,
+        };
+    }
+    mapStreamChunk(chunk) {
+        // A provider/gateway failure emitted mid-stream arrives as an `{"error": …}`
+        // data frame (no `choices`). Surface it as a ConnectorError instead of
+        // silently truncating the stream into a finish-less "success".
+        if (chunk.error != null) {
+            throw this.mapVendorError(streamErrorStatus(chunk.error), chunk, new Headers());
+        }
+        const deltas = [];
+        const choice = chunk.choices?.[0];
+        const delta = choice?.delta;
+        if (typeof delta?.content === 'string' && delta.content.length > 0) {
+            deltas.push({ contentDelta: delta.content, raw: chunk });
+        }
+        // Parallel tool-call fragments can arrive in a single chunk — emit one
+        // toolCallDelta per entry (not just `tool_calls[0]`).
+        for (const tc of delta?.tool_calls ?? []) {
+            deltas.push({
+                toolCallDelta: {
+                    index: tc.index ?? 0,
+                    ...(tc.id ? { id: tc.id } : {}),
+                    ...(tc.function?.name ? { functionName: tc.function.name } : {}),
+                    ...(tc.function?.arguments ? { argumentsDelta: tc.function.arguments } : {}),
+                },
+                raw: chunk,
+            });
+        }
+        const trailer = { raw: chunk };
+        let hasTrailer = false;
+        if (choice?.finish_reason) {
+            trailer.finishReason = mapFinishReason(choice.finish_reason);
+            hasTrailer = true;
+        }
+        const usageRaw = chunk.usage ??
+            (this.spec.streamUsagePath === 'x_groq' ? chunk.x_groq?.usage : undefined);
+        if (usageRaw) {
+            trailer.usage = mapUsage(usageRaw);
+            hasTrailer = true;
+        }
+        if (hasTrailer)
+            deltas.push(trailer);
+        return deltas;
+    }
+    mapVendorError(status, body, headers) {
+        const message = extractErrorMessage(body) ?? `HTTP ${status}`;
+        const providerCode = mapStatusToProviderCode(status, body);
+        const retryAfter = headers.get('retry-after');
+        const cause = { raw: body ?? null };
+        if (retryAfter != null) {
+            cause.retryAfter = retryAfter;
+            const secs = parseRetryAfterSeconds(retryAfter);
+            if (secs != null)
+                cause.retryAfterSeconds = secs;
+        }
+        return new types_1.ConnectorError({
+            message,
+            statusCode: status,
+            providerCode,
+            providerMessage: message,
+            cause,
+        });
+    }
+}
+exports.OpenAICompatConnector = OpenAICompatConnector;
+// ---------------------------------------------------------------------------
+// Module-private mappers
+// ---------------------------------------------------------------------------
+function mapMessage(m) {
+    const out = { role: m.role, content: mapContent(m.content) };
+    if (m.name)
+        out.name = m.name;
+    if (m.toolCalls && m.toolCalls.length > 0) {
+        out.tool_calls = m.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.function.name, arguments: tc.function.arguments },
+        }));
+    }
+    if (m.toolCallId)
+        out.tool_call_id = m.toolCallId;
+    return out;
+}
+function mapContent(content) {
+    if (content === null)
+        return null;
+    if (typeof content === 'string')
+        return content;
+    return content.map((p) => p.type === 'text'
+        ? { type: 'text', text: p.text }
+        : { type: 'image_url', image_url: { url: `data:${p.mediaType};base64,${p.base64}` } });
+}
+function mapToolCall(tc) {
+    return {
+        id: tc.id ?? '',
+        type: 'function',
+        function: { name: tc.function?.name ?? '', arguments: tc.function?.arguments ?? '' },
+    };
+}
+function mapFinishReason(fr) {
+    switch (fr) {
+        case 'stop':
+        case 'eos': // Together AI reports natural end-of-sequence as "eos"
+            return 'stop';
+        case 'length':
+            return 'length';
+        case 'tool_calls':
+        case 'function_call':
+            return 'tool_calls';
+        case 'content_filter':
+            return 'content_filter';
+        default:
+            return 'unknown';
+    }
+}
+function mapUsage(u) {
+    const inputTokens = u?.prompt_tokens ?? 0;
+    const outputTokens = u?.completion_tokens ?? 0;
+    const totalTokens = u?.total_tokens ?? inputTokens + outputTokens;
+    return { inputTokens, outputTokens, totalTokens };
+}
+function mapResponseFormat(rf) {
+    if (rf.type === 'json_schema') {
+        return {
+            type: 'json_schema',
+            json_schema: { name: rf.jsonSchema.name, schema: rf.jsonSchema.schema },
+        };
+    }
+    return { type: rf.type };
+}
+function extractErrorMessage(body) {
+    if (typeof body === 'string')
+        return body;
+    if (!body || typeof body !== 'object')
+        return null;
+    const b = body;
+    if (typeof b.error === 'string')
+        return b.error;
+    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;
+    const errs = b.errors;
+    if (Array.isArray(errs) && errs[0] && typeof errs[0] === 'object') {
+        const m = errs[0].message;
+        if (typeof m === 'string')
+            return m;
+    }
+    return null;
+}
+/** Best-effort HTTP status for a mid-stream `{"error": …}` frame (some gateways carry a numeric `code`). */
+function streamErrorStatus(error) {
+    if (error && typeof error === 'object') {
+        const code = error.code;
+        if (typeof code === 'number' && code >= 400 && code <= 599)
+            return code;
+    }
+    return 500;
+}
+function mapStatusToProviderCode(status, body) {
+    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 = (extractErrorMessage(body) ?? '').toLowerCase();
+        if (msg.includes('context length') || msg.includes('maximum context') || msg.includes('context_length')) {
+            return 'context_length_exceeded';
+        }
+        if (msg.includes('content_filter') ||
+            msg.includes('content filter') ||
+            msg.includes('content_policy') ||
+            msg.includes('content policy') ||
+            msg.includes('moderation')) {
+            return 'content_filtered';
+        }
+        return 'invalid_request';
+    }
+    return 'unknown';
+}
+function parseRetryAfterSeconds(header) {
+    const asNum = Number(header);
+    if (Number.isFinite(asNum))
+        return asNum;
+    const asDate = Date.parse(header);
+    if (!Number.isNaN(asDate)) {
+        const secs = Math.round((asDate - Date.now()) / 1000);
+        return secs >= 0 ? secs : 0;
+    }
+    return null;
+}

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

@@ -0,0 +1,18 @@
+import { BaseConnector } from '../../base/base.connector';
+import type { EmbeddingsInput, EmbeddingsResult, IEmbeddingsConnector, OpenAICompatConfig } from '../../types';
+import type { OpenAICompatSpec } from './spec';
+/**
+ * The shared embeddings connector for OpenAI-float-shaped providers
+ * (`POST /embeddings`). Decoupled from chat (a separate operation surface).
+ * Requests `encoding_format: 'float'` and normalizes `data[].embedding` into
+ * `number[][]` in input order. Only wired for providers that expose a
+ * float-shaped embeddings endpoint (see `EMBEDDINGS_PROVIDER_IDS`).
+ */
+export declare class OpenAICompatEmbeddingsConnector extends BaseConnector implements IEmbeddingsConnector {
+    readonly id: string;
+    private readonly baseUrl;
+    private readonly spec;
+    private readonly config;
+    constructor(spec: OpenAICompatSpec, config: OpenAICompatConfig);
+    create(input: EmbeddingsInput): Promise<EmbeddingsResult>;
+}

package/dist/cjs/providers/_shared/openai-compat.embeddings.connector.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatEmbeddingsConnector = void 0;
+const base_connector_1 = require("../../base/base.connector");
+const types_1 = require("../../types");
+/**
+ * The shared embeddings connector for OpenAI-float-shaped providers
+ * (`POST /embeddings`). Decoupled from chat (a separate operation surface).
+ * Requests `encoding_format: 'float'` and normalizes `data[].embedding` into
+ * `number[][]` in input order. Only wired for providers that expose a
+ * float-shaped embeddings endpoint (see `EMBEDDINGS_PROVIDER_IDS`).
+ */
+class OpenAICompatEmbeddingsConnector extends base_connector_1.BaseConnector {
+    constructor(spec, config) {
+        super(config.fetch);
+        this.spec = spec;
+        this.id = spec.id;
+        this.config = config;
+        const baseUrl = config.baseUrl ?? spec.defaultBaseUrl;
+        if (!baseUrl) {
+            throw new types_1.ConnectorError({
+                message: `Provider '${spec.id}' requires an explicit \`baseUrl\` in config`,
+                statusCode: null,
+                providerCode: 'invalid_request',
+            });
+        }
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+    }
+    async create(input) {
+        const body = {
+            model: input.model,
+            input: input.input,
+            encoding_format: 'float',
+        };
+        if (input.dimensions !== undefined)
+            body.dimensions = input.dimensions;
+        if (input._passthrough?.body)
+            Object.assign(body, input._passthrough.body);
+        const headers = {
+            ...this.spec.buildAuthHeaders(this.config),
+            ...this.config.headers,
+            ...input._passthrough?.headers,
+        };
+        const url = (0, base_connector_1.appendPassthroughQuery)(`${this.baseUrl}/embeddings`, input._passthrough?.query);
+        const response = await this.sendPostJson(url, body, headers, input.signal);
+        if (!response.ok) {
+            const errBody = await response.json().catch(() => null);
+            throw mapVendorError(response.status, errBody, response.headers);
+        }
+        const json = this.requireDecodedBody((await response.json().catch(() => null)), response.status);
+        const rows = [...(json?.data ?? [])].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        const inputTokens = json?.usage?.prompt_tokens ?? 0;
+        return {
+            embeddings: rows.map((d) => d.embedding ?? []),
+            usage: { inputTokens, totalTokens: json?.usage?.total_tokens ?? inputTokens },
+            model: json?.model ?? input.model,
+            raw: json,
+        };
+    }
+}
+exports.OpenAICompatEmbeddingsConnector = OpenAICompatEmbeddingsConnector;
+function mapVendorError(status, body, headers) {
+    const message = extractErrorMessage(body) ?? `HTTP ${status}`;
+    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;
+    }
+    return new types_1.ConnectorError({
+        message,
+        statusCode: status,
+        providerCode: mapStatusToProviderCode(status),
+        providerMessage: message,
+        cause,
+    });
+}
+function extractErrorMessage(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 mapStatusToProviderCode(status) {
+    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)
+        return 'invalid_request';
+    return 'unknown';
+}

package/dist/cjs/providers/_shared/spec.d.ts

@@ -0,0 +1,99 @@
+import type { OpenAICompatConfig } from '../../types';
+/**
+ * Per-provider parameterization of the one shared OpenAI-compatible connector.
+ * Base URLs are current-as-of-2026 defaults and are the exact fact each
+ * per-connector README pins; treat as overridable via `config.baseUrl`.
+ */
+export interface OpenAICompatSpec {
+    id: string;
+    /** Default base URL (no trailing slash). Undefined ⇒ consumer must supply `config.baseUrl`. */
+    defaultBaseUrl?: string;
+    buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    /** Providers with no tool support on the primary chat surface (Perplexity Sonar). */
+    supportsTools?: boolean;
+    /** Vendor field name for max output tokens (default `max_tokens`). */
+    maxTokensField?: string;
+    /** Groq relocates streaming usage under `x_groq.usage` on the final chunk (baseline-exception). */
+    streamUsagePath?: 'x_groq';
+    /** Mistral rejects unknown params with HTTP 422 — skip OpenAI-only extras like `stream_options`. */
+    strictParams?: boolean;
+}
+export declare const SPECS: {
+    openai: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    'azure-openai': {
+        id: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    openrouter: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    groq: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+        streamUsagePath: "x_groq";
+    };
+    together: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    fireworks: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    deepseek: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    xai: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    mistral: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+        strictParams: true;
+    };
+    perplexity: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+        supportsTools: false;
+    };
+    deepinfra: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    cloudflare: {
+        id: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    vllm: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    ollama: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+    lmstudio: {
+        id: string;
+        defaultBaseUrl: string;
+        buildAuthHeaders: (config: OpenAICompatConfig) => Record<string, string>;
+    };
+};
+export type SpecId = keyof typeof SPECS;

package/dist/cjs/providers/_shared/spec.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECS = void 0;
+const bearer = (config) => config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {};
+exports.SPECS = {
+    openai: {
+        id: 'openai',
+        defaultBaseUrl: 'https://api.openai.com/v1',
+        buildAuthHeaders: bearer,
+    },
+    'azure-openai': {
+        id: 'azure-openai',
+        // no default: consumer supplies https://<resource>.openai.azure.com/openai/v1
+        buildAuthHeaders: (config) => config.apiKey ? { 'api-key': config.apiKey } : {},
+    },
+    openrouter: {
+        id: 'openrouter',
+        defaultBaseUrl: 'https://openrouter.ai/api/v1',
+        buildAuthHeaders: bearer,
+    },
+    groq: {
+        id: 'groq',
+        defaultBaseUrl: 'https://api.groq.com/openai/v1',
+        buildAuthHeaders: bearer,
+        streamUsagePath: 'x_groq',
+    },
+    together: {
+        id: 'together',
+        defaultBaseUrl: 'https://api.together.ai/v1',
+        buildAuthHeaders: bearer,
+    },
+    fireworks: {
+        id: 'fireworks',
+        defaultBaseUrl: 'https://api.fireworks.ai/inference/v1',
+        buildAuthHeaders: bearer,
+    },
+    deepseek: {
+        id: 'deepseek',
+        defaultBaseUrl: 'https://api.deepseek.com/v1',
+        buildAuthHeaders: bearer,
+    },
+    xai: {
+        id: 'xai',
+        defaultBaseUrl: 'https://api.x.ai/v1',
+        buildAuthHeaders: bearer,
+    },
+    mistral: {
+        id: 'mistral',
+        defaultBaseUrl: 'https://api.mistral.ai/v1',
+        buildAuthHeaders: bearer,
+        strictParams: true,
+    },
+    perplexity: {
+        id: 'perplexity',
+        defaultBaseUrl: 'https://api.perplexity.ai',
+        buildAuthHeaders: bearer,
+        supportsTools: false,
+    },
+    deepinfra: {
+        id: 'deepinfra',
+        defaultBaseUrl: 'https://api.deepinfra.com/v1/openai',
+        buildAuthHeaders: bearer,
+    },
+    cloudflare: {
+        id: 'cloudflare',
+        // no default: consumer supplies https://api.cloudflare.com/client/v4/accounts/<id>/ai/v1
+        buildAuthHeaders: bearer,
+    },
+    vllm: {
+        id: 'vllm',
+        defaultBaseUrl: 'http://localhost:8000/v1',
+        buildAuthHeaders: bearer,
+    },
+    ollama: {
+        id: 'ollama',
+        defaultBaseUrl: 'http://localhost:11434/v1',
+        buildAuthHeaders: bearer,
+    },
+    lmstudio: {
+        id: 'lmstudio',
+        defaultBaseUrl: 'http://localhost:1234/v1',
+        buildAuthHeaders: bearer,
+    },
+};

package/dist/cjs/providers/anthropic/anthropic.config.d.ts

@@ -0,0 +1,17 @@
+export interface AnthropicConfig {
+    /** Anthropic API key — sent as the `x-api-key` header (not Bearer). */
+    apiKey: string;
+    /** Override the base URL. Default `https://api.anthropic.com/v1`. */
+    baseUrl?: string;
+    /** `anthropic-version` header value. Default `2023-06-01`. */
+    anthropicVersion?: string;
+    /**
+     * Anthropic requires `max_tokens` on every request. Used when
+     * `ChatInput.maxOutputTokens` is omitted. Default 4096.
+     */
+    defaultMaxTokens?: number;
+    /** Bring-your-own fetch. Defaults to `globalThis.fetch`. */
+    fetch?: typeof fetch;
+    /** Extra headers merged onto every request. */
+    headers?: Record<string, string>;
+}

package/dist/cjs/providers/anthropic/anthropic.config.js

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

package/dist/cjs/providers/anthropic/anthropic.connector.d.ts

@@ -0,0 +1,30 @@
+import { BaseConnector } from '../../base/base.connector';
+import type { ChatInput, ChatResult, ChatStreamDelta, IChatConnector } from '../../types';
+import type { AnthropicConfig } from './anthropic.config';
+/**
+ * Native adapter for the Anthropic **Messages API** (`POST /v1/messages`).
+ * Anthropic is structurally different from OpenAI Chat Completions — different
+ * auth, a top-level `system`, typed content blocks, tool results carried inside
+ * a user turn, `stop_sequences`, and Anthropic-shaped SSE events — so this is a
+ * full translation layer, not an OpenAI passthrough. It emits the identical
+ * normalized `ChatResult` / `ChatStreamDelta` / `ConnectorError` as every other
+ * connector, so it is drop-in swappable via the `Chat` facade.
+ *
+ * Not normalized here (per D2/D4, surfaced via `raw` or `_passthrough`, never
+ * emulated): `responseFormat` (Anthropic has no `response_format` — use
+ * tool-based structured output via `_passthrough`); reasoning CoT output
+ * (`thinking` blocks land in `raw`); prompt caching (`cache_control` via
+ * `_passthrough`, cached-token counts in `raw`).
+ */
+export declare class AnthropicConnector extends BaseConnector implements IChatConnector {
+    readonly id = "anthropic";
+    private readonly baseUrl;
+    private readonly config;
+    constructor(config: AnthropicConfig);
+    complete(input: ChatInput): Promise<ChatResult>;
+    stream(input: ChatInput): AsyncGenerator<ChatStreamDelta>;
+    private authHeaders;
+    private buildRequest;
+    private parseResult;
+    private mapVendorError;
+}