@framers/agentos 0.1.0

package/dist/core/llm/providers/errors/OpenRouterProviderError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenRouterProviderError.js","sourceRoot":"","sources":["../../../../../src/core/llm/providers/errors/OpenRouterProviderError.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,uBAAwB,SAAQ,aAAa;IAOxD;;;;;;;OAOG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAmB,EACnB,mBAA4B,EAC5B,OAAiB;QAEjB,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,6BAA6B;QAC1E,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAC;QAE/C,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,uBAAuB,CAAC,SAAS,CAAC,CAAC;IACjE,CAAC;CACF"}

package/dist/core/llm/providers/errors/ProviderError.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview Defines the base error class for AI Model Provider related errors.
+ * This class provides a common structure for errors originating from provider interactions,
+ * allowing for consistent error handling and identification across different provider implementations.
+ * @module backend/agentos/core/llm/providers/errors/ProviderError
+ */
+/**
+ * Represents a generic error that occurred within an AI Model Provider.
+ * Specific provider implementations should extend this class to provide
+ * more detailed error information.
+ */
+export declare class ProviderError extends Error {
+    /**
+     * A unique code identifying the type of error.
+     * e.g., 'INITIALIZATION_FAILED', 'API_REQUEST_FAILED', 'AUTHENTICATION_ERROR'.
+     */
+    readonly code: string;
+    /**
+     * The identifier of the provider where the error originated.
+     * e.g., 'openai', 'ollama', 'openrouter'.
+     */
+    readonly providerId?: string;
+    /**
+     * Optional details or context about the error, which could be provider-specific.
+     * This might include things like HTTP status codes, underlying error objects, or request IDs.
+     */
+    readonly details?: unknown;
+    /**
+     * Creates an instance of ProviderError.
+     * @param {string} message - A human-readable description of the error.
+     * @param {string} code - A unique code identifying the type of error.
+     * @param {string} [providerId] - The identifier of the provider where the error originated.
+     * @param {unknown} [details] - Optional details or context about the error.
+     */
+    constructor(message: string, code: string, providerId?: string, details?: unknown);
+}
+//# sourceMappingURL=ProviderError.d.ts.map

package/dist/core/llm/providers/errors/ProviderError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderError.d.ts","sourceRoot":"","sources":["../../../../../src/core/llm/providers/errors/ProviderError.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;OAGG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpC;;;OAGG;IACH,SAAgB,OAAO,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;CAclF"}

package/dist/core/llm/providers/errors/ProviderError.js

@@ -0,0 +1,36 @@
+// File: backend/agentos/core/llm/providers/errors/ProviderError.ts
+/**
+ * @fileoverview Defines the base error class for AI Model Provider related errors.
+ * This class provides a common structure for errors originating from provider interactions,
+ * allowing for consistent error handling and identification across different provider implementations.
+ * @module backend/agentos/core/llm/providers/errors/ProviderError
+ */
+/**
+ * Represents a generic error that occurred within an AI Model Provider.
+ * Specific provider implementations should extend this class to provide
+ * more detailed error information.
+ */
+export class ProviderError extends Error {
+    /**
+     * Creates an instance of ProviderError.
+     * @param {string} message - A human-readable description of the error.
+     * @param {string} code - A unique code identifying the type of error.
+     * @param {string} [providerId] - The identifier of the provider where the error originated.
+     * @param {unknown} [details] - Optional details or context about the error.
+     */
+    constructor(message, code, providerId, details) {
+        super(message);
+        this.name = this.constructor.name; // Ensures the name property is the subclass name
+        this.code = code;
+        this.providerId = providerId;
+        this.details = details;
+        // This line is to make the stack trace more readable and skip the ProviderError constructor
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = new Error(message).stack;
+        }
+    }
+}
+//# sourceMappingURL=ProviderError.js.map

package/dist/core/llm/providers/errors/ProviderError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderError.js","sourceRoot":"","sources":["../../../../../src/core/llm/providers/errors/ProviderError.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE;;;;;GAKG;AAEH;;;;GAIG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IAmBtC;;;;;;OAMG;IACH,YAAY,OAAe,EAAE,IAAY,EAAE,UAAmB,EAAE,OAAiB;QAC/E,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,iDAAiD;QACpF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,4FAA4F;QAC5F,IAAI,OAAO,KAAK,CAAC,iBAAiB,KAAK,UAAU,EAAE,CAAC;YAClD,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC;QACxC,CAAC;IACH,CAAC;CACF"}

package/dist/core/llm/providers/implementations/OllamaProvider.d.ts

@@ -0,0 +1,80 @@
+import { IProvider, ChatMessage, ModelCompletionOptions, ModelCompletionResponse, ModelInfo, ProviderEmbeddingOptions, ProviderEmbeddingResponse } from '../IProvider';
+/**
+ * Configuration specific to the OllamaProvider.
+ */
+export interface OllamaProviderConfig {
+    /**
+     * The base URL of the Ollama API.
+     * @example "http://localhost:11434" (Ollama's default)
+     */
+    baseURL: string;
+    /**
+     * Default model ID to use if not specified in a request (e.g., "llama3:latest").
+     * This model must be available in the connected Ollama instance.
+     */
+    defaultModelId?: string;
+    /**
+     * Timeout for API requests to Ollama in milliseconds.
+     * @default 60000 (60 seconds)
+     */
+    requestTimeout?: number;
+    /**
+     * Optional API key if the Ollama instance is secured (not common for local instances).
+     * Currently, Ollama itself does not use API keys for authentication.
+     */
+    apiKey?: string;
+}
+/**
+ * @class OllamaProvider
+ * @implements {IProvider}
+ * Provides an interface to locally hosted LLMs through an Ollama instance.
+ * It handles API requests for chat completions, streaming, embeddings, and model listing.
+ */
+export declare class OllamaProvider implements IProvider {
+    /** @inheritdoc */
+    readonly providerId: string;
+    /** @inheritdoc */
+    isInitialized: boolean;
+    /** @inheritdoc */
+    defaultModelId?: string;
+    private config;
+    private client;
+    /**
+     * Creates an instance of OllamaProvider.
+     * The provider must be initialized using `initialize()` before use.
+     */
+    constructor();
+    /** @inheritdoc */
+    initialize(config: OllamaProviderConfig): Promise<void>;
+    /**
+     * Ensures the provider is initialized.
+     * @private
+     * @throws {OllamaProviderError} If not initialized.
+     */
+    private ensureInitialized;
+    /**
+     * Transforms standard ChatMessage array to Ollama's expected format.
+     * @private
+     */
+    private mapToOllamaMessages;
+    /** @inheritdoc */
+    generateCompletion(modelId: string, messages: ChatMessage[], options: ModelCompletionOptions): Promise<ModelCompletionResponse>;
+    /** @inheritdoc */
+    generateCompletionStream(modelId: string, messages: ChatMessage[], options: ModelCompletionOptions): AsyncGenerator<ModelCompletionResponse, void, undefined>;
+    /** @inheritdoc */
+    generateEmbeddings(modelId: string, texts: string[], options?: ProviderEmbeddingOptions): Promise<ProviderEmbeddingResponse>;
+    /** @inheritdoc */
+    listAvailableModels(filter?: {
+        capability?: string;
+    }): Promise<ModelInfo[]>;
+    /** @inheritdoc */
+    getModelInfo(modelId: string): Promise<ModelInfo | undefined>;
+    /** @inheritdoc */
+    checkHealth(): Promise<{
+        isHealthy: boolean;
+        _details?: unknown;
+    }>;
+    /** @inheritdoc */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=OllamaProvider.d.ts.map

package/dist/core/llm/providers/implementations/OllamaProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OllamaProvider.d.ts","sourceRoot":"","sources":["../../../../../src/core/llm/providers/implementations/OllamaProvider.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,SAAS,EACT,WAAW,EAEX,sBAAsB,EACtB,uBAAuB,EACvB,SAAS,EAET,wBAAwB,EACxB,yBAAyB,EAE1B,MAAM,cAAc,CAAC;AAGtB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+FD;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC9C,kBAAkB;IAClB,SAAgB,UAAU,EAAE,MAAM,CAAY;IAC9C,kBAAkB;IACX,aAAa,EAAE,OAAO,CAAS;IACtC,kBAAkB;IACX,cAAc,CAAC,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,MAAM,CAAiB;IAE/B;;;OAGG;;IAGH,kBAAkB;IACL,UAAU,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8CpE;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IASzB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAyB3B,kBAAkB;IACL,kBAAkB,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,uBAAuB,CAAC;IAyEnC,kBAAkB;IACJ,wBAAwB,CACpC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,sBAAsB,GAC9B,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC;IAkI3D,kBAAkB;IACL,kBAAkB,CAC7B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,yBAAyB,CAAC;IAsDrC,kBAAkB;IACL,mBAAmB,CAAC,MAAM,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAsExF,kBAAkB;IACL,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAqC1E,kBAAkB;IACL,WAAW,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAsB/E,kBAAkB;IACL,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAMvC"}

package/dist/core/llm/providers/implementations/OllamaProvider.js

@@ -0,0 +1,473 @@
+// File: backend/agentos/core/llm/providers/implementations/OllamaProvider.ts
+/**
+ * @fileoverview Implements the IProvider interface for Ollama, enabling interaction
+ * with locally hosted large language models. This provider supports chat completions,
+ * streaming, embedding generation (if the Ollama model supports it), and model introspection.
+ *
+ * Key features:
+ * - Connects to a specified Ollama instance.
+ * - Standardized chat completion and streaming API.
+ * - Embedding generation via Ollama's `/api/embeddings` endpoint.
+ * - Listing of available local models.
+ * - Health checks for the Ollama service.
+ * - Adherence to AgentOS architectural principles, including custom error handling and comprehensive JSDoc.
+ *
+ * @module backend/agentos/core/llm/providers/implementations/OllamaProvider
+ * @implements {IProvider}
+ */
+import axios from 'axios';
+import { OllamaProviderError } from '../errors/OllamaProviderError.js';
+const extractErrorMessage = (data) => {
+    if (!data || typeof data !== 'object') {
+        return undefined;
+    }
+    const candidate = data.error;
+    return typeof candidate === 'string' ? candidate : undefined;
+};
+const isTextContentPart = (part) => part.type === 'text' && typeof part.text === 'string';
+/**
+ * @class OllamaProvider
+ * @implements {IProvider}
+ * Provides an interface to locally hosted LLMs through an Ollama instance.
+ * It handles API requests for chat completions, streaming, embeddings, and model listing.
+ */
+export class OllamaProvider {
+    /**
+     * Creates an instance of OllamaProvider.
+     * The provider must be initialized using `initialize()` before use.
+     */
+    constructor() {
+        /** @inheritdoc */
+        this.providerId = 'ollama';
+        /** @inheritdoc */
+        this.isInitialized = false;
+    }
+    /** @inheritdoc */
+    async initialize(config) {
+        if (!config.baseURL) {
+            throw new OllamaProviderError('Ollama baseURL is required for initialization.', 'INIT_FAILED_MISSING_BASEURL');
+        }
+        this.config = {
+            requestTimeout: 60000, // Default 60 seconds
+            ...config,
+        };
+        this.defaultModelId = config.defaultModelId;
+        this.client = axios.create({
+            baseURL: this.config.baseURL.endsWith('/api') ? this.config.baseURL : `${this.config.baseURL}/api`,
+            timeout: this.config.requestTimeout,
+            headers: {
+                'Content-Type': 'application/json',
+                // Ollama typically does not require an API key for local instances.
+                // If a proxy in front of Ollama needs one, it could be added here via config.apiKey.
+                ...(this.config.apiKey ? { 'Authorization': `Bearer ${this.config.apiKey}` } : {}),
+            },
+        });
+        try {
+            // Verify connection by attempting to list local models or check base endpoint.
+            await this.client.get('/'); // Ollama's base endpoint should return "Ollama is running"
+            this.isInitialized = true;
+            console.log(`OllamaProvider initialized successfully. Base URL: ${this.client.defaults.baseURL}. Default model: ${this.defaultModelId || 'Not set'}`);
+        }
+        catch (error) {
+            this.isInitialized = false;
+            const axiosError = error;
+            const _details = {
+                baseURL: this.client.defaults.baseURL,
+                status: axiosError.response?.status,
+                data: axiosError.response?.data,
+            };
+            throw new OllamaProviderError(`OllamaProvider initialization failed: Could not connect to Ollama at ${this.client.defaults.baseURL}. Ensure Ollama is running and accessible. Error: ${axiosError.message}`, 'INITIALIZATION_FAILED', axiosError.response?.status, _details);
+        }
+    }
+    /**
+     * Ensures the provider is initialized.
+     * @private
+     * @throws {OllamaProviderError} If not initialized.
+     */
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new OllamaProviderError('OllamaProvider is not initialized. Call initialize() first.', 'PROVIDER_NOT_INITIALIZED');
+        }
+    }
+    /**
+     * Transforms standard ChatMessage array to Ollama's expected format.
+     * @private
+     */
+    mapToOllamaMessages(messages) {
+        return messages.map(msg => {
+            if (typeof msg.content !== 'string') {
+                // Ollama primarily supports text content. Vision models might take base64 images.
+                // For non-string content, we attempt to serialize or take the text part if multimodal.
+                // This part needs careful handling based on specific Ollama model capabilities.
+                console.warn(`OllamaProvider: Message content for role ${msg.role} is not a simple string. Attempting to use text part or serialize.`);
+                if (Array.isArray(msg.content)) {
+                    const textPart = msg.content.find(isTextContentPart);
+                    // TODO: Handle image_url parts for vision-enabled Ollama models by converting to base64.
+                    return {
+                        role: msg.role,
+                        content: textPart?.text ?? JSON.stringify(msg.content), // Fallback to JSON string
+                    };
+                }
+                return { role: msg.role, content: JSON.stringify(msg.content) }; // Fallback
+            }
+            return {
+                role: msg.role,
+                content: msg.content,
+                // images: msg.images_base64_if_supported_and_present // Handle multimodal if applicable
+            };
+        });
+    }
+    /** @inheritdoc */
+    async generateCompletion(modelId, messages, options) {
+        this.ensureInitialized();
+        const ollamaMessages = this.mapToOllamaMessages(messages);
+        const payload = {
+            model: modelId,
+            messages: ollamaMessages,
+            stream: false, // For non-streaming
+            options: {
+                ...(options.temperature !== undefined && { temperature: options.temperature }),
+                ...(options.topP !== undefined && { top_p: options.topP }),
+                ...(options.maxTokens !== undefined && { num_predict: options.maxTokens }), // Ollama uses 'num_predict'
+                ...(options.presencePenalty !== undefined && { presence_penalty: options.presencePenalty }),
+                ...(options.frequencyPenalty !== undefined && { frequency_penalty: options.frequencyPenalty }),
+                ...(options.stopSequences !== undefined && { stop: options.stopSequences }),
+            },
+            format: options.responseFormat?.type === 'json_object' ? 'json' : undefined,
+            // Ollama's tool support is not standardized like OpenAI's.
+            // Pass custom params if any are known for specific Ollama models.
+            ...(options.customModelParams || {}),
+        };
+        try {
+            const response = await this.client.post('/chat', payload);
+            const data = response.data;
+            if (data.error) {
+                throw new OllamaProviderError(`Ollama API error for model ${modelId}: ${data.error}`, 'API_ERROR', response.status, data);
+            }
+            const promptTokens = data.prompt_eval_count || 0;
+            const completionTokens = data.eval_count || 0;
+            const usage = {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+                costUSD: 0, // Local models typically have no direct per-token cost.
+            };
+            return {
+                id: `ollama-${modelId}-${Date.now()}`, // Generate a unique ID
+                object: 'chat.completion',
+                created: data.created_at ? new Date(data.created_at).getTime() / 1000 : Math.floor(Date.now() / 1000),
+                modelId: data.model || modelId,
+                choices: data.message ? [{
+                        index: 0,
+                        message: {
+                            role: data.message.role,
+                            content: data.message.content,
+                        },
+                        finishReason: data.done ? 'stop' : 'length', // Best guess for non-streaming
+                    }] : [],
+                usage,
+            };
+        }
+        catch (error) {
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorData = axiosError.response?.data;
+            const message = extractErrorMessage(errorData) || axiosError.message || 'Unknown Ollama API error';
+            throw new OllamaProviderError(message, 'API_REQUEST_FAILED', status, { requestPayload: payload, responseData: errorData });
+        }
+    }
+    /** @inheritdoc */
+    async *generateCompletionStream(modelId, messages, options) {
+        this.ensureInitialized();
+        const ollamaMessages = this.mapToOllamaMessages(messages);
+        const payload = {
+            model: modelId,
+            messages: ollamaMessages,
+            stream: true,
+            options: {
+                ...(options.temperature !== undefined && { temperature: options.temperature }),
+                ...(options.topP !== undefined && { top_p: options.topP }),
+                ...(options.maxTokens !== undefined && { num_predict: options.maxTokens }),
+                ...(options.presencePenalty !== undefined && { presence_penalty: options.presencePenalty }),
+                ...(options.frequencyPenalty !== undefined && { frequency_penalty: options.frequencyPenalty }),
+                ...(options.stopSequences !== undefined && { stop: options.stopSequences }),
+            },
+            format: options.responseFormat?.type === 'json_object' ? 'json' : undefined,
+            ...(options.customModelParams || {}),
+        };
+        let responseStream;
+        try {
+            responseStream = await this.client.post('/chat', payload, { responseType: 'stream' });
+        }
+        catch (error) {
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorData = axiosError.response?.data;
+            const message = extractErrorMessage(errorData) || axiosError.message || 'Failed to connect to Ollama stream.';
+            throw new OllamaProviderError(message, 'STREAM_CONNECTION_FAILED', status, { requestPayload: payload, responseData: errorData });
+        }
+        const stream = responseStream.data;
+        let accumulatedContent = "";
+        let finalUsage;
+        let responseId = `ollama-stream-${modelId}-${Date.now()}`; // Initial ID
+        const abortSignal = options.abortSignal;
+        if (abortSignal?.aborted) {
+            yield { id: `ollama-abort-${Date.now()}`, object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), modelId, choices: [], error: { message: 'Stream aborted prior to first chunk', type: 'abort' }, isFinal: true };
+            return;
+        }
+        const abortHandler = () => {
+            // We rely on loop check to emit final chunk; no direct stream destroy to keep portability.
+        };
+        abortSignal?.addEventListener('abort', abortHandler, { once: true });
+        try {
+            for await (const chunk of stream) {
+                if (abortSignal?.aborted) {
+                    yield { id: `ollama-abort-${Date.now()}`, object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), modelId, choices: [], error: { message: 'Stream aborted by caller', type: 'abort' }, isFinal: true };
+                    break;
+                }
+                const chunkString = chunk.toString();
+                // Ollama stream sends multiple JSON objects, newline-separated.
+                const jsonObjects = chunkString.split('\n').filter(Boolean);
+                for (const jsonObjStr of jsonObjects) {
+                    try {
+                        const parsedChunk = JSON.parse(jsonObjStr);
+                        responseId = `ollama-stream-${parsedChunk.model || modelId}-${new Date(parsedChunk.created_at).getTime()}`;
+                        if (parsedChunk.error) {
+                            yield {
+                                id: responseId, object: 'chat.completion.chunk', created: new Date(parsedChunk.created_at).getTime() / 1000,
+                                modelId: parsedChunk.model || modelId, choices: [], isFinal: true,
+                                error: { message: parsedChunk.error, type: 'ollama_api_error' }
+                            };
+                            return; // Terminate stream on error
+                        }
+                        const deltaContent = parsedChunk.message?.content || "";
+                        if (deltaContent)
+                            accumulatedContent += deltaContent;
+                        const isFinalChunk = parsedChunk.done;
+                        if (isFinalChunk) {
+                            const promptTokens = parsedChunk.prompt_eval_count || 0;
+                            const completionTokens = parsedChunk.eval_count || 0;
+                            finalUsage = {
+                                promptTokens,
+                                completionTokens,
+                                totalTokens: promptTokens + completionTokens,
+                                costUSD: 0,
+                            };
+                        }
+                        yield {
+                            id: responseId,
+                            object: 'chat.completion.chunk',
+                            created: new Date(parsedChunk.created_at).getTime() / 1000,
+                            modelId: parsedChunk.model || modelId,
+                            choices: parsedChunk.message ? [{
+                                    index: 0,
+                                    message: {
+                                        role: parsedChunk.message.role || 'assistant', // Or infer from previous state
+                                        content: accumulatedContent, // Full accumulated content for this chunk's choice
+                                    },
+                                    finishReason: isFinalChunk ? 'stop' : null,
+                                }] : [],
+                            responseTextDelta: deltaContent,
+                            isFinal: isFinalChunk,
+                            usage: isFinalChunk ? finalUsage : undefined,
+                        };
+                        if (isFinalChunk)
+                            return; // End stream explicitly
+                    }
+                    catch (parseError) {
+                        console.warn('OllamaProvider: Could not parse stream chunk JSON:', jsonObjStr, parseError);
+                        // Optionally yield an error chunk or decide to continue
+                    }
+                }
+            }
+        }
+        catch (streamError) {
+            const message = streamError instanceof Error ? streamError.message : 'Ollama stream processing error';
+            console.error(`OllamaProvider stream error for model ${modelId}:`, message, streamError);
+            // Yield a final error chunk to the consumer
+            yield {
+                id: responseId, object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000),
+                modelId: modelId, choices: [], isFinal: true,
+                error: { message, type: 'STREAM_PROCESSING_ERROR' }
+            };
+        }
+        finally {
+            stream?.destroy?.();
+        }
+        abortSignal?.removeEventListener('abort', abortHandler);
+    }
+    /** @inheritdoc */
+    async generateEmbeddings(modelId, texts, options) {
+        this.ensureInitialized();
+        if (!texts || texts.length === 0) {
+            throw new OllamaProviderError('Input texts array cannot be empty for embeddings.', 'EMBEDDING_NO_INPUT');
+        }
+        // Ollama's /api/embeddings endpoint currently takes one prompt (text) at a time.
+        // We need to batch these requests if multiple texts are provided.
+        const embeddingsData = [];
+        const totalPromptTokens = 0; // Ollama doesn't provide token counts for embeddings yet.
+        for (let i = 0; i < texts.length; i++) {
+            const text = texts[i];
+            const payload = {
+                model: modelId,
+                prompt: text,
+                options: options?.customModelParams, // Pass through any custom model options
+            };
+            try {
+                const response = await this.client.post('/embeddings', payload);
+                const embeddingResponse = response.data;
+                embeddingsData.push({
+                    object: 'embedding',
+                    embedding: embeddingResponse.embedding,
+                    index: i,
+                });
+                // totalPromptTokens += calculate_tokens_for(text); // Hypothetical token calculation
+            }
+            catch (error) {
+                const axiosError = error;
+                const status = axiosError.response?.status;
+                const errorData = axiosError.response?.data;
+                const message = extractErrorMessage(errorData) || axiosError.message || `Failed to generate embedding for text index ${i}`;
+                throw new OllamaProviderError(message, 'EMBEDDING_FAILED', status, { requestPayload: payload, textIndex: i, responseData: errorData });
+            }
+        }
+        return {
+            object: 'list',
+            data: embeddingsData,
+            model: modelId,
+            usage: {
+                prompt_tokens: totalPromptTokens, // This will be 0 until Ollama provides this info or we add local tokenization
+                total_tokens: totalPromptTokens,
+                costUSD: 0, // Local embeddings
+            },
+        };
+    }
+    /** @inheritdoc */
+    async listAvailableModels(filter) {
+        this.ensureInitialized();
+        try {
+            const response = await this.client.get('/tags');
+            const apiModels = response.data.models;
+            const modelInfos = apiModels.map((model) => {
+                const capabilities = ['chat', 'completion']; // Base capabilities for most Ollama models
+                if (model._details?.families?.includes('clip') || model.name.includes('llava') || model.name.includes('bakllava')) {
+                    capabilities.push('vision_input');
+                }
+                // Embedding capability is harder to infer universally, usually specific models.
+                // Assume any model *can* be used with /api/embeddings, but quality varies.
+                // For AgentOS, we might want to explicitly tag known good embedding models.
+                // capabilities.push('embeddings');
+                // Rough estimation of context window based on common model families
+                let contextWindow = 4096; // Default
+                const family = model._details?.family?.toLowerCase();
+                const paramSize = model._details?.parameter_size?.toLowerCase();
+                if (family) {
+                    if (family.includes("llama3") || family.includes("llama-3"))
+                        contextWindow = 8192;
+                    else if (family.includes("llama2") || family.includes("llama-2"))
+                        contextWindow = 4096;
+                    else if (family.includes("codellama"))
+                        contextWindow = 16000;
+                    else if (family.includes("mistral") && (paramSize?.includes("7b") || paramSize?.includes("8x7b")))
+                        contextWindow = 32768; // Mistral-7B, Mixtral-8x7B
+                    else if (family.includes("phi3") || family.includes("phi-3")) {
+                        if (paramSize?.includes("mini") && (paramSize?.includes("128k") || model.name.includes("128k")))
+                            contextWindow = 131072;
+                        else if (paramSize?.includes("mini") && (paramSize?.includes("4k") || model.name.includes("4k")))
+                            contextWindow = 4096;
+                        else if (paramSize?.includes("small"))
+                            contextWindow = 8192; // Phi-3 Small
+                        else if (paramSize?.includes("medium"))
+                            contextWindow = 131072; // Phi-3 Medium (can be 4k or 128k variant)
+                    }
+                }
+                return {
+                    modelId: model.name, // e.g., "llama3:latest", "mistral:7b-instruct-q4_0"
+                    providerId: this.providerId,
+                    displayName: model.name,
+                    description: `Ollama model: ${model._details?.family || model.model} (${model._details?.parameter_size || 'size unknown'}), Format: ${model._details?.format || 'unknown'}`,
+                    capabilities,
+                    contextWindowSize: contextWindow,
+                    // Output/Input token limits are often the same as context window for Ollama models.
+                    // Pricing is not applicable for local Ollama models.
+                    pricePer1MTokensInput: 0,
+                    pricePer1MTokensOutput: 0,
+                    supportsStreaming: true, // Most Ollama chat models support streaming
+                    lastUpdated: model.modified_at,
+                    status: 'active',
+                };
+            });
+            if (filter?.capability) {
+                return modelInfos.filter(m => m.capabilities.includes(filter.capability));
+            }
+            return modelInfos;
+        }
+        catch (error) {
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            throw new OllamaProviderError(`Failed to list available Ollama models: ${axiosError.message}`, 'LIST_MODELS_FAILED', status, axiosError.response?.data);
+        }
+    }
+    /** @inheritdoc */
+    async getModelInfo(modelId) {
+        this.ensureInitialized();
+        // Ollama's /api/show endpoint provides detailed info for a specific model
+        try {
+            const response = await this.client.post('/show', { name: modelId });
+            const detailedInfo = response.data;
+            // Note: detailedInfo._details is available but not currently used; future versions may enrich ModelInfo with it.
+            // Attempt to map this to ModelInfo, might need more robust parsing
+            const models = await this.listAvailableModels(); // Get the base info
+            const baseInfo = models.find(m => m.modelId === modelId);
+            if (!baseInfo)
+                return undefined;
+            // Enrich with _details from /show if possible
+            // For example, extract more specific parameter_size, quantization etc. from _details if not already in baseInfo.description
+            // This is highly dependent on the output of /api/show for the specific model.
+            // As a simple step, we'll return the info from listAvailableModels as it's more standardized.
+            // A more advanced version would merge data from /show into the ModelInfo.
+            return {
+                ...baseInfo,
+                description: `${baseInfo.description}. Parameters: ${detailedInfo.parameters?.split('\n').filter(Boolean).join(', ') || 'N/A'}`
+            };
+        }
+        catch (error) {
+            const axiosError = error;
+            if (axiosError.response?.status === 404) {
+                return undefined; // Model not found
+            }
+            throw new OllamaProviderError(`Failed to get info for Ollama model '${modelId}': ${axiosError.message}`, 'GET_MODEL_INFO_FAILED', axiosError.response?.status, axiosError.response?.data);
+        }
+    }
+    /** @inheritdoc */
+    async checkHealth() {
+        this.ensureInitialized(); // Ensures client is created
+        try {
+            const response = await this.client.get('/'); // Check base Ollama endpoint
+            // Ollama returns "Ollama is running" with a 200 OK on its root path.
+            if (response.status === 200 && typeof response.data === 'string' && response.data.includes("Ollama is running")) {
+                return { isHealthy: true, _details: { message: response.data } };
+            }
+            return { isHealthy: false, _details: { status: response.status, data: response.data } };
+        }
+        catch (error) {
+            const axiosError = error;
+            return {
+                isHealthy: false,
+                _details: {
+                    message: `Ollama health check failed: ${axiosError.message}`,
+                    status: axiosError.response?.status,
+                    data: axiosError.response?.data,
+                },
+            };
+        }
+    }
+    /** @inheritdoc */
+    async shutdown() {
+        // For OllamaProvider using Axios, there are no persistent connections to explicitly close.
+        // Marking as uninitialized is sufficient.
+        this.isInitialized = false;
+        console.log('OllamaProvider shutdown complete.');
+    }
+}
+//# sourceMappingURL=OllamaProvider.js.map