@pellux/goodvibes-sdk 0.18.14 → 0.18.16

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

@@ -0,0 +1,27 @@
+import type { ProviderCapability } from './capabilities.js';
+import type { ChatRequest, ChatResponse, LLMProvider, ProviderEmbeddingRequest, ProviderEmbeddingResult, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+import { type OpenAICompatOptions } from './openai-compat.js';
+type NativeFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface OllamaProviderOptions extends OpenAICompatOptions {
+    nativeFetch?: NativeFetch;
+    fallbackProvider?: LLMProvider;
+}
+export declare class OllamaProvider implements LLMProvider {
+    readonly name: string;
+    readonly models: string[];
+    readonly capabilities?: Partial<ProviderCapability>;
+    private readonly baseURL;
+    private readonly defaultModel;
+    private readonly nativeChatUrl;
+    private readonly nativeEmbedUrl;
+    private readonly nativeFetch;
+    private readonly fallbackProvider;
+    private readonly embeddingModel;
+    constructor(opts: OllamaProviderOptions);
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    embed(request: ProviderEmbeddingRequest): Promise<ProviderEmbeddingResult>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+    private chatViaNativeOllama;
+}
+export {};
+//# sourceMappingURL=ollama.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/ollama.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EAEZ,WAAW,EAEX,wBAAwB,EACxB,uBAAuB,EAEvB,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIpF,KAAK,WAAW,GAAG,CACjB,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,CAAC,EAAE,WAAW,KACf,OAAO,CAAC,QAAQ,CAAC,CAAC;AAqBvB,MAAM,WAAW,qBAAsB,SAAQ,mBAAmB;IAChE,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,gBAAgB,CAAC,EAAE,WAAW,CAAC;CAChC;AAED,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAc;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoB;gBAEvC,IAAI,EAAE,qBAAqB;IAYjC,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAkBhD,KAAK,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAuC1E,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;YA4C5E,mBAAmB;CAoGlC"}

package/dist/_internal/platform/providers/ollama.js

@@ -0,0 +1,376 @@
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { toOpenAITools } from './tool-formats.js';
+import { summarizeError, toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export class OllamaProvider {
+    name;
+    models;
+    capabilities;
+    baseURL;
+    defaultModel;
+    nativeChatUrl;
+    nativeEmbedUrl;
+    nativeFetch;
+    fallbackProvider;
+    embeddingModel = 'embeddinggemma';
+    constructor(opts) {
+        this.name = opts.name;
+        this.models = opts.models;
+        this.capabilities = opts.capabilities;
+        this.baseURL = opts.baseURL;
+        this.defaultModel = opts.defaultModel;
+        this.nativeChatUrl = deriveOllamaChatUrl(opts.baseURL);
+        this.nativeEmbedUrl = deriveOllamaEmbedUrl(opts.baseURL);
+        this.nativeFetch = opts.nativeFetch ?? ((input, init) => fetch(input, init));
+        this.fallbackProvider = opts.fallbackProvider ?? new OpenAICompatProvider(opts);
+    }
+    async chat(params) {
+        return withRetry(async () => {
+            const model = params.model || this.defaultModel;
+            if (canUseNativeOllamaChat(params.messages)) {
+                try {
+                    return await this.chatViaNativeOllama(params, model);
+                }
+                catch (err) {
+                    if (!shouldFallbackFromNative(err)) {
+                        throw normalizeProviderError(err, this.name, 'chat', 'request');
+                    }
+                }
+            }
+            return this.fallbackProvider.chat(params);
+        });
+    }
+    async embed(request) {
+        try {
+            const response = await this.nativeFetch(this.nativeEmbedUrl, {
+                method: 'POST',
+                headers: {
+                    accept: 'application/json',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: request.model ?? this.embeddingModel,
+                    input: request.text,
+                    ...(request.dimensions ? { dimensions: request.dimensions } : {}),
+                }),
+                signal: request.signal,
+            });
+            if (!response.ok) {
+                throw await buildHttpError('Ollama native embeddings', response, this.name, 'embed', 'request');
+            }
+            const body = await response.json();
+            const vector = body.embedding ?? body.embeddings?.[0] ?? [];
+            return {
+                vector: Float32Array.from(vector),
+                dimensions: vector.length,
+                modelId: body.model ?? request.model ?? this.embeddingModel,
+                metadata: {
+                    usage: request.usage,
+                    provider: this.name,
+                },
+            };
+        }
+        catch (err) {
+            if (this.fallbackProvider.embed) {
+                return this.fallbackProvider.embed(request);
+            }
+            throw normalizeProviderError(err, this.name, 'embed', 'request');
+        }
+    }
+    async describeRuntime(deps) {
+        const local = !/^https?:\/\/ollama\.com\b/i.test(this.baseURL);
+        const { buildStandardProviderAuthRoutes } = await import('./runtime-metadata.js');
+        const authRoutes = await buildStandardProviderAuthRoutes({
+            providerId: this.name,
+            apiKeyEnvVars: ['OLLAMA_API_KEY', 'OLLAMA_CLOUD_API_KEY'],
+            secretKeys: ['OLLAMA_API_KEY', 'OLLAMA_CLOUD_API_KEY'],
+            serviceNames: ['ollama-cloud'],
+            allowAnonymous: local,
+            anonymousConfigured: local,
+            anonymousDetail: 'Local Ollama endpoints can be used without an API key.',
+        }, deps);
+        return {
+            auth: {
+                mode: local ? 'anonymous' : 'api-key',
+                configured: local || Boolean(process.env.OLLAMA_API_KEY || process.env.OLLAMA_CLOUD_API_KEY),
+                detail: local
+                    ? 'Local Ollama endpoint does not require an API key'
+                    : 'Ollama Cloud API key is required',
+                envVars: ['OLLAMA_API_KEY', 'OLLAMA_CLOUD_API_KEY'],
+                routes: authRoutes,
+            },
+            models: {
+                models: this.models,
+                embeddingModel: this.embeddingModel,
+                embeddingDimensions: 384,
+            },
+            usage: {
+                streaming: true,
+                toolCalling: true,
+                parallelTools: false,
+                notes: ['Native Ollama embeddings prefer the /api/embed endpoint.'],
+            },
+            policy: {
+                local,
+                streamProtocol: 'ollama-ndjson',
+                reasoningMode: 'native-think-toggle',
+                supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+                cacheStrategy: 'provider-managed',
+                notes: local ? ['Local-first embedding generation.'] : ['Remote Ollama Cloud usage is subject to service policy.'],
+            },
+        };
+    }
+    async chatViaNativeOllama(params, model) {
+        const messages = toOllamaMessages(params.messages, params.systemPrompt);
+        const think = mapOllamaThinking(params.reasoningEffort);
+        const body = {
+            model,
+            messages,
+            stream: true,
+            ...(params.tools && params.tools.length > 0 ? { tools: toOpenAITools(params.tools) } : {}),
+            ...(think !== undefined ? { think } : {}),
+            ...(params.maxTokens ? { options: { num_predict: params.maxTokens } } : {}),
+        };
+        let response;
+        try {
+            response = await this.nativeFetch(this.nativeChatUrl, {
+                method: 'POST',
+                headers: {
+                    accept: 'application/x-ndjson, application/json',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(body),
+                signal: params.signal,
+            });
+        }
+        catch (err) {
+            throw normalizeProviderError(err, this.name, 'chat', 'request');
+        }
+        if (!response.ok) {
+            throw await buildHttpError('Ollama native chat', response, this.name, 'chat', 'request');
+        }
+        if (!response.body) {
+            throw new ProviderError('Ollama native chat returned no response body.', {
+                statusCode: 502,
+                provider: this.name,
+                operation: 'chat',
+                phase: 'response',
+            });
+        }
+        let responseText = '';
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let doneReason = '';
+        let finalToolCalls = [];
+        const emittedToolCalls = new Set();
+        await consumeNDJSON(response.body, (chunk) => {
+            const message = chunk.message;
+            const content = typeof message?.content === 'string' ? message.content : '';
+            if (content) {
+                responseText += content;
+                params.onDelta?.({ content });
+            }
+            const thinking = typeof message?.thinking === 'string' ? message.thinking : '';
+            if (thinking) {
+                params.onDelta?.({ reasoning: thinking });
+            }
+            if (Array.isArray(message?.tool_calls) && message.tool_calls.length > 0) {
+                const normalized = normalizeOllamaToolCalls(message.tool_calls);
+                finalToolCalls = normalized;
+                normalized.forEach((call, index) => {
+                    if (emittedToolCalls.has(call.id))
+                        return;
+                    emittedToolCalls.add(call.id);
+                    const argumentsText = JSON.stringify(call.arguments);
+                    const partial = {
+                        index,
+                        id: call.id,
+                        name: call.name,
+                        arguments: argumentsText,
+                    };
+                    params.onDelta?.({ toolCalls: [partial] });
+                });
+            }
+            if (chunk.done) {
+                doneReason = typeof chunk.done_reason === 'string' ? chunk.done_reason : doneReason;
+                inputTokens = typeof chunk.prompt_eval_count === 'number' ? chunk.prompt_eval_count : inputTokens;
+                outputTokens = typeof chunk.eval_count === 'number' ? chunk.eval_count : outputTokens;
+            }
+        });
+        const stopReason = finalToolCalls.length > 0 || /tool/i.test(doneReason)
+            ? 'tool_use'
+            : (/length|max_tokens/i.test(doneReason) ? 'max_tokens' : 'end');
+        return {
+            content: responseText,
+            toolCalls: finalToolCalls,
+            usage: {
+                inputTokens,
+                outputTokens,
+            },
+            stopReason,
+        };
+    }
+}
+function deriveOllamaChatUrl(baseURL) {
+    const trimmed = baseURL.replace(/\/+$/, '');
+    const origin = trimmed.endsWith('/v1') ? trimmed.slice(0, -3) : trimmed;
+    return `${origin}/api/chat`;
+}
+function deriveOllamaEmbedUrl(baseURL) {
+    const trimmed = baseURL.replace(/\/+$/, '');
+    const origin = trimmed.endsWith('/v1') ? trimmed.slice(0, -3) : trimmed;
+    return `${origin}/api/embed`;
+}
+function canUseNativeOllamaChat(messages) {
+    if (messages.length === 0)
+        return false;
+    return !messages.some((message) => (message.role === 'tool'
+        || (message.role === 'assistant' && (message.toolCalls?.length ?? 0) > 0)));
+}
+function toOllamaMessages(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt?.trim()) {
+        result.push({ role: 'system', content: systemPrompt.trim() });
+    }
+    for (const message of messages) {
+        if (message.role === 'user') {
+            if (Array.isArray(message.content)) {
+                result.push(contentPartsToOllamaMessage('user', message.content));
+            }
+            else {
+                result.push({ role: 'user', content: message.content });
+            }
+            continue;
+        }
+        if (message.role === 'assistant') {
+            result.push({ role: 'assistant', content: message.content });
+            continue;
+        }
+    }
+    return result;
+}
+function contentPartsToOllamaMessage(role, parts) {
+    const text = parts
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .join('\n');
+    const images = parts
+        .filter((part) => part.type === 'image')
+        .map((part) => part.data);
+    return {
+        role,
+        content: text,
+        ...(images.length > 0 ? { images } : {}),
+    };
+}
+function normalizeOllamaToolCalls(calls) {
+    return calls.flatMap((call, index) => {
+        const fn = call.function;
+        if (!fn || typeof fn.name !== 'string' || fn.name.length === 0)
+            return [];
+        return [{
+                id: `ollama_call_${index}`,
+                name: fn.name,
+                arguments: fn.arguments && typeof fn.arguments === 'object' ? fn.arguments : {},
+            }];
+    });
+}
+function mapOllamaThinking(reasoningEffort) {
+    switch (reasoningEffort) {
+        case 'instant':
+            return false;
+        case 'low':
+        case 'medium':
+        case 'high':
+            return reasoningEffort;
+        default:
+            return undefined;
+    }
+}
+async function consumeNDJSON(body, onChunk) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const reader = body.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            onChunk(JSON.parse(trimmed));
+        }
+    }
+    buffer += decoder.decode();
+    const trailing = buffer.trim();
+    if (trailing) {
+        onChunk(JSON.parse(trailing));
+    }
+}
+async function buildHttpError(prefix, response, provider, operation, phase) {
+    const text = await response.text();
+    try {
+        const parsed = JSON.parse(text);
+        const error = toRecord(parsed['error']);
+        if (Object.keys(error).length > 0) {
+            const code = typeof error['code'] === 'string' ? `${error['code']}: ` : '';
+            const message = typeof error['message'] === 'string' ? error['message'] : text;
+            return new ProviderError(`${prefix} error ${response.status}: ${code}${message}`, {
+                statusCode: response.status,
+                provider,
+                operation,
+                phase,
+            });
+        }
+    }
+    catch {
+        // fall through
+    }
+    return new ProviderError(`${prefix} error ${response.status}: ${text || response.statusText}`, {
+        statusCode: response.status,
+        provider,
+        operation,
+        phase,
+    });
+}
+function shouldFallbackFromNative(err) {
+    const status = getErrorStatus(err);
+    const message = getErrorMessage(err);
+    if (status === 404 || status === 405 || status === 501)
+        return true;
+    if (status === 400 && /tool|messages|unsupported/i.test(message))
+        return true;
+    return /not implemented|unsupported|unknown endpoint/i.test(message);
+}
+function getErrorStatus(err) {
+    if (err && typeof err === 'object') {
+        const record = err;
+        if (typeof record.status === 'number')
+            return record.status;
+        if (typeof record.statusCode === 'number')
+            return record.statusCode;
+    }
+    return undefined;
+}
+function getErrorMessage(err) {
+    return summarizeError(err);
+}
+function normalizeProviderError(err, provider, operation, phase = 'request') {
+    const status = getErrorStatus(err);
+    return toProviderError(err, {
+        ...(status !== undefined ? { statusCode: status } : {}),
+        provider,
+        operation,
+        phase,
+    });
+}
+function toRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}

package/dist/_internal/platform/providers/openai-codex.d.ts

@@ -0,0 +1,12 @@
+import type { ChatRequest, ChatResponse, LLMProvider, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
+export declare function chatWithOpenAICodex(accessToken: string, params: ChatRequest): Promise<ChatResponse>;
+export declare class OpenAICodexProvider implements LLMProvider {
+    private readonly subscriptionManager;
+    readonly name = "openai-subscriber";
+    readonly models: string[];
+    constructor(subscriptionManager: Pick<SubscriptionManager, 'get' | 'saveSubscription' | 'resolveAccessToken'>);
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+}
+//# sourceMappingURL=openai-codex.d.ts.map

package/dist/_internal/platform/providers/openai-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-codex.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/openai-codex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EAGX,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AAMxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAgJ/F,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,YAAY,CAAC,CA+PvB;AAED,qBAAa,mBAAoB,YAAW,WAAW;IAKnD,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAJtC,QAAQ,CAAC,IAAI,uBAA8B;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAM;gBAGZ,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,EAAE,KAAK,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;IAG9G,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAahD,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAgC3F"}