nova-terminal-ai 0.3.4

package/dist/packages/core/src/model/providers/CodingPlanProvider.d.ts

@@ -0,0 +1,66 @@
+import { OpenAICompatibleProvider, type OpenAICompatibleConfig } from './OpenAICompatibleProvider.js';
+/** Coding Plan platform identifiers */
+export type CodingPlanPlatform = 'alibaba' | 'tencent' | 'volcengine' | 'baidu' | 'kimi' | 'zhipu' | 'minimax' | 'custom';
+/** Coding Plan configuration */
+export interface CodingPlanConfig extends Omit<OpenAICompatibleConfig, 'baseUrl'> {
+    platform: CodingPlanPlatform;
+    /** Custom base URL (required if platform is 'custom') */
+    customBaseUrl?: string;
+}
+/**
+ * Coding Plan Provider - Access multiple AI models through Chinese Coding Plan platforms
+ *
+ * @example
+ * ```typescript
+ * // 使用阿里云百炼 Coding Plan
+ * const provider = new CodingPlanProvider({
+ *   platform: 'alibaba',
+ *   apiKey: 'your-coding-plan-api-key',
+ *   model: 'qwen3-coder',
+ * });
+ *
+ * // 使用自定义 Coding Plan
+ * const provider = new CodingPlanProvider({
+ *   platform: 'custom',
+ *   customBaseUrl: 'https://your-coding-plan-endpoint.com/v1',
+ *   apiKey: 'your-api-key',
+ *   model: 'custom-model',
+ * });
+ * ```
+ */
+export declare class CodingPlanProvider extends OpenAICompatibleProvider {
+    readonly name: string;
+    readonly platform: CodingPlanPlatform;
+    readonly supportedModels: string[];
+    constructor(config: CodingPlanConfig);
+    /**
+     * Get list of supported models for this platform
+     */
+    getSupportedModels(): string[];
+    /**
+     * Get platform info
+     */
+    getPlatformInfo(): {
+        name: string;
+        platform: CodingPlanPlatform;
+        baseUrl: string;
+    };
+    /**
+     * Get Anthropic-compatible base URL (for Alibaba Cloud only)
+     */
+    getAnthropicBaseUrl(): string | null;
+}
+/**
+ * Get all supported Coding Plan platforms
+ */
+export declare function getSupportedCodingPlanPlatforms(): Array<{
+    platform: CodingPlanPlatform;
+    name: string;
+    baseUrl: string;
+    models: string[];
+}>;
+/**
+ * Quick factory for creating Coding Plan providers
+ */
+export declare function createCodingPlanProvider(platform: CodingPlanPlatform, apiKey: string, model: string, customBaseUrl?: string): CodingPlanProvider;
+//# sourceMappingURL=CodingPlanProvider.d.ts.map

package/dist/packages/core/src/model/providers/CodingPlanProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodingPlanProvider.d.ts","sourceRoot":"","sources":["../../../../../../../core/src/model/providers/CodingPlanProvider.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,wBAAwB,EAAE,KAAK,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEtG,uCAAuC;AACvC,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,YAAY,GACZ,OAAO,GACP,MAAM,GACN,OAAO,GACP,SAAS,GACT,QAAQ,CAAC;AAEb,gCAAgC;AAChC,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC;IAC/E,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAoDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAmB,SAAQ,wBAAwB;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;gBAEvB,MAAM,EAAE,gBAAgB;IAmCpC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,eAAe,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,kBAAkB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IASlF;;OAEG;IACH,mBAAmB,IAAI,MAAM,GAAG,IAAI;CAIrC;AAED;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,KAAK,CAAC;IACvD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC,CASD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,MAAM,GACrB,kBAAkB,CAOpB"}

package/dist/packages/core/src/model/providers/CodingPlanProvider.js

@@ -0,0 +1,161 @@
+// ============================================================================
+// CodingPlanProvider - Support for Chinese Coding Plan platforms
+// ============================================================================
+//
+// Supports multiple Coding Plan platforms with a single API key:
+// - Alibaba Cloud (阿里云百炼)
+// - Tencent Cloud (腾讯云)
+// - Volcengine (火山引擎)
+// - Baidu Qianfan (百度千帆)
+// - Kimi Code
+// - Zhipu AI (智谱)
+// - MiniMax
+//
+// All platforms use OpenAI-compatible API with custom base URLs
+// ============================================================================
+import { OpenAICompatibleProvider } from './OpenAICompatibleProvider.js';
+/** Platform-specific configurations */
+const PLATFORM_CONFIGS = {
+    alibaba: {
+        name: 'Alibaba Cloud Coding Plan',
+        baseUrl: 'https://coding.dashscope.aliyuncs.com/v1',
+        anthropicBaseUrl: 'https://coding.dashscope.aliyuncs.com/apps/anthropic',
+        models: ['qwen3.5-plus', 'qwen3-coder', 'glm-5', 'minimax-m2.5', 'kimi-k2.5'],
+    },
+    tencent: {
+        name: 'Tencent Cloud Coding Plan',
+        baseUrl: 'https://api.hunyuan.cloud.tencent.com/v1', // 需要从控制台获取实际URL
+        models: ['hy-2.0-instruct', 'glm-5', 'kimi-k2.5', 'minimax-m2.5'],
+    },
+    volcengine: {
+        name: 'Volcengine Coding Plan',
+        baseUrl: 'https://ark.cn-beijing.volces.com/api/v3', // 需要从控制台获取实际URL
+        models: ['doubao-seed-code', 'deepseek-v3.2', 'glm-4.7', 'kimi-k2'],
+    },
+    baidu: {
+        name: 'Baidu Qianfan Coding Plan',
+        baseUrl: 'https://qianfan.baidubce.com/v2', // 需要从控制台获取实际URL
+        models: ['glm-5', 'minimax-m2.5', 'kimi-k2.5', 'ernie-4.5'],
+    },
+    kimi: {
+        name: 'Kimi Code',
+        baseUrl: 'https://api.moonshot.cn/v1',
+        models: ['kimi-k2', 'kimi-k2.5'],
+    },
+    zhipu: {
+        name: 'Zhipu AI Coding Plan',
+        baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+        models: ['glm-4.7', 'glm-5'],
+    },
+    minimax: {
+        name: 'MiniMax Coding Plan',
+        baseUrl: 'https://api.minimax.chat/v1',
+        models: ['minimax-2.7', 'abab6.5s-chat'],
+    },
+    custom: {
+        name: 'Custom Coding Plan',
+        baseUrl: '',
+        models: [],
+    },
+};
+/**
+ * Coding Plan Provider - Access multiple AI models through Chinese Coding Plan platforms
+ *
+ * @example
+ * ```typescript
+ * // 使用阿里云百炼 Coding Plan
+ * const provider = new CodingPlanProvider({
+ *   platform: 'alibaba',
+ *   apiKey: 'your-coding-plan-api-key',
+ *   model: 'qwen3-coder',
+ * });
+ *
+ * // 使用自定义 Coding Plan
+ * const provider = new CodingPlanProvider({
+ *   platform: 'custom',
+ *   customBaseUrl: 'https://your-coding-plan-endpoint.com/v1',
+ *   apiKey: 'your-api-key',
+ *   model: 'custom-model',
+ * });
+ * ```
+ */
+export class CodingPlanProvider extends OpenAICompatibleProvider {
+    name;
+    platform;
+    supportedModels;
+    constructor(config) {
+        const platformConfig = PLATFORM_CONFIGS[config.platform];
+        if (!platformConfig) {
+            throw new Error(`Unknown Coding Plan platform: ${config.platform}`);
+        }
+        if (config.platform === 'custom' && !config.customBaseUrl) {
+            throw new Error('customBaseUrl is required when platform is "custom"');
+        }
+        const baseUrl = config.platform === 'custom'
+            ? config.customBaseUrl
+            : platformConfig.baseUrl;
+        super({
+            apiKey: config.apiKey,
+            baseUrl: baseUrl,
+            model: config.model,
+            headers: config.headers,
+        });
+        this.name = platformConfig.name;
+        this.platform = config.platform;
+        this.supportedModels = platformConfig.models;
+        // Validate model if platform has known models
+        if (platformConfig.models.length > 0 && !platformConfig.models.includes(config.model)) {
+            console.warn(`[CodingPlanProvider] Model "${config.model}" may not be supported by ${platformConfig.name}. ` +
+                `Known models: ${platformConfig.models.join(', ')}`);
+        }
+    }
+    /**
+     * Get list of supported models for this platform
+     */
+    getSupportedModels() {
+        return [...this.supportedModels];
+    }
+    /**
+     * Get platform info
+     */
+    getPlatformInfo() {
+        const config = PLATFORM_CONFIGS[this.platform];
+        return {
+            name: this.name,
+            platform: this.platform,
+            baseUrl: this.platform === 'custom' ? '' : config.baseUrl,
+        };
+    }
+    /**
+     * Get Anthropic-compatible base URL (for Alibaba Cloud only)
+     */
+    getAnthropicBaseUrl() {
+        const config = PLATFORM_CONFIGS[this.platform];
+        return config.anthropicBaseUrl || null;
+    }
+}
+/**
+ * Get all supported Coding Plan platforms
+ */
+export function getSupportedCodingPlanPlatforms() {
+    return Object.entries(PLATFORM_CONFIGS)
+        .filter(([key]) => key !== 'custom')
+        .map(([platform, config]) => ({
+        platform: platform,
+        name: config.name,
+        baseUrl: config.baseUrl,
+        models: config.models,
+    }));
+}
+/**
+ * Quick factory for creating Coding Plan providers
+ */
+export function createCodingPlanProvider(platform, apiKey, model, customBaseUrl) {
+    return new CodingPlanProvider({
+        platform,
+        apiKey,
+        model,
+        customBaseUrl,
+    });
+}
+//# sourceMappingURL=CodingPlanProvider.js.map

package/dist/packages/core/src/model/providers/CodingPlanProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodingPlanProvider.js","sourceRoot":"","sources":["../../../../../../../core/src/model/providers/CodingPlanProvider.ts"],"names":[],"mappings":"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"}

package/dist/packages/core/src/model/providers/OllamaCloudProvider.d.ts

@@ -0,0 +1,38 @@
+import type { Message } from '../../types/session.js';
+import type { ModelProvider, ModelRequestOptions, ModelResponse, StreamEvent } from '../types.js';
+export interface OllamaCloudConfig {
+    apiKey: string;
+    baseUrl?: string;
+    model: string;
+}
+export declare class OllamaCloudProvider implements ModelProvider {
+    readonly name = "Ollama Cloud";
+    private apiKey;
+    private baseUrl;
+    constructor(config: OllamaCloudConfig);
+    complete(messages: Message[], options: ModelRequestOptions): Promise<ModelResponse>;
+    stream(messages: Message[], options: ModelRequestOptions): AsyncGenerator<StreamEvent>;
+    countTokens(messages: Message[]): Promise<number>;
+    private getOptions;
+    /**
+     * Convert internal ToolDefinition[] to Ollama's native tool format.
+     * Ollama uses the same format as OpenAI: { type: "function", function: { name, description, parameters } }
+     */
+    private convertTools;
+    /**
+     * Convert messages to Ollama format.
+     * Handles: system, user, assistant (with optional tool_calls), and tool results.
+     * Ollama doesn't have a native tool role; tool results are sent as user messages.
+     */
+    private convertMessages;
+    private extractText;
+    private convertResponseContent;
+    private convertStopReason;
+    /**
+     * Parse text-based tool calls in XML format (used by some models via Ollama Cloud).
+     * Expected format: <function_calls><invoke name="tool_name"><parameter name="key">value</parameter>...</invoke></function_calls>
+     */
+    private parseTextToolCalls;
+    private request;
+}
+//# sourceMappingURL=OllamaCloudProvider.d.ts.map

package/dist/packages/core/src/model/providers/OllamaCloudProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OllamaCloudProvider.d.ts","sourceRoot":"","sources":["../../../../../../../core/src/model/providers/OllamaCloudProvider.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,OAAO,EAAmD,MAAM,wBAAwB,CAAC;AAEvG,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,aAAa,EAAc,WAAW,EAAE,MAAM,aAAa,CAAC;AAI9G,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAgDD,qBAAa,mBAAoB,YAAW,aAAa;IACvD,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,iBAAiB;IAK/B,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IA4ClF,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,WAAW,CAAC;IAgIvF,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAWvD,OAAO,CAAC,UAAU;IASlB;;;OAGG;IACH,OAAO,CAAC,YAAY;IA2BpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAiDvB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,sBAAsB;IA0B9B,OAAO,CAAC,iBAAiB;IAUzB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;YAiCZ,OAAO;CAWtB"}

package/dist/packages/core/src/model/providers/OllamaCloudProvider.js

@@ -0,0 +1,365 @@
+// ============================================================================
+// OllamaCloudProvider - Ollama Cloud API (https://ollama.com)
+// ============================================================================
+//
+// Uses Ollama's native REST API (/api/chat) for cloud-hosted models.
+// Supports:
+// - All Ollama Cloud models (deepseek-v3.2, kimi-k2.5, qwen3-coder, etc.)
+// - Streaming responses with thinking/reasoning support
+// - Tool/function calling (Ollama native format)
+// - Model discovery via /api/tags
+// - API key authentication (Bearer token)
+//
+// NOTE: Ollama Cloud uses native API format, NOT OpenAI-compatible.
+// ============================================================================
+import { ModelError } from '../../types/errors.js';
+import { createToolCallId } from '../../types/session.js';
+export class OllamaCloudProvider {
+    name = 'Ollama Cloud';
+    apiKey;
+    baseUrl;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl || 'https://ollama.com').replace(/\/+$/, '');
+    }
+    async complete(messages, options) {
+        const ollamaMessages = this.convertMessages(messages, options.systemPrompt);
+        const tools = this.convertTools(options.tools);
+        const body = {
+            model: options.model,
+            messages: ollamaMessages,
+            stream: false,
+            ...(tools.length > 0 && { tools }),
+            ...(options.maxTokens && { options: { num_predict: options.maxTokens } }),
+            ...(options.temperature !== undefined && options.temperature !== 1 && {
+                options: { ...this.getOptions(options), temperature: options.temperature },
+            }),
+        };
+        const res = await this.request('/api/chat', body);
+        const data = await res.json();
+        if (!res.ok) {
+            throw new ModelError(`Ollama Cloud API error: ${res.status} ${res.statusText} - ${JSON.stringify(data)}`, res.status, this.name);
+        }
+        const content = this.convertResponseContent(data.message);
+        const usage = {
+            inputTokens: data.prompt_eval_count || 0,
+            outputTokens: data.eval_count || 0,
+        };
+        // Ollama returns done_reason "stop" even for tool calls; detect from response content
+        const hasToolCalls = content.some((c) => c.type === 'tool_use');
+        const stopReason = hasToolCalls ? 'tool_use' : this.convertStopReason(data.done_reason);
+        return {
+            content,
+            model: data.model,
+            stopReason,
+            usage,
+            sessionId: options.sessionId,
+        };
+    }
+    async *stream(messages, options) {
+        const ollamaMessages = this.convertMessages(messages, options.systemPrompt);
+        const tools = this.convertTools(options.tools);
+        const body = {
+            model: options.model,
+            messages: ollamaMessages,
+            stream: true,
+            ...(tools.length > 0 && { tools }),
+            options: this.getOptions(options),
+        };
+        let res;
+        try {
+            res = await this.request('/api/chat', body);
+        }
+        catch (err) {
+            yield { type: 'error', error: new ModelError(`Ollama Cloud request failed: ${err.message}`, undefined, this.name) };
+            return;
+        }
+        if (!res.ok) {
+            let errorText = '';
+            try {
+                errorText = await res.text();
+            }
+            catch { /* ignore */ }
+            yield { type: 'error', error: new ModelError(`Ollama Cloud API error: ${res.status} ${errorText || res.statusText}`, res.status, this.name) };
+            return;
+        }
+        yield { type: 'message_start', model: options.model };
+        const reader = res.body?.getReader();
+        if (!reader) {
+            yield { type: 'error', error: new ModelError('No response body from Ollama Cloud', undefined, this.name) };
+            return;
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let totalInput = 0;
+        let totalOutput = 0;
+        // Track tool calls for streaming (Ollama sends them in the final chunk)
+        let pendingToolCalls = [];
+        // Accumulate all text content for text-based tool call detection
+        let fullTextBuffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const chunk = JSON.parse(line);
+                        // Emit thinking content
+                        if (chunk.message?.thinking) {
+                            yield { type: 'thinking_delta', delta: chunk.message.thinking };
+                        }
+                        // Emit text content
+                        if (chunk.message?.content) {
+                            fullTextBuffer += chunk.message.content;
+                            yield { type: 'text_delta', delta: chunk.message.content };
+                        }
+                        // Collect tool calls (Ollama sends them in final chunk or inline)
+                        if (chunk.message?.tool_calls) {
+                            for (const tc of chunk.message.tool_calls) {
+                                const argsStr = typeof tc.function.arguments === 'string'
+                                    ? tc.function.arguments
+                                    : JSON.stringify(tc.function.arguments);
+                                pendingToolCalls.push({
+                                    name: tc.function.name,
+                                    arguments: argsStr,
+                                });
+                            }
+                        }
+                        // Track token usage
+                        if (chunk.prompt_eval_count)
+                            totalInput = chunk.prompt_eval_count;
+                        if (chunk.eval_count)
+                            totalOutput = chunk.eval_count;
+                        // Stream done
+                        if (chunk.done) {
+                            // Check for text-based tool calls (some models output <function_calls>...</function_calls> as text)
+                            if (fullTextBuffer.includes('<function_calls>') && fullTextBuffer.includes('</function_calls>')) {
+                                const callsBlock = fullTextBuffer.substring(fullTextBuffer.indexOf('<function_calls>'), fullTextBuffer.indexOf('</function_calls>') + '</function_calls>'.length);
+                                const parsed = this.parseTextToolCalls(callsBlock);
+                                if (parsed.length > 0) {
+                                    pendingToolCalls.push(...parsed);
+                                }
+                            }
+                            // Emit any pending tool calls before message_complete
+                            if (pendingToolCalls.length > 0) {
+                                for (const tc of pendingToolCalls) {
+                                    const toolCallId = createToolCallId(`tool_${Date.now()}_${Math.random()}`);
+                                    yield { type: 'tool_call_start', toolCallId, toolName: tc.name };
+                                    yield { type: 'tool_call_delta', toolCallId, delta: tc.arguments };
+                                }
+                            }
+                            // Ollama uses "stop" even for tool calls; detect from pending tool calls
+                            const hasToolCalls = pendingToolCalls.length > 0;
+                            const stopReason = hasToolCalls ? 'tool_use' : this.convertStopReason(chunk.done_reason);
+                            yield {
+                                type: 'message_complete',
+                                stopReason,
+                                usage: { inputTokens: totalInput, outputTokens: totalOutput },
+                            };
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+        }
+        catch (err) {
+            yield { type: 'error', error: new ModelError(`Ollama Cloud stream error: ${err.message}`, undefined, this.name) };
+        }
+    }
+    async countTokens(messages) {
+        // Approximate: ~4 chars per token
+        const text = messages.map(m => {
+            if (typeof m.content === 'string')
+                return m.content;
+            return m.content.map(c => c.type === 'text' ? c.text : '').join('');
+        }).join('');
+        return Math.ceil(text.length / 4);
+    }
+    // --- Private helpers ---
+    getOptions(options) {
+        const opts = {};
+        if (options.maxTokens)
+            opts.num_predict = options.maxTokens;
+        if (options.temperature !== undefined && options.temperature !== 1) {
+            opts.temperature = options.temperature;
+        }
+        return opts;
+    }
+    /**
+     * Convert internal ToolDefinition[] to Ollama's native tool format.
+     * Ollama uses the same format as OpenAI: { type: "function", function: { name, description, parameters } }
+     */
+    convertTools(tools) {
+        if (!tools || tools.length === 0)
+            return [];
+        return tools.map(tool => {
+            const parameters = {
+                type: 'object',
+                properties: {},
+            };
+            if (tool.inputSchema?.properties) {
+                parameters.properties = tool.inputSchema.properties;
+            }
+            if (tool.inputSchema?.required) {
+                parameters.required = tool.inputSchema.required;
+            }
+            return {
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: tool.description || '',
+                    parameters,
+                },
+            };
+        });
+    }
+    /**
+     * Convert messages to Ollama format.
+     * Handles: system, user, assistant (with optional tool_calls), and tool results.
+     * Ollama doesn't have a native tool role; tool results are sent as user messages.
+     */
+    convertMessages(messages, systemPrompt) {
+        const result = [];
+        if (systemPrompt) {
+            result.push({ role: 'system', content: systemPrompt });
+        }
+        for (const msg of messages) {
+            if (msg.role === 'user') {
+                const text = this.extractText(msg.content);
+                result.push({ role: 'user', content: text });
+            }
+            else if (msg.role === 'assistant') {
+                // Check if assistant message contains tool calls
+                const toolUseBlocks = msg.content.filter((c) => c.type === 'tool_use');
+                const textBlocks = msg.content.filter(c => c.type === 'text');
+                if (toolUseBlocks.length > 0) {
+                    // Ollama supports tool_calls in assistant messages
+                    const msgObj = {
+                        role: 'assistant',
+                        content: textBlocks.map(c => c.text).join('') || '',
+                        tool_calls: toolUseBlocks.map(tc => ({
+                            function: {
+                                name: tc.name,
+                                arguments: tc.input,
+                            },
+                        })),
+                    };
+                    result.push(msgObj);
+                }
+                else {
+                    const text = this.extractText(msg.content);
+                    result.push({ role: 'assistant', content: text });
+                }
+            }
+            else if (msg.role === 'tool') {
+                // Ollama doesn't have a native tool role; include as user message
+                const toolResults = msg.content.filter((c) => c.type === 'tool_result');
+                const text = toolResults.map(tr => {
+                    const content = typeof tr.content === 'string'
+                        ? tr.content
+                        : JSON.stringify(tr.content);
+                    return `[Tool Result for ${tr.tool_use_id}]: ${content}`;
+                }).join('\n');
+                result.push({ role: 'user', content: text });
+            }
+        }
+        return result;
+    }
+    extractText(content) {
+        if (typeof content === 'string')
+            return content;
+        return content
+            .map(block => {
+            if (block.type === 'text')
+                return block.text;
+            if (block.type === 'tool_use')
+                return `[Calling tool: ${block.name}]`;
+            if (block.type === 'tool_result')
+                return `[Tool result: ${typeof block.content === 'string' ? block.content : JSON.stringify(block.content)}]`;
+            return '';
+        })
+            .join('\n');
+    }
+    convertResponseContent(message) {
+        const content = [];
+        if (message.thinking) {
+            content.push({ type: 'text', text: message.thinking });
+        }
+        if (message.content) {
+            content.push({ type: 'text', text: message.content });
+        }
+        // Handle tool calls
+        if (message.tool_calls) {
+            for (const tc of message.tool_calls) {
+                content.push({
+                    type: 'tool_use',
+                    id: createToolCallId(`tool_${Date.now()}_${Math.random()}`),
+                    name: tc.function.name,
+                    input: tc.function.arguments,
+                });
+            }
+        }
+        return content;
+    }
+    convertStopReason(reason) {
+        if (!reason)
+            return 'end_turn';
+        switch (reason) {
+            case 'stop': return 'end_turn';
+            case 'length': return 'max_tokens';
+            case 'tool_calls': return 'tool_use';
+            default: return 'end_turn';
+        }
+    }
+    /**
+     * Parse text-based tool calls in XML format (used by some models via Ollama Cloud).
+     * Expected format: <function_calls><invoke name="tool_name"><parameter name="key">value</parameter>...</invoke></function_calls>
+     */
+    parseTextToolCalls(xmlBlock) {
+        const results = [];
+        const invokeRegex = /<invoke\s+name=["']([^"']+)["']\s*>(.*?)<\/invoke>/gs;
+        let match;
+        while ((match = invokeRegex.exec(xmlBlock)) !== null) {
+            const toolName = match[1];
+            const paramsXml = match[2];
+            const params = {};
+            const paramRegex = /<parameter\s+name=["']([^"']+)["']\s*>(.*?)<\/parameter>/gs;
+            let paramMatch;
+            while ((paramMatch = paramRegex.exec(paramsXml)) !== null) {
+                const paramName = paramMatch[1];
+                const paramValue = paramMatch[2].trim();
+                try {
+                    params[paramName] = JSON.parse(paramValue);
+                }
+                catch {
+                    params[paramName] = paramValue;
+                }
+            }
+            results.push({
+                name: toolName,
+                arguments: JSON.stringify(params),
+            });
+        }
+        return results;
+    }
+    async request(path, body) {
+        return fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(120000),
+        });
+    }
+}
+//# sourceMappingURL=OllamaCloudProvider.js.map