feat: switch primary to Ollama Cloud (Qwen 3.5 397B) with parallel tool calling

- Fix Ollama tool calling: add tool_name field for tool results (Ollama uses
  tool_name instead of tool_call_id), use real IDs from API when available
- Switch routing: level 1+2 → ollama-cloud (qwen3.5:397b-cloud) with vision
- Parallel tool execution: multiple tool calls run concurrently via goroutines
- Increase max tool iterations from 5 to 10

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Alexey Panfilov

.gitignore

@@ -21,3 +21,4 @@ openspec
 config/routing.json
 migrate-to-pg
 bin/
+/agent

config/config.yaml

@@ -76,11 +76,13 @@ models:
     max_tokens: 64
     no_think: true
 
-  # Ollama local — simple tasks via Ollama Cloud model (routed through local Ollama).
-  ollama-local:
-    model: qwen3.5:cloud
-    base_url: http://host.docker.internal:11434
+  # Ollama Cloud — Qwen 3.5 via Ollama Cloud API.
+  ollama-cloud:
+    model: qwen3.5:397b-cloud
+    base_url: https://api.ollama.com
+    api_key: ${OLLAMA_API_KEY}
     max_tokens: 4096
+    vision: true
 
   # Claude via bridge (host service wrapping `claude -p` CLI).
   # Requires claude-bridge running on host:9900.
@@ -91,8 +93,8 @@ models:
     max_tokens: 120
 
 routing:
-  local: deepseek              # level 1: simple tasks → DeepSeek
-  default: deepseek            # level 2: moderate tasks → DeepSeek
+  local: ollama-cloud           # level 1: simple tasks → Qwen via Ollama Cloud
+  default: ollama-cloud         # level 2: moderate tasks → Qwen via Ollama Cloud
   reasoner: claude             # level 3: complex reasoning → Claude
   fallback: gemini-flash-lite
   multimodal: gemini-flash     # vision/audio fallback (used when primary lacks vision)

internal/agent/agent.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log/slog"
 	"strings"
+	"sync"
 	"time"
 	"unicode/utf8"
 
@@ -20,7 +21,7 @@ func encodeBase64(data []byte) string {
 }
 
 const (
-	maxToolIterations = 5
+	maxToolIterations = 10
 	semanticRecentN   = 10 // always include last N messages in current session
 	semanticTopK      = 20 // up to K older turns selected by similarity within session
 
@@ -170,29 +171,7 @@ func (a *Agent) Process(ctx context.Context, chatID int64, userMsg llm.Message,
 			ToolCalls: resp.ToolCalls,
 		})
 
-		for _, tc := range resp.ToolCalls {
-			if onToolCall != nil {
-				onToolCall(tc.Name)
-			}
-			a.logger.Info("tool call", "tool", tc.Name)
-			result, err := a.callTool(ctx, tc.Name, tc.Arguments)
-			if err != nil {
-				a.logger.Warn("tool call failed", "tool", tc.Name, "err", err)
-				result = fmt.Sprintf("Error: %s", err.Error())
-			}
-			if len(result) > toolResultSummarizeThreshold {
-				if summarized, sErr := a.summarizeToolResult(ctx, tc.Name, result); sErr == nil {
-					a.logger.Info("tool result summarized", "tool", tc.Name, "original_len", len(result), "summary_len", len(summarized))
-					result = summarized
-				}
-			}
-			a.logger.Info("tool result", "tool", tc.Name, "result_len", len(result))
-			a.store.AddMessage(chatID, llm.Message{
-				Role:       "tool",
-				Content:    result,
-				ToolCallID: tc.ID,
-			})
-		}
+		a.executeToolCalls(ctx, chatID, resp.ToolCalls, onToolCall)
 	}
 
 	return "", fmt.Errorf("exceeded maximum tool iterations (%d)", maxToolIterations)
@@ -279,11 +258,36 @@ func (a *Agent) ProcessStream(ctx context.Context, chatID int64, userMsg llm.Mes
 			ToolCalls: toolCalls,
 		})
 
-		for _, tc := range toolCalls {
-			if onToolCall != nil {
-				onToolCall(tc.Name)
-			}
-			a.logger.Info("tool call", "tool", tc.Name)
+		a.executeToolCalls(ctx, chatID, toolCalls, onToolCall)
+	}
+
+	return "", fmt.Errorf("exceeded maximum tool iterations (%d)", maxToolIterations)
+}
+
+// SupportsStreaming returns true if the current provider supports streaming.
+func (a *Agent) SupportsStreaming() bool {
+	return a.router.SupportsStreaming()
+}
+
+// executeToolCalls runs tool calls in parallel and stores results in order.
+func (a *Agent) executeToolCalls(ctx context.Context, chatID int64, toolCalls []llm.ToolCall, onToolCall func(string)) {
+	type toolResult struct {
+		tc     llm.ToolCall
+		result string
+	}
+
+	results := make([]toolResult, len(toolCalls))
+	var wg sync.WaitGroup
+
+	for i, tc := range toolCalls {
+		if onToolCall != nil {
+			onToolCall(tc.Name)
+		}
+		a.logger.Info("tool call", "tool", tc.Name)
+
+		wg.Add(1)
+		go func(idx int, tc llm.ToolCall) {
+			defer wg.Done()
 			result, err := a.callTool(ctx, tc.Name, tc.Arguments)
 			if err != nil {
 				a.logger.Warn("tool call failed", "tool", tc.Name, "err", err)
@@ -296,20 +300,20 @@ func (a *Agent) ProcessStream(ctx context.Context, chatID int64, userMsg llm.Mes
 				}
 			}
 			a.logger.Info("tool result", "tool", tc.Name, "result_len", len(result))
-			a.store.AddMessage(chatID, llm.Message{
-				Role:       "tool",
-				Content:    result,
-				ToolCallID: tc.ID,
-			})
-		}
+			results[idx] = toolResult{tc: tc, result: result}
+		}(i, tc)
 	}
 
-	return "", fmt.Errorf("exceeded maximum tool iterations (%d)", maxToolIterations)
-}
+	wg.Wait()
 
-// SupportsStreaming returns true if the current provider supports streaming.
-func (a *Agent) SupportsStreaming() bool {
-	return a.router.SupportsStreaming()
+	// Store results in original order.
+	for _, r := range results {
+		a.store.AddMessage(chatID, llm.Message{
+			Role:       "tool",
+			Content:    r.result,
+			ToolCallID: r.tc.ID,
+		})
+	}
 }
 
 func (a *Agent) ClearHistory(chatID int64) {

internal/llm/ollama.go

@@ -72,9 +72,11 @@ type ollamaMessage struct {
 	Content   string            `json:"content"`
 	Images    []string          `json:"images,omitempty"`
 	ToolCalls []ollamaToolCall  `json:"tool_calls,omitempty"`
+	ToolName  string            `json:"tool_name,omitempty"`
 }
 
 type ollamaToolCall struct {
+	ID       string             `json:"id,omitempty"`
 	Function ollamaFunctionCall `json:"function"`
 }
 
@@ -166,8 +168,12 @@ func (p *ollamaProvider) Chat(ctx context.Context, messages []Message, systemPro
 		if err != nil {
 			argsJSON = []byte("{}")
 		}
+		callID := tc.ID
+		if callID == "" {
+			callID = fmt.Sprintf("call_%d", i)
+		}
 		result.ToolCalls = append(result.ToolCalls, ToolCall{
-			ID:        fmt.Sprintf("call_%d", i),
+			ID:        callID,
 			Name:      tc.Function.Name,
 			Arguments: string(argsJSON),
 		})
@@ -180,12 +186,29 @@ func (p *ollamaProvider) buildMessages(messages []Message, systemPrompt string)
 	if systemPrompt != "" {
 		msgs = append(msgs, ollamaMessage{Role: "system", Content: systemPrompt})
 	}
+	// Build a map from tool call ID → tool name for resolving tool results.
+	toolCallNames := make(map[string]string)
+	for _, m := range messages {
+		for _, tc := range m.ToolCalls {
+			if tc.ID != "" {
+				toolCallNames[tc.ID] = tc.Name
+			}
+		}
+	}
+
 	for _, m := range messages {
 		msg := ollamaMessage{
 			Role:    m.Role,
 			Content: m.Content,
 		}
 
+		// Ollama uses "tool_name" instead of "tool_call_id" for tool results.
+		if m.Role == "tool" && m.ToolCallID != "" {
+			if name, ok := toolCallNames[m.ToolCallID]; ok {
+				msg.ToolName = name
+			}
+		}
+
 		// Handle multimodal parts.
 		if len(m.Parts) > 0 {
 			var textParts []string

internal/llm/ollama_test.go

@@ -0,0 +1,86 @@
+package llm
+
+import (
+	"encoding/json"
+	"testing"
+
+	"telegram-agent/internal/config"
+)
+
+func TestOllamaBuildMessages_ToolNamePopulated(t *testing.T) {
+	p, _ := NewOllama(config.ModelConfig{Model: "test"})
+
+	messages := []Message{
+		{Role: "user", Content: "what's the weather?"},
+		{
+			Role: "assistant",
+			ToolCalls: []ToolCall{
+				{ID: "call_0", Name: "get_weather", Arguments: `{"city":"Belgrade"}`},
+			},
+		},
+		{Role: "tool", Content: `{"temp":22}`, ToolCallID: "call_0"},
+	}
+
+	ollamaMsgs := p.buildMessages(messages, "")
+
+	// Find the tool result message.
+	var toolMsg *ollamaMessage
+	for i := range ollamaMsgs {
+		if ollamaMsgs[i].Role == "tool" {
+			toolMsg = &ollamaMsgs[i]
+			break
+		}
+	}
+
+	if toolMsg == nil {
+		t.Fatal("no tool message found")
+	}
+	if toolMsg.ToolName != "get_weather" {
+		t.Errorf("expected tool_name='get_weather', got '%s'", toolMsg.ToolName)
+	}
+
+	// Verify it serializes correctly.
+	b, _ := json.Marshal(toolMsg)
+	var raw map[string]any
+	json.Unmarshal(b, &raw)
+	if raw["tool_name"] != "get_weather" {
+		t.Errorf("JSON tool_name missing or wrong: %s", string(b))
+	}
+}
+
+func TestOllamaBuildMessages_MultipleToolCalls(t *testing.T) {
+	p, _ := NewOllama(config.ModelConfig{Model: "test"})
+
+	messages := []Message{
+		{Role: "user", Content: "weather and time?"},
+		{
+			Role: "assistant",
+			ToolCalls: []ToolCall{
+				{ID: "call_0", Name: "get_weather", Arguments: `{"city":"Belgrade"}`},
+				{ID: "call_1", Name: "get_time", Arguments: `{"tz":"CET"}`},
+			},
+		},
+		{Role: "tool", Content: `{"temp":22}`, ToolCallID: "call_0"},
+		{Role: "tool", Content: `{"time":"14:00"}`, ToolCallID: "call_1"},
+	}
+
+	ollamaMsgs := p.buildMessages(messages, "")
+
+	expected := map[string]string{
+		`{"temp":22}`:     "get_weather",
+		`{"time":"14:00"}`: "get_time",
+	}
+
+	for _, msg := range ollamaMsgs {
+		if msg.Role == "tool" {
+			want, ok := expected[msg.Content]
+			if !ok {
+				t.Errorf("unexpected tool content: %s", msg.Content)
+				continue
+			}
+			if msg.ToolName != want {
+				t.Errorf("content=%s: expected tool_name='%s', got '%s'", msg.Content, want, msg.ToolName)
+			}
+		}
+	}
+}