@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/providers/anthropic-compat.js

@@ -0,0 +1,291 @@
+import { REASONING_BUDGET_MAP } from './interface.js';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { toAnthropicTools, toAnthropicMessages, fromAnthropicContent, } from './tool-formats.js';
+import { toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const ANTHROPIC_API_VERSION = '2023-06-01';
+/**
+ * AnthropicCompatProvider — generic provider for endpoints that speak the
+ * Anthropic Messages API (SSE streaming variant). Useful for self-hosted
+ * proxies, Claude-compatible services, and any backend that mirrors the
+ * Anthropic Messages API spec.
+ *
+ * Configured via a custom provider JSON file with `"type": "anthropic-compat"`
+ * in ~/.goodvibes/goodvibes/providers/.
+ */
+export class AnthropicCompatProvider {
+    name;
+    models;
+    baseURL;
+    apiKey;
+    defaultModel;
+    defaultHeaders;
+    authEnvVars;
+    serviceNames;
+    aliases;
+    subscriptionProviderId;
+    streamProtocol;
+    authHeaderMode;
+    allowAnonymous;
+    anonymousConfigured;
+    anonymousDetail;
+    constructor(opts) {
+        this.name = opts.name;
+        this.models = opts.models;
+        this.baseURL = opts.baseURL.replace(/\/$/, ''); // strip trailing slash
+        this.apiKey = opts.apiKey;
+        this.defaultModel = opts.defaultModel;
+        this.defaultHeaders = opts.defaultHeaders ?? {};
+        this.authEnvVars = opts.authEnvVars ?? [];
+        this.serviceNames = opts.serviceNames ?? [];
+        this.aliases = opts.aliases ?? [];
+        this.subscriptionProviderId = opts.subscriptionProviderId;
+        this.streamProtocol = opts.streamProtocol;
+        this.authHeaderMode = opts.authHeaderMode ?? 'x-api-key';
+        this.allowAnonymous = opts.allowAnonymous ?? false;
+        this.anonymousConfigured = opts.anonymousConfigured ?? false;
+        this.anonymousDetail = opts.anonymousDetail;
+    }
+    async chat(params) {
+        const { messages, tools, model, maxTokens, signal, systemPrompt, onDelta, reasoningEffort } = params;
+        return withRetry(async () => {
+            const resolvedModel = model ?? this.defaultModel;
+            const body = {
+                model: resolvedModel,
+                max_tokens: maxTokens ?? 8192,
+                messages: toAnthropicMessages(messages),
+                stream: true,
+            };
+            if (systemPrompt) {
+                body['system'] = systemPrompt;
+            }
+            if (tools && tools.length > 0) {
+                body['tools'] = toAnthropicTools(tools);
+            }
+            if (reasoningEffort && reasoningEffort !== 'instant') {
+                const budget = REASONING_BUDGET_MAP[reasoningEffort];
+                if (budget !== undefined && budget > 0) {
+                    body['thinking'] = { type: 'enabled', budget_tokens: budget };
+                    const currentMax = body['max_tokens'] ?? 8192;
+                    if (currentMax <= budget) {
+                        body['max_tokens'] = budget + 4096;
+                    }
+                }
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                'anthropic-version': ANTHROPIC_API_VERSION,
+                ...this.defaultHeaders,
+            };
+            if (this.apiKey) {
+                if (this.authHeaderMode === 'bearer') {
+                    headers['Authorization'] = `Bearer ${this.apiKey}`;
+                }
+                else {
+                    headers['x-api-key'] = this.apiKey;
+                }
+            }
+            if (body['thinking']) {
+                headers['anthropic-beta'] = 'interleaved-thinking-2025-05-14';
+            }
+            let res;
+            try {
+                res = await fetch(`${this.baseURL}/messages`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(body),
+                    signal,
+                });
+            }
+            catch (err) {
+                throw toProviderError(err, {
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'request',
+                });
+            }
+            if (!res.ok) {
+                const text = await res.text().catch(() => 'unknown error');
+                throw new ProviderError(`AnthropicCompat(${this.name}) API error ${res.status}: ${text}`, {
+                    statusCode: res.status,
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'request',
+                });
+            }
+            // Parse SSE stream
+            let responseText = '';
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let cacheReadTokens = 0;
+            let cacheWriteTokens = 0;
+            let stopReason = 'end';
+            // Accumulate tool use blocks by index
+            const toolBlocks = new Map();
+            const reader = res.body?.getReader();
+            if (!reader) {
+                throw new ProviderError(`AnthropicCompat(${this.name}) returned no response body.`, {
+                    statusCode: 502,
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'response',
+                });
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6).trim();
+                        if (!data || data === '[DONE]')
+                            continue;
+                        let event;
+                        try {
+                            event = JSON.parse(data);
+                        }
+                        catch {
+                            logger.debug('AnthropicCompat SSE: failed to parse JSON chunk', { data });
+                            continue;
+                        }
+                        if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                            const idx = event.index ?? 0;
+                            toolBlocks.set(idx, {
+                                id: event.content_block.id ?? '',
+                                name: event.content_block.name ?? '',
+                                args: '',
+                            });
+                            if (onDelta) {
+                                onDelta({ toolCalls: [{ index: idx, id: event.content_block.id, name: event.content_block.name }] });
+                            }
+                        }
+                        else if (event.type === 'content_block_delta') {
+                            const idx = event.index ?? 0;
+                            if (event.delta?.type === 'text_delta' && event.delta.text) {
+                                responseText += event.delta.text;
+                                if (onDelta)
+                                    onDelta({ content: event.delta.text });
+                            }
+                            else if (event.delta?.type === 'thinking_delta' && event.delta.thinking) {
+                                if (onDelta)
+                                    onDelta({ reasoning: event.delta.thinking });
+                            }
+                            else if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
+                                const block = toolBlocks.get(idx);
+                                if (block)
+                                    block.args += event.delta.partial_json;
+                                if (onDelta) {
+                                    onDelta({ toolCalls: [{ index: idx, arguments: event.delta.partial_json }] });
+                                }
+                            }
+                        }
+                        else if (event.type === 'message_delta') {
+                            if (event.delta?.stop_reason === 'tool_use')
+                                stopReason = 'tool_use';
+                            else if (event.delta?.stop_reason === 'max_tokens')
+                                stopReason = 'max_tokens';
+                            if (event.usage?.output_tokens)
+                                outputTokens = event.usage.output_tokens;
+                            if (event.usage?.cache_read_input_tokens != null)
+                                cacheReadTokens = event.usage.cache_read_input_tokens;
+                            if (event.usage?.cache_creation_input_tokens != null)
+                                cacheWriteTokens = event.usage.cache_creation_input_tokens;
+                        }
+                        else if (event.type === 'message_start') {
+                            if (event.message?.usage) {
+                                inputTokens = event.message.usage.input_tokens;
+                                outputTokens = event.message.usage.output_tokens;
+                                cacheReadTokens = event.message.usage.cache_read_input_tokens ?? 0;
+                                cacheWriteTokens = event.message.usage.cache_creation_input_tokens ?? 0;
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            // Assemble content blocks
+            const contentBlocks = [];
+            if (responseText) {
+                contentBlocks.push({ type: 'text', text: responseText });
+            }
+            for (const [, block] of [...toolBlocks.entries()].sort(([a], [b]) => a - b)) {
+                let parsedInput = {};
+                try {
+                    parsedInput = JSON.parse(block.args || '{}');
+                }
+                catch {
+                    logger.debug('AnthropicCompat: failed to parse tool args JSON', { name: block.name, args: block.args });
+                    parsedInput = {};
+                }
+                contentBlocks.push({
+                    type: 'tool_use',
+                    id: block.id,
+                    name: block.name,
+                    input: parsedInput,
+                });
+            }
+            const { text, toolCalls } = fromAnthropicContent(contentBlocks);
+            return {
+                content: text,
+                toolCalls,
+                usage: { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens },
+                stopReason,
+            };
+        });
+    }
+    async describeRuntime(deps) {
+        const { buildStandardProviderAuthRoutes } = await import('./runtime-metadata.js');
+        const authRoutes = await buildStandardProviderAuthRoutes({
+            providerId: this.name,
+            apiKeyEnvVars: this.authEnvVars,
+            secretKeys: this.authEnvVars,
+            serviceNames: this.serviceNames,
+            ...(this.subscriptionProviderId ? { subscriptionProviderId: this.subscriptionProviderId } : {}),
+            allowAnonymous: this.allowAnonymous,
+            anonymousConfigured: this.anonymousConfigured,
+            anonymousDetail: this.anonymousDetail,
+        }, deps);
+        return {
+            auth: {
+                mode: this.allowAnonymous && !this.apiKey ? 'anonymous' : 'api-key',
+                configured: Boolean(this.apiKey) || this.anonymousConfigured,
+                detail: this.apiKey
+                    ? `API key for ${this.name} is available`
+                    : this.allowAnonymous
+                        ? (this.anonymousDetail ?? `${this.name} can be used without a stored API key`)
+                        : `API key for ${this.name} is not configured`,
+                ...(this.authEnvVars.length > 0 ? { envVars: this.authEnvVars } : {}),
+                routes: authRoutes,
+            },
+            models: {
+                defaultModel: this.defaultModel,
+                models: this.models,
+                ...(this.aliases.length > 0 ? { aliases: this.aliases } : {}),
+            },
+            usage: {
+                streaming: true,
+                toolCalling: true,
+                parallelTools: true,
+                promptCaching: true,
+                notes: ['Anthropic prompt caching and thinking controls are surfaced through the compat wrapper.'],
+            },
+            policy: {
+                local: false,
+                streamProtocol: this.streamProtocol ?? 'anthropic-sse',
+                reasoningMode: 'thinking_budget',
+                supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+                cacheStrategy: 'anthropic-prompt-cache',
+            },
+        };
+    }
+}

package/dist/_internal/platform/providers/anthropic-sdk-provider.d.ts

@@ -0,0 +1,37 @@
+import type { ChatRequest, ChatResponse, LLMProvider, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+type AnthropicStreamCapableClient = {
+    messages: {
+        stream: unknown;
+    };
+};
+export interface AnthropicSdkProviderAuthConfig {
+    readonly mode: 'api-key' | 'anonymous';
+    readonly configured: boolean;
+    readonly detail: string;
+    readonly envVars?: readonly string[];
+    readonly secretKeys?: readonly string[];
+    readonly serviceNames?: readonly string[];
+    readonly allowAnonymous?: boolean;
+    readonly anonymousConfigured?: boolean;
+    readonly anonymousDetail?: string;
+}
+export interface AnthropicSdkProviderOptions {
+    readonly name: string;
+    readonly label: string;
+    readonly defaultModel: string;
+    readonly models: readonly string[];
+    readonly createClient: () => AnthropicStreamCapableClient;
+    readonly auth: AnthropicSdkProviderAuthConfig;
+    readonly streamProtocol: string;
+    readonly notes?: readonly string[];
+}
+export declare class AnthropicSdkProvider implements LLMProvider {
+    private readonly options;
+    readonly name: string;
+    readonly models: string[];
+    constructor(options: AnthropicSdkProviderOptions);
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+}
+export {};
+//# sourceMappingURL=anthropic-sdk-provider.d.ts.map

package/dist/_internal/platform/providers/anthropic-sdk-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-sdk-provider.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/anthropic-sdk-provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AAexB,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE;QACR,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;CACH,CAAC;AAoBF,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,4BAA4B,CAAC;IAC1D,QAAQ,CAAC,IAAI,EAAE,8BAA8B,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,qBAAa,oBAAqB,YAAW,WAAW;IAI1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;gBAEG,OAAO,EAAE,2BAA2B;IAK3D,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAkHhD,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAqC3F"}

package/dist/_internal/platform/providers/anthropic-sdk-provider.js

@@ -0,0 +1,173 @@
+import { REASONING_BUDGET_MAP } from './interface.js';
+import { fromAnthropicContent, toAnthropicMessages, toAnthropicTools, } from './tool-formats.js';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { buildStandardProviderAuthRoutes } from './runtime-metadata.js';
+import { toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const DEFAULT_MAX_OUTPUT = 8192;
+function normalizeAnthropicModel(model) {
+    if (model.startsWith('anthropic:'))
+        return model.slice('anthropic:'.length);
+    if (model.startsWith('anthropic/'))
+        return model.slice('anthropic/'.length);
+    return model;
+}
+export class AnthropicSdkProvider {
+    options;
+    name;
+    models;
+    constructor(options) {
+        this.options = options;
+        this.name = options.name;
+        this.models = [...options.models];
+    }
+    async chat(params) {
+        return withRetry(async () => {
+            const client = this.options.createClient();
+            const resolvedModel = normalizeAnthropicModel(params.model ?? this.options.defaultModel);
+            const body = {
+                model: resolvedModel,
+                max_tokens: params.maxTokens ?? DEFAULT_MAX_OUTPUT,
+                messages: toAnthropicMessages(params.messages),
+                stream: true,
+            };
+            if (params.systemPrompt) {
+                body['system'] = params.systemPrompt;
+            }
+            if (params.tools && params.tools.length > 0) {
+                body['tools'] = toAnthropicTools(params.tools);
+            }
+            if (params.reasoningEffort && params.reasoningEffort !== 'instant') {
+                const budget = REASONING_BUDGET_MAP[params.reasoningEffort];
+                if (typeof budget === 'number' && budget > 0) {
+                    body['thinking'] = { type: 'enabled', budget_tokens: budget };
+                    const currentMax = body['max_tokens'] ?? DEFAULT_MAX_OUTPUT;
+                    if (currentMax <= budget)
+                        body['max_tokens'] = budget + 4096;
+                }
+            }
+            const toolBlocks = new Map();
+            let responseText = '';
+            let stopReason = 'end';
+            try {
+                const streamFactory = client.messages.stream;
+                const stream = streamFactory(body, params.signal ? { signal: params.signal } : undefined);
+                for await (const event of stream) {
+                    if (event.type === 'content_block_start' && event.content_block.type === 'tool_use') {
+                        const idx = event.index ?? 0;
+                        toolBlocks.set(idx, {
+                            id: event.content_block.id ?? '',
+                            name: event.content_block.name ?? '',
+                            args: '',
+                        });
+                        params.onDelta?.({
+                            toolCalls: [{ index: idx, id: event.content_block.id, name: event.content_block.name }],
+                        });
+                    }
+                    else if (event.type === 'content_block_delta') {
+                        const idx = event.index ?? 0;
+                        if (event.delta.type === 'text_delta' && event.delta.text) {
+                            responseText += event.delta.text;
+                            params.onDelta?.({ content: event.delta.text });
+                        }
+                        else if (event.delta.type === 'thinking_delta' && event.delta.thinking) {
+                            params.onDelta?.({ reasoning: event.delta.thinking });
+                        }
+                        else if (event.delta.type === 'input_json_delta' && event.delta.partial_json) {
+                            const block = toolBlocks.get(idx);
+                            if (block)
+                                block.args += event.delta.partial_json;
+                            params.onDelta?.({
+                                toolCalls: [{ index: idx, arguments: event.delta.partial_json }],
+                            });
+                        }
+                    }
+                    else if (event.type === 'message_delta') {
+                        if (event.delta.stop_reason === 'tool_use')
+                            stopReason = 'tool_use';
+                        else if (event.delta.stop_reason === 'max_tokens')
+                            stopReason = 'max_tokens';
+                    }
+                }
+                const finalMessage = await stream.finalMessage();
+                const contentBlocks = [];
+                if (responseText) {
+                    contentBlocks.push({ type: 'text', text: responseText });
+                }
+                for (const [, block] of [...toolBlocks.entries()].sort(([a], [b]) => a - b)) {
+                    let parsedInput = {};
+                    try {
+                        parsedInput = JSON.parse(block.args || '{}');
+                    }
+                    catch {
+                        parsedInput = {};
+                    }
+                    contentBlocks.push({
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: parsedInput,
+                    });
+                }
+                const parsed = contentBlocks.length > 0
+                    ? fromAnthropicContent(contentBlocks)
+                    : fromAnthropicContent(finalMessage.content);
+                return {
+                    content: parsed.text,
+                    toolCalls: parsed.toolCalls,
+                    usage: {
+                        inputTokens: finalMessage.usage.input_tokens,
+                        outputTokens: finalMessage.usage.output_tokens,
+                        ...(finalMessage.usage.cache_read_input_tokens != null ? { cacheReadTokens: finalMessage.usage.cache_read_input_tokens } : {}),
+                        ...(finalMessage.usage.cache_creation_input_tokens != null ? { cacheWriteTokens: finalMessage.usage.cache_creation_input_tokens } : {}),
+                    },
+                    stopReason,
+                };
+            }
+            catch (error) {
+                throw toProviderError(error, {
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'stream',
+                });
+            }
+        });
+    }
+    async describeRuntime(deps) {
+        const authRoutes = await buildStandardProviderAuthRoutes({
+            providerId: this.options.name,
+            apiKeyEnvVars: this.options.auth.envVars,
+            secretKeys: this.options.auth.secretKeys,
+            serviceNames: this.options.auth.serviceNames,
+            allowAnonymous: this.options.auth.allowAnonymous,
+            anonymousConfigured: this.options.auth.anonymousConfigured,
+            anonymousDetail: this.options.auth.anonymousDetail,
+        }, deps);
+        return {
+            auth: {
+                mode: this.options.auth.mode,
+                configured: this.options.auth.configured,
+                detail: this.options.auth.detail,
+                ...(this.options.auth.envVars ? { envVars: this.options.auth.envVars } : {}),
+                routes: authRoutes,
+            },
+            models: {
+                defaultModel: this.options.defaultModel,
+                models: this.models,
+            },
+            usage: {
+                streaming: true,
+                toolCalling: true,
+                parallelTools: true,
+                promptCaching: true,
+                ...(this.options.notes ? { notes: this.options.notes } : {}),
+            },
+            policy: {
+                local: false,
+                streamProtocol: this.options.streamProtocol,
+                reasoningMode: 'thinking_budget',
+                supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+            },
+        };
+    }
+}

package/dist/_internal/platform/providers/anthropic-vertex.d.ts

@@ -0,0 +1,5 @@
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.js';
+export declare class AnthropicVertexProvider extends AnthropicSdkProvider {
+    constructor();
+}
+//# sourceMappingURL=anthropic-vertex.d.ts.map

package/dist/_internal/platform/providers/anthropic-vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-vertex.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/anthropic-vertex.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAsBnE,qBAAa,uBAAwB,SAAQ,oBAAoB;;CAmChE"}

package/dist/_internal/platform/providers/anthropic-vertex.js

@@ -0,0 +1,53 @@
+import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.js';
+const VERTEX_MODELS = [
+    'claude-sonnet-4-6',
+    'claude-opus-4-6',
+    'claude-haiku-4-5',
+];
+function resolveVertexProjectId() {
+    return process.env['ANTHROPIC_VERTEX_PROJECT_ID']
+        ?? process.env['GOOGLE_CLOUD_PROJECT']
+        ?? process.env['GOOGLE_CLOUD_PROJECT_ID']
+        ?? null;
+}
+function hasVertexCredentials() {
+    return Boolean(resolveVertexProjectId()
+        && (process.env['GOOGLE_APPLICATION_CREDENTIALS'] || process.env['ANTHROPIC_VERTEX_USE_GCP_METADATA'] === '1'));
+}
+export class AnthropicVertexProvider extends AnthropicSdkProvider {
+    constructor() {
+        const configured = hasVertexCredentials();
+        super({
+            name: 'anthropic-vertex',
+            label: 'Anthropic Vertex',
+            defaultModel: 'claude-sonnet-4-6',
+            models: VERTEX_MODELS,
+            createClient: () => new AnthropicVertex({
+                projectId: resolveVertexProjectId(),
+                region: process.env['GOOGLE_CLOUD_LOCATION'] ?? process.env['CLOUD_ML_REGION'] ?? 'global',
+            }),
+            auth: {
+                mode: configured ? 'api-key' : 'anonymous',
+                configured,
+                detail: configured
+                    ? 'Google Cloud Vertex credentials are available for Anthropic Vertex.'
+                    : 'Configure project ID plus GOOGLE_APPLICATION_CREDENTIALS or metadata-based auth for Anthropic Vertex.',
+                envVars: [
+                    'ANTHROPIC_VERTEX_PROJECT_ID',
+                    'GOOGLE_CLOUD_PROJECT',
+                    'GOOGLE_CLOUD_PROJECT_ID',
+                    'GOOGLE_CLOUD_LOCATION',
+                    'CLOUD_ML_REGION',
+                    'GOOGLE_APPLICATION_CREDENTIALS',
+                    'ANTHROPIC_VERTEX_USE_GCP_METADATA',
+                ],
+                allowAnonymous: true,
+                anonymousConfigured: Boolean(resolveVertexProjectId()),
+                anonymousDetail: 'Anthropic Vertex can use Google ADC or workload identity without a stored API key.',
+            },
+            streamProtocol: 'anthropic-sdk-stream',
+            notes: ['Anthropic Vertex is backed by Google ADC / Vertex auth rather than a provider API key.'],
+        });
+    }
+}

package/dist/_internal/platform/providers/anthropic.d.ts

@@ -0,0 +1,18 @@
+import type { LLMProvider, ChatRequest, ChatResponse, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+import type { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
+/**
+ * AnthropicProvider — calls the Anthropic Messages API directly via fetch.
+ * System message is a top-level field (not a message). Tool results are
+ * `tool_result` content blocks inside `user` messages.
+ * Supports SSE streaming when onDelta is provided.
+ */
+export declare class AnthropicProvider implements LLMProvider {
+    readonly name = "anthropic";
+    readonly models: string[];
+    private readonly apiKey;
+    private readonly cacheHitTracker;
+    constructor(apiKey: string, cacheHitTracker?: Pick<CacheHitTracker, 'getHitRate' | 'recordTurn'>);
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+}
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/_internal/platform/providers/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAInI,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,yDAAyD,CAAC;AAwE7G;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IACnD,QAAQ,CAAC,IAAI,eAAe;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAM;IAE/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqD;gBAGnF,MAAM,EAAE,MAAM,EACd,eAAe,GAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,YAAY,CAA0B;IAMxF,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAkUhD,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAkC3F"}