@loonylabs/llm-middleware 2.0.0

package/dist/middleware/services/llm/llm.service.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * LLM Service Orchestrator
+ * Provides a unified interface for interacting with different LLM providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmService = exports.LLMService = void 0;
+const ollama_provider_1 = require("./providers/ollama-provider");
+const types_1 = require("./types");
+class LLMService {
+    constructor() {
+        this.defaultProvider = types_1.LLMProvider.OLLAMA;
+        this.providers = new Map();
+        // Initialize available providers
+        this.providers.set(types_1.LLMProvider.OLLAMA, new ollama_provider_1.OllamaProvider());
+    }
+    /**
+     * Get a specific provider instance
+     */
+    getProvider(provider) {
+        const providerInstance = this.providers.get(provider);
+        if (!providerInstance) {
+            throw new Error(`Provider ${provider} is not available. Available providers: ${Array.from(this.providers.keys()).join(', ')}`);
+        }
+        return providerInstance;
+    }
+    /**
+     * Set the default provider for all requests
+     */
+    setDefaultProvider(provider) {
+        if (!this.providers.has(provider)) {
+            throw new Error(`Provider ${provider} is not available`);
+        }
+        this.defaultProvider = provider;
+    }
+    /**
+     * Get the current default provider
+     */
+    getDefaultProvider() {
+        return this.defaultProvider;
+    }
+    /**
+     * Call an LLM with a custom system message
+     * Uses the specified provider or the default provider
+     */
+    async callWithSystemMessage(userPrompt, systemMessage, options = {}) {
+        const provider = options.provider || this.defaultProvider;
+        const providerInstance = this.getProvider(provider);
+        return providerInstance.callWithSystemMessage(userPrompt, systemMessage, options);
+    }
+    /**
+     * Call an LLM with the default system message
+     * Uses the specified provider or the default provider
+     */
+    async call(prompt, options = {}) {
+        const provider = options.provider || this.defaultProvider;
+        const providerInstance = this.getProvider(provider);
+        return providerInstance.call(prompt, options);
+    }
+    /**
+     * Get list of available providers
+     */
+    getAvailableProviders() {
+        return Array.from(this.providers.keys());
+    }
+}
+exports.LLMService = LLMService;
+// Export singleton instance
+exports.llmService = new LLMService();
+//# sourceMappingURL=llm.service.js.map

package/dist/middleware/services/llm/llm.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.service.js","sourceRoot":"","sources":["../../../../src/middleware/services/llm/llm.service.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,iEAA6D;AAC7D,mCAA2E;AAE3E,MAAa,UAAU;IAIrB;QAFQ,oBAAe,GAAgB,mBAAW,CAAC,MAAM,CAAC;QAGxD,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC;QAC3B,iCAAiC;QACjC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,mBAAW,CAAC,MAAM,EAAE,IAAI,gCAAc,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,QAAqB;QACtC,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACtD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,2CAA2C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjI,CAAC;QACD,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,QAAqB;QAC7C,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,mBAAmB,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,kBAAkB;QACvB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,qBAAqB,CAChC,UAAkB,EAClB,aAAqB,EACrB,UAAyD,EAAE;QAE3D,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,eAAe,CAAC;QAC1D,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACpD,OAAO,gBAAgB,CAAC,qBAAqB,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACpF,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,IAAI,CACf,MAAc,EACd,UAAyD,EAAE;QAE3D,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,eAAe,CAAC;QAC1D,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACpD,OAAO,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,qBAAqB;QAC1B,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3C,CAAC;CACF;AAvED,gCAuEC;AAED,4BAA4B;AACf,QAAA,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC"}

package/dist/middleware/services/llm/providers/base-llm-provider.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Base abstract class for all LLM providers
+ * Defines the contract that all providers must implement
+ */
+import { CommonLLMOptions, CommonLLMResponse, LLMProvider } from '../types';
+export declare abstract class BaseLLMProvider {
+    protected providerName: LLMProvider;
+    constructor(providerName: LLMProvider);
+    /**
+     * Get the provider name
+     */
+    getProviderName(): LLMProvider;
+    /**
+     * Call the LLM API with a custom system message
+     * This is the main method that all providers must implement
+     *
+     * @param userPrompt - The user's prompt for the model
+     * @param systemMessage - The system message defining AI behavior
+     * @param options - Provider-specific options
+     * @returns The API response or null on error
+     */
+    abstract callWithSystemMessage(userPrompt: string, systemMessage: string, options: CommonLLMOptions): Promise<CommonLLMResponse | null>;
+    /**
+     * Call the LLM API with default system message
+     *
+     * @param prompt - The prompt for the model
+     * @param options - Provider-specific options
+     * @returns The API response or null on error
+     */
+    call(prompt: string, options?: CommonLLMOptions): Promise<CommonLLMResponse | null>;
+    /**
+     * Validate that required configuration is present
+     * Override this in specific providers if they need validation
+     */
+    protected validateConfig(options: CommonLLMOptions): void;
+}
+//# sourceMappingURL=base-llm-provider.d.ts.map

package/dist/middleware/services/llm/providers/base-llm-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-llm-provider.d.ts","sourceRoot":"","sources":["../../../../../src/middleware/services/llm/providers/base-llm-provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5E,8BAAsB,eAAe;IACnC,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC;gBAExB,YAAY,EAAE,WAAW;IAIrC;;OAEG;IACI,eAAe,IAAI,WAAW;IAIrC;;;;;;;;OAQG;IACH,QAAQ,CAAC,qBAAqB,CAC5B,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAEpC;;;;;;OAMG;IACU,IAAI,CACf,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAKpC;;;OAGG;IACH,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;CAQ1D"}

package/dist/middleware/services/llm/providers/base-llm-provider.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Base abstract class for all LLM providers
+ * Defines the contract that all providers must implement
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseLLMProvider = void 0;
+class BaseLLMProvider {
+    constructor(providerName) {
+        this.providerName = providerName;
+    }
+    /**
+     * Get the provider name
+     */
+    getProviderName() {
+        return this.providerName;
+    }
+    /**
+     * Call the LLM API with default system message
+     *
+     * @param prompt - The prompt for the model
+     * @param options - Provider-specific options
+     * @returns The API response or null on error
+     */
+    async call(prompt, options = {}) {
+        const defaultSystemMessage = "You are a helpful assistant, who provides clear and precise answers.";
+        return this.callWithSystemMessage(prompt, defaultSystemMessage, options);
+    }
+    /**
+     * Validate that required configuration is present
+     * Override this in specific providers if they need validation
+     */
+    validateConfig(options) {
+        if (!options.model) {
+            throw new Error(`Model name is required for ${this.providerName} provider. ` +
+                'Please ensure model is set in your options or environment variables.');
+        }
+    }
+}
+exports.BaseLLMProvider = BaseLLMProvider;
+//# sourceMappingURL=base-llm-provider.js.map

package/dist/middleware/services/llm/providers/base-llm-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-llm-provider.js","sourceRoot":"","sources":["../../../../../src/middleware/services/llm/providers/base-llm-provider.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAIH,MAAsB,eAAe;IAGnC,YAAY,YAAyB;QACnC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAiBD;;;;;;OAMG;IACI,KAAK,CAAC,IAAI,CACf,MAAc,EACd,UAA4B,EAAE;QAE9B,MAAM,oBAAoB,GAAG,sEAAsE,CAAC;QACpG,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACO,cAAc,CAAC,OAAyB;QAChD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,8BAA8B,IAAI,CAAC,YAAY,aAAa;gBAC5D,sEAAsE,CACvE,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AAxDD,0CAwDC"}

package/dist/middleware/services/llm/providers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-llm-provider';
+export * from './ollama-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/middleware/services/llm/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/middleware/services/llm/providers/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC;AAGpC,cAAc,mBAAmB,CAAC"}

package/dist/middleware/services/llm/providers/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Base provider
+__exportStar(require("./base-llm-provider"), exports);
+// Concrete providers
+__exportStar(require("./ollama-provider"), exports);
+// Future providers will be added here:
+// export * from './openai-provider';
+// export * from './anthropic-provider';
+// export * from './google-provider';
+//# sourceMappingURL=index.js.map

package/dist/middleware/services/llm/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/middleware/services/llm/providers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gBAAgB;AAChB,sDAAoC;AAEpC,qBAAqB;AACrB,oDAAkC;AAElC,uCAAuC;AACvC,qCAAqC;AACrC,wCAAwC;AACxC,qCAAqC"}

package/dist/middleware/services/llm/providers/ollama-provider.d.ts

@@ -0,0 +1,39 @@
+import { BaseLLMProvider } from './base-llm-provider';
+import { CommonLLMResponse } from '../types';
+import { OllamaRequestOptions, OllamaResponse } from '../types/ollama.types';
+/**
+ * Ollama provider implementation with advanced features:
+ * - Comprehensive debugging and logging
+ * - Retry logic with authentication fallbacks
+ * - Session management
+ * - Parameter handling
+ * - Error recovery strategies
+ */
+export declare class OllamaProvider extends BaseLLMProvider {
+    private dataFlowLogger;
+    constructor();
+    /**
+     * Call the Ollama API with a custom system message
+     * @param userPrompt - The user's prompt for the model
+     * @param systemMessage - The system message defining AI behavior
+     * @param options - Options for the API call (including token and sessionId)
+     * @returns The API response or null on error
+     */
+    callWithSystemMessage(userPrompt: string, systemMessage: string, options?: OllamaRequestOptions): Promise<CommonLLMResponse | null>;
+    /**
+     * Helper method to handle successful responses consistently
+     */
+    private handleSuccessfulResponse;
+    /**
+     * Backward compatibility: Old method name
+     */
+    callOllamaApiWithSystemMessage(userPrompt: string, systemMessage: string, options?: OllamaRequestOptions): Promise<OllamaResponse | null>;
+    /**
+     * Backward compatibility: Old method name
+     */
+    callOllamaApi(prompt: string, options?: OllamaRequestOptions): Promise<OllamaResponse | null>;
+}
+export declare const ollamaProvider: OllamaProvider;
+export { OllamaProvider as OllamaService };
+export { ollamaProvider as ollamaService };
+//# sourceMappingURL=ollama-provider.d.ts.map

package/dist/middleware/services/llm/providers/ollama-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-provider.d.ts","sourceRoot":"","sources":["../../../../../src/middleware/services/llm/providers/ollama-provider.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAe,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI7E;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,eAAe;IACjD,OAAO,CAAC,cAAc,CAAwB;;IAO9C;;;;;;OAMG;IACU,qBAAqB,CAChC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IA8ZpC;;OAEG;YACW,wBAAwB;IAkCtC;;OAEG;IACU,8BAA8B,CACzC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAIjC;;OAEG;IACU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;CAGlC;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC;AAGnD,OAAO,EAAE,cAAc,IAAI,aAAa,EAAE,CAAC;AAC3C,OAAO,EAAE,cAAc,IAAI,aAAa,EAAE,CAAC"}

package/dist/middleware/services/llm/providers/ollama-provider.js

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ollamaService = exports.OllamaService = exports.ollamaProvider = exports.OllamaProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const uuid_1 = require("uuid");
+const logging_utils_1 = require("../../../shared/utils/logging.utils");
+const base_llm_provider_1 = require("./base-llm-provider");
+const types_1 = require("../types");
+const debug_llm_utils_1 = require("../utils/debug-llm.utils");
+const data_flow_logger_1 = require("../../data-flow-logger");
+/**
+ * Ollama provider implementation with advanced features:
+ * - Comprehensive debugging and logging
+ * - Retry logic with authentication fallbacks
+ * - Session management
+ * - Parameter handling
+ * - Error recovery strategies
+ */
+class OllamaProvider extends base_llm_provider_1.BaseLLMProvider {
+    constructor() {
+        super(types_1.LLMProvider.OLLAMA);
+        this.dataFlowLogger = data_flow_logger_1.DataFlowLoggerService.getInstance();
+    }
+    /**
+     * Call the Ollama API with a custom system message
+     * @param userPrompt - The user's prompt for the model
+     * @param systemMessage - The system message defining AI behavior
+     * @param options - Options for the API call (including token and sessionId)
+     * @returns The API response or null on error
+     */
+    async callWithSystemMessage(userPrompt, systemMessage, options = {}) {
+        const { authToken, model, temperature = 0.7, baseUrl = process.env.MODEL1_URL || "http://localhost:11434", repeat_penalty, top_p, top_k, frequency_penalty, presence_penalty, repeat_last_n, num_predict, debugContext, sessionId = (0, uuid_1.v4)(), chapterNumber, pageNumber, pageName } = options;
+        // Validate that model is provided
+        if (!model) {
+            throw new Error('Model name is required but not provided. ' +
+                'Please ensure MODEL1_NAME is set in your .env file or pass model explicitly in options.');
+        }
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (authToken) {
+            headers['Authorization'] = `Bearer ${authToken}`;
+        }
+        // Create base data without session_id
+        const baseData = {
+            model: model,
+            messages: [
+                { role: "system", content: systemMessage },
+                { role: "user", content: userPrompt }
+            ],
+            temperature: temperature,
+            stream: false,
+            options: {
+                ...(repeat_penalty !== undefined && { repeat_penalty }),
+                ...(top_p !== undefined && { top_p }),
+                ...(top_k !== undefined && { top_k }),
+                ...(frequency_penalty !== undefined && { frequency_penalty }),
+                ...(presence_penalty !== undefined && { presence_penalty }),
+                ...(repeat_last_n !== undefined && { repeat_last_n }),
+                ...(num_predict !== undefined && { num_predict })
+            }
+        };
+        // Add session_id if it should be used
+        const data = {
+            ...baseData,
+            session_id: sessionId
+        };
+        // Get client request body from global scope
+        let clientRequestBody = undefined;
+        try {
+            clientRequestBody = global.currentRequestBody;
+        }
+        catch (error) {
+            // Ignore as it's optional
+        }
+        // Prepare debug info
+        const debugInfo = {
+            timestamp: new Date(),
+            provider: this.providerName,
+            model: model,
+            baseUrl: baseUrl,
+            systemMessage: systemMessage,
+            userMessage: userPrompt,
+            requestData: data,
+            useCase: debugContext,
+            clientRequestBody: clientRequestBody,
+            sessionId: sessionId,
+            chapterNumber: chapterNumber,
+            pageNumber: pageNumber,
+            pageName: pageName
+        };
+        // Log request
+        await debug_llm_utils_1.LLMDebugger.logRequest(debugInfo);
+        // Log to data flow logger
+        const contextForLogger = {
+            currentChapterNr: chapterNumber,
+            currentPage: pageNumber,
+            debugContext
+        };
+        const requestId = this.dataFlowLogger.startRequest(debugContext || 'ollama-direct', contextForLogger);
+        this.dataFlowLogger.logLLMRequest({
+            stage: debugContext || 'ollama-direct',
+            prompt: userPrompt,
+            systemMessage: systemMessage,
+            modelName: model,
+            temperature: temperature,
+            contextInfo: {
+                sessionId,
+                chapterNumber,
+                pageNumber,
+                pageName,
+                parameters: {
+                    repeat_penalty,
+                    top_p,
+                    top_k,
+                    frequency_penalty,
+                    presence_penalty,
+                    repeat_last_n,
+                    num_predict
+                }
+            }
+        }, contextForLogger, requestId);
+        const requestStartTime = Date.now();
+        try {
+            logging_utils_1.logger.info('Sending request to Ollama API', {
+                context: 'OllamaProvider',
+                metadata: {
+                    url: `${baseUrl}/api/chat`,
+                    model: model,
+                    hasAuthToken: !!authToken,
+                    promptLength: userPrompt.length
+                }
+            });
+            const response = await axios_1.default.post(`${baseUrl}/api/chat`, data, {
+                headers,
+                timeout: 90000 // 90 second timeout
+            });
+            const requestDuration = Date.now() - requestStartTime;
+            if (response && response.status === 200) {
+                const aiResponse = response.data;
+                // Add session ID to response
+                aiResponse.sessionId = sessionId;
+                // Add metadata
+                aiResponse.metadata = {
+                    provider: this.providerName,
+                    model: model,
+                    tokensUsed: aiResponse.eval_count,
+                    processingTime: requestDuration
+                };
+                // Add response info
+                debugInfo.responseTimestamp = new Date();
+                debugInfo.response = aiResponse.message.content;
+                debugInfo.rawResponseData = aiResponse;
+                // Try to extract thinking content
+                const thinkMatch = aiResponse.message.content.match(/<think>([\s\S]*?)<\/think>/);
+                if (thinkMatch && thinkMatch[1]) {
+                    debugInfo.thinking = thinkMatch[1].trim();
+                }
+                // Log response (including markdown saving)
+                await debug_llm_utils_1.LLMDebugger.logResponse(debugInfo);
+                // Log to data flow logger
+                this.dataFlowLogger.logLLMResponse(debugContext || 'ollama-direct', {
+                    rawResponse: aiResponse.message.content,
+                    processingTime: requestDuration
+                }, contextForLogger, requestId);
+                return aiResponse;
+            }
+            else {
+                const error = new Error(`Status ${response?.status || 'unknown'}`);
+                logging_utils_1.logger.error('Error calling Ollama API', {
+                    context: this.constructor.name,
+                    error: error.message,
+                    metadata: response?.data || {}
+                });
+                // Log error to data flow logger
+                this.dataFlowLogger.logLLMResponse(debugContext || 'ollama-direct', {
+                    rawResponse: '',
+                    processingTime: Date.now() - requestStartTime,
+                    error
+                }, contextForLogger, requestId);
+                return null;
+            }
+        }
+        catch (error) {
+            // Type-safe error handling
+            let errorMessage = 'Unknown error';
+            let errorDetails = {};
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            // Check for Axios error and safely extract properties
+            if (error &&
+                typeof error === 'object' &&
+                'isAxiosError' in error &&
+                error.isAxiosError === true) {
+                const axiosError = error;
+                if (axiosError.response) {
+                    errorDetails = {
+                        statusCode: axiosError.response.status,
+                        statusText: axiosError.response.statusText,
+                        data: axiosError.response.data
+                    };
+                    // Check for session ID related errors
+                    if (axiosError.response.status === 400 &&
+                        typeof axiosError.response.data === 'object' &&
+                        axiosError.response.data?.error?.includes('session_id')) {
+                        logging_utils_1.logger.warn('Session ID not supported in this Ollama version', {
+                            context: this.constructor.name,
+                            error: axiosError.response.data?.error,
+                            metadata: { sessionId }
+                        });
+                        // Retry without session_id
+                        try {
+                            const retryResponse = await axios_1.default.post(`${baseUrl}/api/chat`, baseData, { headers });
+                            if (retryResponse && retryResponse.status === 200) {
+                                const aiResponse = retryResponse.data;
+                                // Add session ID for internal tracking anyway
+                                aiResponse.sessionId = sessionId;
+                                debugInfo.responseTimestamp = new Date();
+                                debugInfo.response = aiResponse.message.content;
+                                debugInfo.rawResponseData = aiResponse;
+                                const thinkMatch = aiResponse.message.content.match(/<think>([\s\S]*?)<\/think>/);
+                                if (thinkMatch && thinkMatch[1]) {
+                                    debugInfo.thinking = thinkMatch[1].trim();
+                                }
+                                await debug_llm_utils_1.LLMDebugger.logResponse(debugInfo);
+                                // Log successful retry to data flow logger
+                                this.dataFlowLogger.logLLMResponse(debugContext || 'ollama-direct', {
+                                    rawResponse: aiResponse.message.content,
+                                    processingTime: Date.now() - requestStartTime
+                                }, contextForLogger, requestId);
+                                return aiResponse;
+                            }
+                        }
+                        catch (retryError) {
+                            // Error in retry, continue with original error
+                            logging_utils_1.logger.error('Retry also failed', {
+                                context: this.constructor.name,
+                                error: retryError instanceof Error ? retryError.message : 'Unknown retry error'
+                            });
+                        }
+                    }
+                    // Check for auth errors specifically
+                    if (axiosError.response.status === 401 || axiosError.response.status === 403) {
+                        logging_utils_1.logger.error('Authentication error with Ollama API', {
+                            context: this.constructor.name,
+                            error: 'Invalid or missing authentication token',
+                            metadata: {
+                                baseUrl,
+                                hasToken: !!authToken,
+                                statusCode: axiosError.response.status
+                            }
+                        });
+                        // Retry strategy ladder:
+                        // 1) Authorization: <raw token>
+                        if (authToken) {
+                            try {
+                                const headersRawAuth = {
+                                    'Content-Type': 'application/json',
+                                    'Authorization': authToken
+                                };
+                                const retryRaw = await axios_1.default.post(`${baseUrl}/api/chat`, baseData, {
+                                    headers: headersRawAuth,
+                                    timeout: 90000
+                                });
+                                if (retryRaw && retryRaw.status === 200) {
+                                    return this.handleSuccessfulResponse(retryRaw.data, debugInfo, sessionId, requestStartTime, debugContext, contextForLogger, requestId);
+                                }
+                            }
+                            catch (retryRawErr) {
+                                logging_utils_1.logger.warn('Retry with raw Authorization header failed', {
+                                    context: this.constructor.name,
+                                    error: retryRawErr instanceof Error ? retryRawErr.message : 'Unknown'
+                                });
+                            }
+                        }
+                        // 2) X-API-Key header
+                        if (authToken) {
+                            try {
+                                const headersApiKey = {
+                                    'Content-Type': 'application/json',
+                                    'X-API-Key': authToken
+                                };
+                                const retryApiKey = await axios_1.default.post(`${baseUrl}/api/chat`, baseData, {
+                                    headers: headersApiKey,
+                                    timeout: 90000
+                                });
+                                if (retryApiKey && retryApiKey.status === 200) {
+                                    return this.handleSuccessfulResponse(retryApiKey.data, debugInfo, sessionId, requestStartTime, debugContext, contextForLogger, requestId);
+                                }
+                            }
+                            catch (retryKeyErr) {
+                                logging_utils_1.logger.warn('Retry with X-API-Key header failed', {
+                                    context: this.constructor.name,
+                                    error: retryKeyErr instanceof Error ? retryKeyErr.message : 'Unknown'
+                                });
+                            }
+                        }
+                        // 3) No auth (for dev instances)
+                        try {
+                            const headersNoAuth = { 'Content-Type': 'application/json' };
+                            const retryAuthless = await axios_1.default.post(`${baseUrl}/api/chat`, baseData, {
+                                headers: headersNoAuth,
+                                timeout: 90000
+                            });
+                            if (retryAuthless && retryAuthless.status === 200) {
+                                return this.handleSuccessfulResponse(retryAuthless.data, debugInfo, sessionId, requestStartTime, debugContext, contextForLogger, requestId);
+                            }
+                        }
+                        catch (retryAuthlessError) {
+                            logging_utils_1.logger.error('Authless retry failed', {
+                                context: this.constructor.name,
+                                error: retryAuthlessError instanceof Error ? retryAuthlessError.message : 'Unknown authless retry error'
+                            });
+                        }
+                    }
+                }
+            }
+            logging_utils_1.logger.error('Error in API request', {
+                context: this.constructor.name,
+                error: errorMessage,
+                metadata: {
+                    ...errorDetails,
+                    requestModel: model,
+                    baseUrl: baseUrl,
+                    sessionId: sessionId
+                }
+            });
+            // Log error to data flow logger
+            this.dataFlowLogger.logLLMResponse(debugContext || 'ollama-direct', {
+                rawResponse: '',
+                processingTime: Date.now() - requestStartTime,
+                error: error instanceof Error ? error : new Error(errorMessage)
+            }, contextForLogger, requestId);
+            // Add error info
+            debugInfo.responseTimestamp = new Date();
+            debugInfo.error = {
+                message: errorMessage,
+                details: errorDetails
+            };
+            // Log error
+            await debug_llm_utils_1.LLMDebugger.logError(debugInfo);
+            // Check for memory errors in response
+            const errorResponseData = errorDetails.data;
+            if (errorResponseData &&
+                typeof errorResponseData === 'object' &&
+                'error' in errorResponseData &&
+                typeof errorResponseData.error === 'string') {
+                const errorText = errorResponseData.error;
+                if (errorText.includes('model requires more system memory') ||
+                    errorText.includes('model request too large for system')) {
+                    throw new Error(`Insufficient memory to load model ${model}. Try closing other applications or using a smaller model.`);
+                }
+            }
+            return null;
+        }
+    }
+    /**
+     * Helper method to handle successful responses consistently
+     */
+    async handleSuccessfulResponse(aiResponse, debugInfo, sessionId, requestStartTime, debugContext, contextForLogger, requestId) {
+        aiResponse.sessionId = sessionId;
+        debugInfo.responseTimestamp = new Date();
+        debugInfo.response = aiResponse.message.content;
+        debugInfo.rawResponseData = aiResponse;
+        const thinkMatch = aiResponse.message.content.match(/<think>([\s\S]*?)<\/think>/);
+        if (thinkMatch && thinkMatch[1]) {
+            debugInfo.thinking = thinkMatch[1].trim();
+        }
+        await debug_llm_utils_1.LLMDebugger.logResponse(debugInfo);
+        this.dataFlowLogger.logLLMResponse(debugContext || 'ollama-direct', {
+            rawResponse: aiResponse.message.content,
+            processingTime: Date.now() - requestStartTime
+        }, contextForLogger, requestId);
+        return aiResponse;
+    }
+    /**
+     * Backward compatibility: Old method name
+     */
+    async callOllamaApiWithSystemMessage(userPrompt, systemMessage, options = {}) {
+        return this.callWithSystemMessage(userPrompt, systemMessage, options);
+    }
+    /**
+     * Backward compatibility: Old method name
+     */
+    async callOllamaApi(prompt, options = {}) {
+        return this.call(prompt, options);
+    }
+}
+exports.OllamaProvider = OllamaProvider;
+exports.OllamaService = OllamaProvider;
+// Export singleton instance for backward compatibility
+exports.ollamaProvider = new OllamaProvider();
+exports.ollamaService = exports.ollamaProvider;
+//# sourceMappingURL=ollama-provider.js.map