litellmts-core 1.0.1 → 2.0.0

package/dist/handlers/gemini.js

@@ -1,78 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiHandler = GeminiHandler;
-const generative_ai_1 = require("@google/generative-ai");
-const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
-function toGeminiContent(messages) {
-    return messages.map((msg) => {
-        const parts = [];
-        if (msg.content) {
-            parts.push({ text: msg.content });
-        }
-        return {
-            role: msg.role === 'assistant' ? 'model' : msg.role,
-            parts,
-        };
-    });
-}
-function toFinishReason(reason) {
-    switch (reason) {
-        case 'STOP':
-            return 'stop';
-        case 'MAX_TOKENS':
-            return 'length';
-        default:
-            return 'stop';
-    }
-}
-function toUsage(meta) {
-    if (!meta)
-        return undefined;
-    return {
-        prompt_tokens: meta.promptTokenCount,
-        completion_tokens: meta.candidatesTokenCount,
-        total_tokens: meta.totalTokenCount,
-    };
-}
-function toResponse(response, model) {
-    const candidate = response.candidates?.[0];
-    return {
-        model: model,
-        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        usage: toUsage(response.usageMetadata),
-        choices: [
-            {
-                index: candidate?.index ?? 0,
-                finish_reason: toFinishReason(candidate?.finishReason),
-                message: {
-                    role: 'assistant',
-                    content: candidate ? candidate.content.parts.map((p) => 'text' in p ? p.text : '').join('') : null,
-                },
-            },
-        ],
-    };
-}
-async function* toStreamingResponse(stream) {
-    for await (const chunk of stream) {
-        const candidate = chunk.candidates?.[0];
-        const deltaContent = candidate?.content.parts.map((p) => 'text' in p ? p.text : '').join('') ?? '';
-        yield {
-            model: undefined,
-            created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-            usage: toUsage(chunk.usageMetadata),
-            choices: [
-                {
-                    index: candidate?.index ?? 0,
-                    finish_reason: toFinishReason(candidate?.finishReason),
-                    delta: {
-                        content: deltaContent,
-                        role: 'assistant',
-                    },
-                },
-            ],
-        };
-    }
-}
+const genai_1 = require("@google/genai");
+const gemini_1 = require("../utils/gemini");
 async function GeminiHandler(params) {
     const apiKey = params.apiKey ?? process.env.GEMINI_API_KEY;
     if (!apiKey)
@@ -80,23 +10,50 @@ async function GeminiHandler(params) {
     const modelName = params.model.startsWith('gemini/')
         ? params.model.slice(7)
         : params.model;
-    const genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
-    const model = genAI.getGenerativeModel({
-        model: modelName,
-        generationConfig: {
-            temperature: params.temperature ?? undefined,
-            topP: params.top_p ?? undefined,
-            maxOutputTokens: params.max_tokens ?? undefined,
-            stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
-        },
-    });
-    const contents = toGeminiContent(params.messages);
-    if (params.stream) {
-        const result = await model.generateContentStream({ contents });
-        return toStreamingResponse(result.stream);
+    const client = new genai_1.GoogleGenAI({ apiKey });
+    const contents = (0, gemini_1.toGeminiContent)(params.messages);
+    try {
+        if (params.stream) {
+            const stream = await client.models.generateContentStream({
+                model: modelName,
+                contents,
+                config: {
+                    temperature: params.temperature ?? undefined,
+                    topP: params.top_p ?? undefined,
+                    maxOutputTokens: params.max_tokens ?? undefined,
+                    stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
+                },
+            });
+            return (0, gemini_1.toStreamingResponse)(stream, modelName);
+        }
+        const response = await client.models.generateContent({
+            model: modelName,
+            contents,
+            config: {
+                temperature: params.temperature ?? undefined,
+                topP: params.top_p ?? undefined,
+                maxOutputTokens: params.max_tokens ?? undefined,
+                stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
+            },
+        });
+        return (0, gemini_1.toResponse)(response, modelName);
+    }
+    catch (err) {
+        throw new Error(`Gemini API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
-    const result = await model.generateContent({ contents });
-    return toResponse(result.response, modelName);
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('gemini/', GeminiHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('gemini', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.GEMINI_API_KEY;
+    if (!key)
+        return [];
+    const client = new genai_1.GoogleGenAI({ apiKey: key });
+    const pager = await client.models.list();
+    const models = [];
+    for await (const m of pager) {
+        models.push({ id: m.name ?? m.displayName, provider: 'gemini' });
+    }
+    return models;
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('gemini/', GeminiHandler);

package/dist/handlers/geminiEmbedding.d.ts

@@ -1,2 +1,2 @@
-import { EmbeddingParams, EmbeddingResponse } from '../types';
+import type { EmbeddingParams, EmbeddingResponse } from '../types';
 export declare function GeminiEmbeddingHandler(params: EmbeddingParams): Promise<EmbeddingResponse>;

package/dist/handlers/geminiEmbedding.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiEmbeddingHandler = GeminiEmbeddingHandler;
-const generative_ai_1 = require("@google/generative-ai");
+const genai_1 = require("@google/genai");
 async function GeminiEmbeddingHandler(params) {
     const apiKey = params.apiKey ?? process.env.GEMINI_API_KEY;
     if (!apiKey)
@@ -9,20 +9,17 @@ async function GeminiEmbeddingHandler(params) {
     const modelName = params.model.startsWith('gemini/')
         ? params.model.slice(7)
         : params.model;
-    const genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
-    const model = genAI.getGenerativeModel({ model: modelName });
+    const client = new genai_1.GoogleGenAI({ apiKey });
     const input = typeof params.input === 'string'
         ? params.input
         : params.input.join(' ');
-    const result = await model.embedContent({
-        content: {
-            role: 'user',
-            parts: [{ text: input }],
-        },
+    const result = await client.models.embedContent({
+        model: modelName,
+        contents: [{ role: 'user', parts: [{ text: input }] }],
     });
     return {
         model: modelName,
-        data: [{ embedding: result.embedding.values, index: 0 }],
+        data: [{ embedding: result.embeddings?.[0]?.values ?? [], index: 0 }],
     };
 }
 const registry_1 = require("../registry");

package/dist/handlers/mistral.js

@@ -21,7 +21,9 @@ async function MistralHandler(params) {
     const apiKey = params.apiKey ?? process.env.MISTRAL_API_KEY;
     if (!apiKey)
         throw new Error('Mistral requires an API key. Set MISTRAL_API_KEY environment variable or pass apiKey in params.');
-    const model = params.model.split('mistral/')[1];
+    const model = params.model.startsWith('mistral/')
+        ? params.model.slice(8)
+        : params.model;
     const res = await getMistralResponse(model, params.messages, baseUrl, apiKey, params.stream ?? false);
     if (!res.ok) {
         throw new Error(`Mistral API error: ${res.status} ${res.statusText}`);
@@ -52,5 +54,18 @@ async function MistralHandler(params) {
     };
     return result;
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('mistral/', MistralHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('mistral', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.MISTRAL_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.mistral.ai/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok)
+        return [];
+    const { data } = await res.json();
+    return (data ?? []).map((m) => ({ id: m.id, provider: 'mistral' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('mistral/', MistralHandler);

package/dist/handlers/mistralEmbedding.js

@@ -15,7 +15,9 @@ async function getMistralResponse(model, input, baseUrl, apiKey) {
     });
 }
 async function MistralEmbeddingHandler(params) {
-    const model = params.model.split('mistral/')[1];
+    const model = params.model.startsWith('mistral/')
+        ? params.model.slice(8)
+        : params.model;
     const baseUrl = params.baseUrl ?? 'https://api.mistral.ai';
     const apiKey = params.apiKey ?? process.env.MISTRAL_API_KEY;
     if (!apiKey)

package/dist/handlers/ollama.js

@@ -67,7 +67,9 @@ async function getOllamaResponse(model, prompt, baseUrl) {
 }
 async function OllamaHandler(params) {
     const baseUrl = params.baseUrl ?? 'http://127.0.0.1:11434';
-    const model = params.model.split('ollama/')[1];
+    const model = params.model.startsWith('ollama/')
+        ? params.model.slice(7)
+        : params.model;
     const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
     const res = await getOllamaResponse(model, prompt, baseUrl);
     if (!res.ok) {
@@ -81,9 +83,17 @@ async function OllamaHandler(params) {
         chunks.push(chunk);
     }
     const message = chunks.reduce((acc, chunk) => {
-        return (acc += chunk.choices[0].delta.content);
+        return acc + chunk.choices[0].delta.content;
     }, '');
     return toResponse(message, model, prompt);
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('ollama/', OllamaHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('ollama', async () => {
+    const res = await fetch('http://127.0.0.1:11434/api/tags');
+    if (!res.ok)
+        return [];
+    const { models } = await res.json();
+    return (models ?? []).map((m) => ({ id: m.name, provider: 'ollama' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('ollama/', OllamaHandler);

package/dist/handlers/ollamaEmbedding.js

@@ -16,11 +16,13 @@ async function getOllamaResponse(model, input, baseUrl) {
     });
 }
 async function OllamaEmbeddingHandler(params) {
-    const model = params.model.split('ollama/')[1];
+    const model = params.model.startsWith('ollama/')
+        ? params.model.slice(7)
+        : params.model;
     const baseUrl = params.baseUrl ?? 'http://127.0.0.1:11434';
     const input = typeof params.input === 'string'
         ? params.input
-        : params.input.reduce((acc, curr) => (acc += curr), '');
+        : params.input.reduce((acc, curr) => acc + curr, '');
     const response = await getOllamaResponse(model, input, baseUrl);
     if (!response.ok) {
         throw new Error(`Received an error with code ${response.status} from Ollama API.`);

package/dist/handlers/openai.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIHandler = OpenAIHandler;
 const openai_1 = __importDefault(require("openai"));
+const registry_1 = require("../models/registry");
 function toOpenAIMessages(messages) {
     return messages;
 }
@@ -31,24 +32,41 @@ async function OpenAIHandler(params) {
     const { apiKey: providedApiKey, baseUrl: providedBaseUrl, ...completionsParams } = params;
     const apiKey = providedApiKey ?? process.env.OPENAI_API_KEY;
     const baseUrl = providedBaseUrl ?? 'https://api.openai.com/v1';
+    const modelName = completionsParams.model.startsWith('openai/')
+        ? completionsParams.model.slice(7)
+        : completionsParams.model;
     const openai = new openai_1.default({
         apiKey: apiKey,
         baseURL: baseUrl,
     });
     const messages = toOpenAIMessages(completionsParams.messages);
     if (params.stream) {
-        const response = await openai.chat.completions.create({
+        let response;
+        try {
+            response = await openai.chat.completions.create({
+                ...completionsParams,
+                model: modelName,
+                stream: true,
+                messages,
+            });
+        }
+        catch (err) {
+            throw new Error(`OpenAI API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        return toStreamingResponse(response);
+    }
+    let response;
+    try {
+        response = await openai.chat.completions.create({
             ...completionsParams,
-            stream: true,
+            model: modelName,
+            stream: false,
             messages,
         });
-        return toStreamingResponse(response);
     }
-    const response = await openai.chat.completions.create({
-        ...completionsParams,
-        stream: false,
-        messages,
-    });
+    catch (err) {
+        throw new Error(`OpenAI API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
     const result = {
         created: response.created,
         model: response.model,
@@ -71,6 +89,15 @@ async function OpenAIHandler(params) {
     };
     return result;
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('gpt-', OpenAIHandler);
-(0, registry_1.registerCompletionHandler)('openai/', OpenAIHandler);
+(0, registry_1.registerModelProvider)('openai', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.openai.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    const { data } = await res.json();
+    return data.map((m) => ({ id: m.id, provider: 'openai', created: m.created }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('openai/', OpenAIHandler);

package/dist/handlers/openaiEmbedding.js

@@ -8,11 +8,19 @@ const openai_1 = __importDefault(require("openai"));
 async function OpenAIEmbeddingHandler(params) {
     const apiKey = params.apiKey ?? process.env.OPENAI_API_KEY;
     const baseUrl = params.baseUrl;
+    const modelName = params.model.startsWith('openai/')
+        ? params.model.slice(7)
+        : params.model;
     const openai = new openai_1.default({
         apiKey: apiKey,
         baseURL: baseUrl,
     });
-    return openai.embeddings.create({ input: params.input, model: params.model });
+    try {
+        return await openai.embeddings.create({ input: params.input, model: modelName });
+    }
+    catch (err) {
+        throw new Error(`OpenAI embedding API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
 }
 const registry_1 = require("../registry");
-(0, registry_1.registerEmbeddingHandler)('text-embedding-', OpenAIEmbeddingHandler);
+(0, registry_1.registerEmbeddingHandler)('openai/', OpenAIEmbeddingHandler);

package/dist/handlers/openaiLike.d.ts

@@ -1,3 +1,3 @@
 import type { Handler } from '../types';
 import type { OpenAILikeConfig } from '../mappings/openaiLike';
-export declare function createOpenAILikeHandler(config: OpenAILikeConfig): Handler;
+export declare function createOpenAILikeHandler(prefix: string, config: OpenAILikeConfig): Handler;

package/dist/handlers/openaiLike.js

@@ -2,21 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAILikeHandler = createOpenAILikeHandler;
 const openai_1 = require("./openai");
-function createOpenAILikeHandler(config) {
+const registry_1 = require("../models/registry");
+function createOpenAILikeHandler(prefix, config) {
     return async (params) => {
         const apiKey = params.apiKey ?? process.env[config.apiKeyEnv];
         if (!apiKey) {
             throw new Error(`${config.name} requires an API key. Set the ${config.apiKeyEnv} environment variable or pass apiKey in params.`);
         }
+        const modelName = params.model.startsWith(prefix)
+            ? params.model.slice(prefix.length)
+            : params.model;
         return (0, openai_1.OpenAIHandler)({
             ...params,
+            model: modelName,
             apiKey,
             baseUrl: config.baseUrl,
         });
     };
 }
 const openaiLike_1 = require("../mappings/openaiLike");
-const registry_1 = require("../registry");
+const registry_2 = require("../registry");
 for (const [prefix, config] of Object.entries(openaiLike_1.OPENAI_LIKE_MAPPINGS)) {
-    (0, registry_1.registerCompletionHandler)(prefix, createOpenAILikeHandler(config));
+    (0, registry_2.registerCompletionHandler)(prefix, createOpenAILikeHandler(prefix, config));
+    const provider = prefix.replace('/', '');
+    (0, registry_1.registerModelProvider)(provider, async ({ apiKey } = {}) => {
+        const key = apiKey ?? process.env[config.apiKeyEnv];
+        if (!key)
+            return [];
+        try {
+            const res = await fetch(`${config.baseUrl}/models`, {
+                headers: { Authorization: `Bearer ${key}` },
+            });
+            if (!res.ok)
+                return [];
+            const { data } = await res.json();
+            return (data ?? []).map((m) => ({ id: m.id, provider }));
+        }
+        catch {
+            return [];
+        }
+    });
 }

package/dist/handlers/openaiLikeEmbedding.d.ts

@@ -1,3 +1,3 @@
 import type { EmbeddingParams, EmbeddingResponse } from '../types';
 import type { OpenAILikeConfig } from '../mappings/openaiLike';
-export declare function createOpenAILikeEmbeddingHandler(config: OpenAILikeConfig): (params: EmbeddingParams) => Promise<EmbeddingResponse>;
+export declare function createOpenAILikeEmbeddingHandler(prefix: string, config: OpenAILikeConfig): (params: EmbeddingParams) => Promise<EmbeddingResponse>;

package/dist/handlers/openaiLikeEmbedding.js

@@ -2,14 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAILikeEmbeddingHandler = createOpenAILikeEmbeddingHandler;
 const openaiEmbedding_1 = require("./openaiEmbedding");
-function createOpenAILikeEmbeddingHandler(config) {
+function createOpenAILikeEmbeddingHandler(prefix, config) {
     return async (params) => {
         const apiKey = params.apiKey ?? process.env[config.apiKeyEnv];
         if (!apiKey) {
             throw new Error(`${config.name} requires an API key. Set the ${config.apiKeyEnv} environment variable or pass apiKey in params.`);
         }
+        const modelName = params.model.startsWith(prefix)
+            ? params.model.slice(prefix.length)
+            : params.model;
         return (0, openaiEmbedding_1.OpenAIEmbeddingHandler)({
             ...params,
+            model: modelName,
             apiKey,
             baseUrl: config.baseUrl,
         });
@@ -18,5 +22,5 @@ function createOpenAILikeEmbeddingHandler(config) {
 const openaiLike_1 = require("../mappings/openaiLike");
 const registry_1 = require("../registry");
 for (const [prefix, config] of Object.entries(openaiLike_1.OPENAI_LIKE_MAPPINGS)) {
-    (0, registry_1.registerEmbeddingHandler)(prefix, createOpenAILikeEmbeddingHandler(config));
+    (0, registry_1.registerEmbeddingHandler)(prefix, createOpenAILikeEmbeddingHandler(prefix, config));
 }

package/dist/handlers/replicate.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReplicateHandler = ReplicateHandler;
 const replicate_1 = __importDefault(require("replicate"));
-const eventsource_1 = __importDefault(require("eventsource"));
+const eventsource_1 = require("eventsource");
 const combinePrompts_1 = require("../utils/combinePrompts");
 const toUsage_1 = require("../utils/toUsage");
 const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
@@ -16,10 +16,11 @@ async function sleep(time) {
         }, time);
     });
 }
-async function handleNonStreamingPrediction(prompt, prediction, replicate) {
+async function handleNonStreamingPrediction(prompt, prediction, replicate, modelName) {
     const pred = await replicate.wait(prediction, {});
-    const output = pred.output.reduce((acc, curr) => (acc += curr), '');
+    const output = pred.output.reduce((acc, curr) => acc + curr, '');
     return {
+        model: modelName,
         usage: (0, toUsage_1.toUsage)(prompt, output),
         created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
         choices: [
@@ -38,7 +39,7 @@ async function* handleStreamingPrediction(prompt, prediction) {
     if (!prediction?.urls?.stream) {
         throw new Error('Prediction does not support streaming');
     }
-    const source = new eventsource_1.default(prediction.urls.stream, {
+    const source = new eventsource_1.EventSource(prediction.urls.stream, {
         withCredentials: true,
     });
     let results = [];
@@ -57,7 +58,7 @@ async function* handleStreamingPrediction(prompt, prediction) {
     while (!done) {
         await promise;
         await sleep(500);
-        const combined = results.reduce((acc, curr) => (acc += curr), '');
+        const combined = results.reduce((acc, curr) => acc + curr, '');
         yield {
             created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
             usage: (0, toUsage_1.toUsage)(prompt, combined),
@@ -80,19 +81,43 @@ async function ReplicateHandler(params) {
     const replicate = new replicate_1.default({
         auth: apiKey,
     });
-    const model = params.model.split('replicate/')[1];
-    const version = model.split(':')[1];
+    const modelName = params.model.startsWith('replicate/')
+        ? params.model.slice(10)
+        : params.model;
+    const version = modelName.split(':')[1];
+    if (!version) {
+        throw new Error(`Invalid Replicate model format: ${params.model}. Expected format: replicate/<owner>/<name>:<version>`);
+    }
     const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
-    const prediction = await replicate.predictions.create({
-        version: version,
-        input: {
-            prompt,
-        },
-    });
+    let prediction;
+    try {
+        prediction = await replicate.predictions.create({
+            version: version,
+            input: {
+                prompt,
+            },
+        });
+    }
+    catch (err) {
+        throw new Error(`Replicate API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
     if (params.stream) {
         return handleStreamingPrediction(prompt, prediction);
     }
-    return handleNonStreamingPrediction(prompt, prediction, replicate);
+    return handleNonStreamingPrediction(prompt, prediction, replicate, modelName);
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('replicate/', ReplicateHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('replicate', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.REPLICATE_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.replicate.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok)
+        return [];
+    const { results } = await res.json();
+    return (results ?? []).map((m) => ({ id: `${m.owner}/${m.name}`, provider: 'replicate' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('replicate/', ReplicateHandler);

package/dist/handlers/vertexAnthropic.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerParams, ResultNotStreaming, ResultStreaming } from '../types';
+export declare function VertexAnthropicHandler(params: HandlerParams): Promise<ResultNotStreaming | ResultStreaming>;

package/dist/handlers/vertexAnthropic.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexAnthropicHandler = VertexAnthropicHandler;
+const vertex_sdk_1 = require("@anthropic-ai/vertex-sdk");
+const anthropic_1 = require("../utils/anthropic");
+async function VertexAnthropicHandler(params) {
+    const project = params.project ?? process.env.GCP_PROJECT;
+    if (!project)
+        throw new Error('Vertex AI Anthropic requires GCP_PROJECT environment variable or project in params.');
+    const region = params.location ?? process.env.CLOUD_ML_REGION ?? 'us-central1';
+    const modelName = params.model.startsWith('vertex/')
+        ? params.model.slice(7)
+        : params.model;
+    const anthropic = new vertex_sdk_1.AnthropicVertex({
+        projectId: project,
+        region,
+    });
+    const { system, messages } = (0, anthropic_1.toAnthropicMessages)(params.messages);
+    try {
+        if (params.stream) {
+            const stream = await anthropic.messages.create({
+                model: modelName,
+                max_tokens: params.max_tokens ?? 300,
+                messages,
+                ...(system ? { system } : {}),
+                stream: true,
+            });
+            return (0, anthropic_1.toAnthropicStreamingResponse)(stream);
+        }
+        const message = await anthropic.messages.create({
+            model: modelName,
+            max_tokens: params.max_tokens ?? 300,
+            messages,
+            ...(system ? { system } : {}),
+        });
+        return (0, anthropic_1.toAnthropicResponse)(message);
+    }
+    catch (err) {
+        throw new Error(`Vertex Anthropic error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('vertex/claude-', VertexAnthropicHandler);

package/dist/handlers/vertexai.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerParams, ResultNotStreaming, ResultStreaming } from '../types';
+export declare function VertexAIHandler(params: HandlerParams): Promise<ResultNotStreaming | ResultStreaming>;