@sulala/agent 0.1.6 → 0.1.8

package/dist/ai/orchestrator.js

@@ -1,23 +1,146 @@
 import { log, saveAiResult } from '../db/index.js';
 const providers = new Map();
-const defaultProvider = process.env.AI_DEFAULT_PROVIDER || 'openai';
 export function registerProvider(name, adapter) {
     providers.set(name, adapter);
 }
 export function getProvider(name) {
-    const key = name ?? defaultProvider;
+    const key = name ?? process.env.AI_DEFAULT_PROVIDER ?? 'ollama';
     const p = providers.get(key);
     if (!p)
         throw new Error(`Unknown AI provider: ${key}. Registered: ${[...providers.keys()].join(', ')}`);
     return p;
 }
-/** Stream completion (OpenAI and OpenRouter). Falls back to non-streaming for other providers. */
+/** Stream completion (OpenAI, OpenRouter, Ollama). Falls back to non-streaming for other providers. */
 export async function completeStream(options, onChunk) {
-    const provider = options.provider ?? defaultProvider;
+    const provider = options.provider ?? process.env.AI_DEFAULT_PROVIDER ?? 'ollama';
     const messages = options.messages ?? [];
     const model = options.model;
     const max_tokens = options.max_tokens ?? 1024;
     const tools = options.tools;
+    if (provider === 'ollama' || provider === 'llama') {
+        // Tool calling: use non-streaming so tool_calls.arguments are complete (streaming can truncate and cause JSON.parse errors).
+        if (tools?.length) {
+            const result = await complete({ ...options, provider, messages, model, max_tokens, tools, signal: options.signal });
+            onChunk({ type: 'finish', content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage });
+            return { content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage };
+        }
+        const think = options.think !== false && ollamaSupportsThinking(model);
+        const OLLAMA_BASE = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+        const OLLAMA_DEFAULT = process.env.AI_OLLAMA_DEFAULT_MODEL || 'llama3.2';
+        const url = `${OLLAMA_BASE}/api/chat`;
+        const ollamaMessages = toOllamaMessages(messages);
+        const body = {
+            model: model || OLLAMA_DEFAULT,
+            messages: ollamaMessages,
+            stream: true,
+            think,
+            options: { num_predict: max_tokens || 1024 },
+        };
+        if (tools?.length) {
+            body.tools = tools.map((t) => ({
+                type: 'function',
+                function: { name: t.name, description: t.description, parameters: t.parameters ?? {} },
+            }));
+        }
+        let res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: options.signal,
+        });
+        if (!res.ok) {
+            const errText = await res.text();
+            let didRetryStream = false;
+            if (res.status === 400 && errText.includes('does not support tools') && body.tools) {
+                delete body.tools;
+                console.log('[Ollama] Model does not support tools; retrying without tools');
+                res = await fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(body),
+                    signal: options.signal,
+                });
+                didRetryStream = true;
+            }
+            if (!res.ok) {
+                const retryErrText = didRetryStream ? await res.text() : errText;
+                if (res.status === 404 && (retryErrText.includes('not found') || retryErrText.includes('model'))) {
+                    const { pullOllamaModel } = await import('../ollama-setup.js');
+                    pullOllamaModel(model || OLLAMA_DEFAULT);
+                    throw new Error(`Model "${model || OLLAMA_DEFAULT}" not found. Pulling now; try again in 1–2 min.`);
+                }
+                throw new Error(`Ollama: ${res.status} ${retryErrText}`);
+            }
+        }
+        const reader = res.body?.getReader();
+        if (!reader) {
+            const result = await complete({ ...options, provider, messages, model, max_tokens, tools, signal: options.signal });
+            onChunk({ type: 'finish', content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage });
+            return { content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage };
+        }
+        const dec = new TextDecoder();
+        let buffer = '';
+        let content = '';
+        let usage;
+        let tool_calls;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += dec.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.message?.thinking) {
+                            onChunk({ type: 'thinking', delta: obj.message.thinking });
+                        }
+                        if (obj.message?.content) {
+                            content += obj.message.content;
+                            onChunk({ type: 'delta', content: obj.message.content });
+                        }
+                        if (obj.message?.tool_calls?.length) {
+                            tool_calls = fromOllamaToolCalls(obj.message.tool_calls);
+                        }
+                        if (obj.done) {
+                            if (obj.eval_count != null)
+                                usage = { completion_tokens: obj.eval_count };
+                        }
+                    }
+                    catch {
+                        // skip malformed line
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                try {
+                    const obj = JSON.parse(buffer);
+                    if (obj.message?.thinking)
+                        onChunk({ type: 'thinking', delta: obj.message.thinking });
+                    if (obj.message?.content) {
+                        content += obj.message.content;
+                        onChunk({ type: 'delta', content: obj.message.content });
+                    }
+                    if (obj.message?.tool_calls?.length)
+                        tool_calls = fromOllamaToolCalls(obj.message.tool_calls);
+                    if (obj.done && obj.eval_count != null)
+                        usage = { completion_tokens: obj.eval_count };
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        onChunk({ type: 'finish', content, tool_calls, usage });
+        return { content, tool_calls, usage };
+    }
     const streamClient = provider === 'openai' ? openAiStreamClient : provider === 'openrouter' ? openRouterStreamClient : null;
     const streamDefaultModel = provider === 'openai' ? OPENAI_DEFAULT : provider === 'openrouter' ? OPENROUTER_DEFAULT : '';
     if (!streamClient || !streamDefaultModel) {
@@ -25,6 +148,12 @@ export async function completeStream(options, onChunk) {
         onChunk({ type: 'finish', content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage });
         return { content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage };
     }
+    // Tool calling: use non-streaming so tool_calls.arguments are complete JSON (streaming can truncate and cause JSON.parse errors).
+    if (tools?.length) {
+        const result = await complete({ ...options, provider, messages, model, max_tokens, tools, signal: options.signal });
+        onChunk({ type: 'finish', content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage });
+        return { content: result.content ?? '', tool_calls: result.tool_calls, usage: result.usage };
+    }
     const openAiMessages = messages.map((m) => {
         if (!m.tool_calls?.length)
             return m;
@@ -87,7 +216,7 @@ export async function completeStream(options, onChunk) {
 let openAiStreamClient = null;
 let openRouterStreamClient = null;
 export async function complete(options = {}) {
-    const { provider = defaultProvider, model, messages, max_tokens = 1024, task_id = null, tools, signal, } = options;
+    const { provider = process.env.AI_DEFAULT_PROVIDER ?? 'ollama', model, messages, max_tokens = 1024, task_id = null, tools, signal, } = options;
     const start = Date.now();
     const adapter = getProvider(provider);
     const id = `ai_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
@@ -96,8 +225,14 @@ export async function complete(options = {}) {
         result = await adapter.complete({ model, messages: messages ?? [], max_tokens, tools, signal });
     }
     catch (err) {
-        log('ai', 'error', `Completion failed: ${err instanceof Error ? err.message : err}`, {
+        const errObj = err;
+        const detail = errObj?.status && errObj?.error != null
+            ? `${errObj.status} ${typeof errObj.error === 'object' && errObj.error && 'message' in errObj.error ? errObj.error.message : JSON.stringify(errObj.error)}`
+            : err instanceof Error ? err.message : String(err);
+        log('ai', 'error', `Completion failed: ${detail}`, {
             provider,
+            model: model || adapter.defaultModel,
+            status: errObj?.status,
             stack: err instanceof Error ? err.stack : undefined,
         });
         throw err;
@@ -127,234 +262,386 @@ function stubAdapter(defaultModel = 'stub') {
         },
     };
 }
+const OLLAMA_DEFAULT = process.env.AI_OLLAMA_DEFAULT_MODEL || 'llama3.2';
+const OLLAMA_THINKING_MODELS = ['deepseek-r1', 'qwen3', 'deepseek-v3.1', 'gpt-oss'];
+function ollamaSupportsThinking(model) {
+    const m = (model || OLLAMA_DEFAULT).toLowerCase();
+    return OLLAMA_THINKING_MODELS.some((t) => m === t || m.startsWith(t + ':'));
+}
+/** Convert agent messages to Ollama format (tool_calls use index/object args; tool results use tool_name). */
+function toOllamaMessages(messages) {
+    return messages.map((m) => {
+        const base = {
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? ''),
+        };
+        if (m.role === 'assistant' && m.tool_calls?.length) {
+            base.tool_calls = m.tool_calls.map((tc, i) => ({
+                type: 'function',
+                function: {
+                    index: i,
+                    name: tc.name,
+                    arguments: (() => {
+                        try {
+                            return typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : (tc.arguments ?? {});
+                        }
+                        catch {
+                            return {};
+                        }
+                    })(),
+                },
+            }));
+        }
+        if (m.role === 'tool') {
+            base.tool_name = m.name ?? '';
+        }
+        return base;
+    });
+}
+/** Parse Ollama tool_calls (arguments may be object or string) into agent format. */
+function fromOllamaToolCalls(toolCalls) {
+    if (!toolCalls?.length)
+        return undefined;
+    return toolCalls.map((tc, i) => {
+        const fn = tc.function;
+        const name = fn?.name ?? '';
+        const args = fn?.arguments;
+        const argsStr = typeof args === 'string' ? args : JSON.stringify(args ?? {});
+        return { id: `ollama_${i}_${Date.now()}`, name, arguments: argsStr };
+    });
+}
 const OPENAI_DEFAULT = process.env.AI_OPENAI_DEFAULT_MODEL || 'gpt-4o-mini';
 const OPENROUTER_DEFAULT = process.env.AI_OPENROUTER_DEFAULT_MODEL || 'openai/gpt-4o-mini';
-registerProvider('stub', stubAdapter('stub'));
-if (process.env.OPENAI_API_KEY) {
-    try {
-        const mod = await import('openai').catch(() => ({}));
-        const OpenAI = mod.OpenAI;
-        if (OpenAI) {
-            const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-            openAiStreamClient = client;
-            registerProvider('openai', {
-                defaultModel: OPENAI_DEFAULT,
-                async complete({ model, messages, max_tokens, tools: toolsOpt, signal }) {
-                    // OpenAI expects tool_calls as { id, type: "function", function: { name, arguments } }
-                    const openAiMessages = (messages ?? []).map((m) => {
-                        if (!m.tool_calls?.length)
-                            return m;
-                        return {
-                            ...m,
-                            tool_calls: m.tool_calls.map((tc) => ({
-                                id: tc.id,
-                                type: 'function',
-                                function: { name: tc.name, arguments: tc.arguments ?? '' },
-                            })),
+async function registerAllProviders() {
+    providers.clear();
+    registerProvider('stub', stubAdapter('stub'));
+    if (process.env.OPENAI_API_KEY) {
+        try {
+            const mod = await import('openai').catch(() => ({}));
+            const OpenAI = mod.OpenAI;
+            if (OpenAI) {
+                const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+                openAiStreamClient = client;
+                registerProvider('openai', {
+                    defaultModel: OPENAI_DEFAULT,
+                    async complete({ model, messages, max_tokens, tools: toolsOpt, signal }) {
+                        // OpenAI expects tool_calls as { id, type: "function", function: { name, arguments } }
+                        const openAiMessages = (messages ?? []).map((m) => {
+                            if (!m.tool_calls?.length)
+                                return m;
+                            return {
+                                ...m,
+                                tool_calls: m.tool_calls.map((tc) => ({
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: { name: tc.name, arguments: tc.arguments ?? '' },
+                                })),
+                            };
+                        });
+                        const createOpts = {
+                            model: model || OPENAI_DEFAULT,
+                            messages: openAiMessages,
+                            max_tokens: max_tokens || 1024,
                         };
-                    });
-                    const createOpts = {
-                        model: model || OPENAI_DEFAULT,
-                        messages: openAiMessages,
-                        max_tokens: max_tokens || 1024,
-                    };
-                    if (toolsOpt?.length) {
-                        createOpts.tools = toolsOpt.map((t) => ({
-                            type: 'function',
-                            function: { name: t.name, description: t.description, parameters: t.parameters ?? {} },
+                        if (toolsOpt?.length) {
+                            createOpts.tools = toolsOpt.map((t) => ({
+                                type: 'function',
+                                function: { name: t.name, description: t.description, parameters: t.parameters ?? {} },
+                            }));
+                        }
+                        const res = await client.chat.completions.create(createOpts, signal ? { signal } : undefined);
+                        const choice = res.choices?.[0];
+                        const msg = choice?.message;
+                        const tool_calls = msg?.tool_calls?.map((tc) => ({
+                            id: tc.id,
+                            name: tc.function?.name ?? '',
+                            arguments: tc.function?.arguments ?? '',
                         }));
-                    }
-                    const res = await client.chat.completions.create(createOpts, signal ? { signal } : undefined);
-                    const choice = res.choices?.[0];
-                    const msg = choice?.message;
-                    const tool_calls = msg?.tool_calls?.map((tc) => ({
-                        id: tc.id,
-                        name: tc.function?.name ?? '',
-                        arguments: tc.function?.arguments ?? '',
-                    }));
-                    return {
-                        content: msg?.content ?? '',
-                        usage: res.usage ?? {},
-                        ...(tool_calls?.length ? { tool_calls } : {}),
-                    };
-                },
-            });
+                        return {
+                            content: msg?.content ?? '',
+                            usage: res.usage ?? {},
+                            ...(tool_calls?.length ? { tool_calls } : {}),
+                        };
+                    },
+                });
+            }
+        }
+        catch {
+            // import failed
         }
     }
-    catch {
-        // import failed
-    }
-}
-if (process.env.OPENROUTER_API_KEY) {
-    try {
-        const mod = await import('openai').catch(() => ({}));
-        const OpenAI = mod.OpenAI;
-        if (OpenAI) {
-            const client = new OpenAI({
-                apiKey: process.env.OPENROUTER_API_KEY,
-                baseURL: 'https://openrouter.ai/api/v1',
-            });
-            openRouterStreamClient = client;
-            registerProvider('openrouter', {
-                defaultModel: OPENROUTER_DEFAULT,
-                async complete({ model, messages, max_tokens, tools: toolsOpt, signal }) {
-                    const openAiMessages = (messages ?? []).map((m) => {
-                        if (!m.tool_calls?.length)
-                            return m;
-                        return {
-                            ...m,
-                            tool_calls: m.tool_calls.map((tc) => ({
-                                id: tc.id,
-                                type: 'function',
-                                function: { name: tc.name, arguments: tc.arguments ?? '' },
-                            })),
+    if (process.env.OPENROUTER_API_KEY) {
+        try {
+            const mod = await import('openai').catch(() => ({}));
+            const OpenAI = mod.OpenAI;
+            if (OpenAI) {
+                const client = new OpenAI({
+                    apiKey: process.env.OPENROUTER_API_KEY,
+                    baseURL: 'https://openrouter.ai/api/v1',
+                });
+                openRouterStreamClient = client;
+                registerProvider('openrouter', {
+                    defaultModel: OPENROUTER_DEFAULT,
+                    async complete({ model, messages, max_tokens, tools: toolsOpt, signal }) {
+                        const openAiMessages = (messages ?? []).map((m) => {
+                            if (!m.tool_calls?.length)
+                                return m;
+                            return {
+                                ...m,
+                                tool_calls: m.tool_calls.map((tc) => ({
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: { name: tc.name, arguments: tc.arguments ?? '' },
+                                })),
+                            };
+                        });
+                        const createOpts = {
+                            model: model || OPENROUTER_DEFAULT,
+                            messages: openAiMessages,
+                            max_tokens: max_tokens || 1024,
                         };
-                    });
-                    const createOpts = {
-                        model: model || OPENROUTER_DEFAULT,
-                        messages: openAiMessages,
-                        max_tokens: max_tokens || 1024,
-                    };
-                    if (toolsOpt?.length) {
-                        createOpts.tools = toolsOpt.map((t) => ({
-                            type: 'function',
-                            function: { name: t.name, description: t.description, parameters: t.parameters ?? {} },
+                        if (toolsOpt?.length) {
+                            createOpts.tools = toolsOpt.map((t) => ({
+                                type: 'function',
+                                function: { name: t.name, description: t.description, parameters: t.parameters ?? {} },
+                            }));
+                        }
+                        const res = await client.chat.completions.create(createOpts, signal ? { signal } : undefined);
+                        const choice = res.choices?.[0];
+                        const msg = choice?.message;
+                        const tool_calls = msg?.tool_calls?.map((tc) => ({
+                            id: tc.id,
+                            name: tc.function?.name ?? '',
+                            arguments: tc.function?.arguments ?? '',
                         }));
-                    }
-                    const res = await client.chat.completions.create(createOpts, signal ? { signal } : undefined);
-                    const choice = res.choices?.[0];
-                    const msg = choice?.message;
-                    const tool_calls = msg?.tool_calls?.map((tc) => ({
-                        id: tc.id,
-                        name: tc.function?.name ?? '',
-                        arguments: tc.function?.arguments ?? '',
-                    }));
-                    return {
-                        content: msg?.content ?? '',
-                        usage: res.usage ?? {},
-                        ...(tool_calls?.length ? { tool_calls } : {}),
-                    };
-                },
-            });
+                        return {
+                            content: msg?.content ?? '',
+                            usage: res.usage ?? {},
+                            ...(tool_calls?.length ? { tool_calls } : {}),
+                        };
+                    },
+                });
+            }
+        }
+        catch {
+            // import failed
         }
     }
-    catch {
-        // import failed
+    if (!providers.has('openai')) {
+        registerProvider('openai', stubAdapter(OPENAI_DEFAULT));
     }
-}
-if (!providers.has('openai')) {
-    registerProvider('openai', stubAdapter(OPENAI_DEFAULT));
-}
-const CLAUDE_DEFAULT = process.env.AI_CLAUDE_DEFAULT_MODEL || 'claude-sonnet-4-6';
-if (process.env.ANTHROPIC_API_KEY) {
-    registerProvider('claude', {
-        defaultModel: CLAUDE_DEFAULT,
-        async complete({ model, messages, max_tokens }) {
-            const key = process.env.ANTHROPIC_API_KEY;
-            const systemMsg = messages.find((m) => m.role === 'system');
-            const chatMessages = messages.filter((m) => m.role !== 'system').map((m) => ({
-                role: m.role === 'assistant' ? 'assistant' : 'user',
-                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-            }));
-            const body = {
-                model: model || CLAUDE_DEFAULT,
-                max_tokens: max_tokens || 1024,
-                messages: chatMessages,
-                ...(systemMsg && { system: typeof systemMsg.content === 'string' ? systemMsg.content : JSON.stringify(systemMsg.content) }),
+    const CLAUDE_DEFAULT = process.env.AI_CLAUDE_DEFAULT_MODEL || 'claude-sonnet-4-6';
+    if (process.env.ANTHROPIC_API_KEY) {
+        registerProvider('claude', {
+            defaultModel: CLAUDE_DEFAULT,
+            async complete({ model, messages, max_tokens }) {
+                const key = process.env.ANTHROPIC_API_KEY;
+                const systemMsg = messages.find((m) => m.role === 'system');
+                const chatMessages = messages.filter((m) => m.role !== 'system').map((m) => ({
+                    role: m.role === 'assistant' ? 'assistant' : 'user',
+                    content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+                }));
+                const body = {
+                    model: model || CLAUDE_DEFAULT,
+                    max_tokens: max_tokens || 1024,
+                    messages: chatMessages,
+                    ...(systemMsg && { system: typeof systemMsg.content === 'string' ? systemMsg.content : JSON.stringify(systemMsg.content) }),
+                };
+                const res = await fetch('https://api.anthropic.com/v1/messages', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': key,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify(body),
+                });
+                if (!res.ok) {
+                    const err = await res.text();
+                    throw new Error(`Anthropic API: ${res.status} ${err}`);
+                }
+                const data = (await res.json());
+                const content = data.content?.find((c) => c.type === 'text')?.text || '';
+                const usage = data.usage || {};
+                return { content, usage: { prompt_tokens: usage.input_tokens ?? 0, completion_tokens: usage.output_tokens ?? 0 } };
+            },
+        });
+    }
+    else {
+        registerProvider('claude', stubAdapter(CLAUDE_DEFAULT));
+    }
+    const GEMINI_DEFAULT = process.env.AI_GEMINI_DEFAULT_MODEL || 'gemini-2.5-flash';
+    const GEMINI_KEY = process.env.GOOGLE_GEMINI_API_KEY || process.env.GEMINI_API_KEY;
+    if (GEMINI_KEY) {
+        registerProvider('gemini', {
+            defaultModel: GEMINI_DEFAULT,
+            async complete({ model, messages, max_tokens }) {
+                const modelId = model || GEMINI_DEFAULT;
+                const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${GEMINI_KEY}`;
+                const contents = messages
+                    .filter((m) => m.role !== 'system')
+                    .map((m) => ({
+                    role: (m.role === 'assistant' ? 'model' : 'user'),
+                    parts: [{ text: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) }],
+                }));
+                const systemInstruction = messages.find((m) => m.role === 'system');
+                const body = {
+                    contents: contents.length ? contents : [{ role: 'user', parts: [{ text: '' }] }],
+                    generationConfig: { maxOutputTokens: max_tokens || 1024 },
+                    ...(systemInstruction && {
+                        systemInstruction: { parts: [{ text: typeof systemInstruction.content === 'string' ? systemInstruction.content : JSON.stringify(systemInstruction.content) }] },
+                    }),
+                };
+                const res = await fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(body),
+                });
+                if (!res.ok) {
+                    const err = await res.text();
+                    throw new Error(`Gemini API: ${res.status} ${err}`);
+                }
+                const data = (await res.json());
+                const text = data.candidates?.[0]?.content?.parts?.[0]?.text ?? '';
+                const usage = data.usageMetadata || {};
+                return {
+                    content: text,
+                    usage: { prompt_tokens: usage.promptTokenCount ?? 0, completion_tokens: usage.candidatesTokenCount ?? 0 },
+                };
+            },
+        });
+    }
+    else {
+        registerProvider('gemini', stubAdapter(GEMINI_DEFAULT));
+    }
+    const OLLAMA_DEFAULT = process.env.AI_OLLAMA_DEFAULT_MODEL || 'llama3.2';
+    const OLLAMA_BASE = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+    const OLLAMA_THINKING_MODELS = ['deepseek-r1', 'qwen3', 'deepseek-v3.1', 'gpt-oss'];
+    function ollamaSupportsThinking(model) {
+        const m = (model || OLLAMA_DEFAULT).toLowerCase();
+        return OLLAMA_THINKING_MODELS.some((t) => m === t || m.startsWith(t + ':'));
+    }
+    /** Convert agent messages to Ollama format (tool_calls use index/object args; tool results use tool_name). */
+    function toOllamaMessages(messages) {
+        return messages.map((m) => {
+            const base = {
+                role: m.role,
+                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? ''),
             };
-            const res = await fetch('https://api.anthropic.com/v1/messages', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': key,
-                    'anthropic-version': '2023-06-01',
-                },
-                body: JSON.stringify(body),
-            });
-            if (!res.ok) {
-                const err = await res.text();
-                throw new Error(`Anthropic API: ${res.status} ${err}`);
+            if (m.role === 'assistant' && m.tool_calls?.length) {
+                base.tool_calls = m.tool_calls.map((tc, i) => ({
+                    type: 'function',
+                    function: {
+                        index: i,
+                        name: tc.name,
+                        arguments: (() => {
+                            try {
+                                return typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : (tc.arguments ?? {});
+                            }
+                            catch {
+                                return {};
+                            }
+                        })(),
+                    },
+                }));
             }
-            const data = (await res.json());
-            const content = data.content?.find((c) => c.type === 'text')?.text || '';
-            const usage = data.usage || {};
-            return { content, usage: { prompt_tokens: usage.input_tokens ?? 0, completion_tokens: usage.output_tokens ?? 0 } };
-        },
-    });
-}
-else {
-    registerProvider('claude', stubAdapter(CLAUDE_DEFAULT));
-}
-const GEMINI_DEFAULT = process.env.AI_GEMINI_DEFAULT_MODEL || 'gemini-2.5-flash';
-const GEMINI_KEY = process.env.GOOGLE_GEMINI_API_KEY || process.env.GEMINI_API_KEY;
-if (GEMINI_KEY) {
-    registerProvider('gemini', {
-        defaultModel: GEMINI_DEFAULT,
-        async complete({ model, messages, max_tokens }) {
-            const modelId = model || GEMINI_DEFAULT;
-            const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${GEMINI_KEY}`;
-            const contents = messages
-                .filter((m) => m.role !== 'system')
-                .map((m) => ({
-                role: (m.role === 'assistant' ? 'model' : 'user'),
-                parts: [{ text: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) }],
-            }));
-            const systemInstruction = messages.find((m) => m.role === 'system');
+            if (m.role === 'tool') {
+                base.tool_name = m.name ?? '';
+            }
+            return base;
+        });
+    }
+    /** Parse Ollama tool_calls (arguments may be object or string) into agent format. */
+    function fromOllamaToolCalls(toolCalls) {
+        if (!toolCalls?.length)
+            return undefined;
+        return toolCalls.map((tc, i) => {
+            const fn = tc.function;
+            const name = fn?.name ?? '';
+            const args = fn?.arguments;
+            const argsStr = typeof args === 'string' ? args : JSON.stringify(args ?? {});
+            return { id: `ollama_${i}_${Date.now()}`, name, arguments: argsStr };
+        });
+    }
+    registerProvider('ollama', {
+        defaultModel: OLLAMA_DEFAULT,
+        async complete({ model, messages, max_tokens, think, tools: toolsOpt }) {
+            const url = `${OLLAMA_BASE}/api/chat`;
+            const ollamaMessages = toOllamaMessages(messages ?? []);
             const body = {
-                contents: contents.length ? contents : [{ role: 'user', parts: [{ text: '' }] }],
-                generationConfig: { maxOutputTokens: max_tokens || 1024 },
-                ...(systemInstruction && {
-                    systemInstruction: { parts: [{ text: typeof systemInstruction.content === 'string' ? systemInstruction.content : JSON.stringify(systemInstruction.content) }] },
-                }),
+                model: model || OLLAMA_DEFAULT,
+                messages: ollamaMessages,
+                options: { num_predict: max_tokens || 1024 },
+                stream: false,
+                think: think !== false && ollamaSupportsThinking(model),
             };
-            const res = await fetch(url, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(body),
-            });
+            if (toolsOpt?.length) {
+                body.tools = toolsOpt.map((t) => ({
+                    type: 'function',
+                    function: { name: t.name, description: t.description, parameters: t.parameters ?? {} },
+                }));
+            }
+            console.log('[Ollama] POST', url, 'model:', model || OLLAMA_DEFAULT, toolsOpt?.length ? `tools=${toolsOpt.length}` : '');
+            let res;
+            try {
+                res = await fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(body),
+                });
+            }
+            catch (e) {
+                console.error('[Ollama] fetch failed:', e);
+                const cause = e?.cause;
+                if (cause?.code === 'ECONNREFUSED') {
+                    throw new Error('Ollama is not running. Start it with: ollama serve  (or open the Ollama app).');
+                }
+                throw e;
+            }
             if (!res.ok) {
-                const err = await res.text();
-                throw new Error(`Gemini API: ${res.status} ${err}`);
+                const errText = await res.text();
+                let didRetry = false;
+                if (res.status === 400 && errText.includes('does not support tools') && body.tools) {
+                    delete body.tools;
+                    console.log('[Ollama] Model does not support tools; retrying without tools');
+                    res = await fetch(url, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(body),
+                    });
+                    didRetry = true;
+                }
+                if (!res.ok) {
+                    const err = didRetry ? await res.text() : errText;
+                    const modelName = model || OLLAMA_DEFAULT;
+                    if (res.status === 404 && (err.includes('not found') || err.includes('model'))) {
+                        const { pullOllamaModel } = await import('../ollama-setup.js');
+                        pullOllamaModel(modelName);
+                        throw new Error(`Model "${modelName}" not found. Pulling it now (see terminal); try again in 1–2 min. Or run: ollama pull ${modelName}`);
+                    }
+                    console.error('[Ollama]', res.status, err);
+                    throw new Error(`Ollama: ${res.status} ${err}`);
+                }
             }
             const data = (await res.json());
-            const text = data.candidates?.[0]?.content?.parts?.[0]?.text ?? '';
-            const usage = data.usageMetadata || {};
+            const msg = data.message;
+            const thinking = msg?.thinking ?? '';
+            const content = msg?.content ?? '';
+            const fullContent = thinking ? thinking + (content ? '\n\n' + content : '') : content;
+            const tool_calls = fromOllamaToolCalls(msg?.tool_calls);
             return {
-                content: text,
-                usage: { prompt_tokens: usage.promptTokenCount ?? 0, completion_tokens: usage.candidatesTokenCount ?? 0 },
+                content: fullContent,
+                usage: data.eval_count != null ? { completion_tokens: data.eval_count } : undefined,
+                ...(tool_calls?.length ? { tool_calls } : {}),
             };
         },
     });
+    if (!providers.has('llama'))
+        registerProvider('llama', getProvider('ollama'));
 }
-else {
-    registerProvider('gemini', stubAdapter(GEMINI_DEFAULT));
+await registerAllProviders();
+/** Reload AI providers from current process.env (e.g. after onboarding saves new API keys). No restart needed. */
+export async function reloadProviders() {
+    await registerAllProviders();
 }
-const OLLAMA_DEFAULT = process.env.AI_OLLAMA_DEFAULT_MODEL || 'llama3.2';
-const OLLAMA_BASE = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
-registerProvider('ollama', {
-    defaultModel: OLLAMA_DEFAULT,
-    async complete({ model, messages, max_tokens }) {
-        const url = `${OLLAMA_BASE}/api/chat`;
-        const body = {
-            model: model || OLLAMA_DEFAULT,
-            messages: messages.map((m) => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
-            options: { num_predict: max_tokens || 1024 },
-            stream: false,
-        };
-        const res = await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok) {
-            const err = await res.text();
-            throw new Error(`Ollama: ${res.status} ${err}`);
-        }
-        const data = (await res.json());
-        const content = data.message?.content || '';
-        return { content, usage: data.eval_count != null ? { completion_tokens: data.eval_count } : undefined };
-    },
-});
-if (!providers.has('llama'))
-    registerProvider('llama', getProvider('ollama'));
 //# sourceMappingURL=orchestrator.js.map