v0.55.0 — Context-limit protection + Telegram message-length fix

Two fixes for session stability:

1. Context-limit-exceeded error recovery (loop.go):
   - Added isContextLengthError() — detects context-length errors
     from DeepSeek, OpenAI, and Anthropic providers
   - Added trimToSurvival() — nuclear-option trimming that drops all
     but system prompt + last 2 turn groups + last user message
   - Modified runLoop error handling: on context-length error,
     auto-trims and retries once instead of failing the session
   - 6 new tests: error detection (positive + negative), survival
     trimming (minimal, multi-turn, no-system)

2. Telegram verbose progress truncation (telegram.go):
   - Added truncateToolArgs() — truncates tool call JSON arguments
     to 2000 chars for verbose progress messages
   - Prevents Telegram "message is too long" (400) error for
     large write_file/batch_write content payloads
   - 3 new tests: short passthrough, long truncation, exact boundary

Author: molty3000

cmd/odek/telegram.go

@@ -1306,7 +1306,7 @@ func handleChatMessage(
 
 				if toolProgress == "verbose" {
 					recordToolStart()
-					line := fmt.Sprintf("%s `%s` %s", render.ToolEmoji(name), name, data)
+					line := fmt.Sprintf("%s `%s` %s", render.ToolEmoji(name), name, truncateToolArgs(data, 2000))
 					line = telegram.EscapeMarkdown(line)
 					bot.SendMessage(chatID, line,
 						&telegram.SendOpts{ParseMode: telegram.ParseModeMarkdownV2})
@@ -1717,6 +1717,17 @@ func sendAsync(bot *telegram.Bot, chatID int64, text string, opts *telegram.Send
 	}()
 }
 
+// truncateToolArgs truncates tool call arguments to at most maxLen characters
+// for Telegram progress display. This prevents the "message is too long" error
+// (Telegram's 4096 character limit) when sending verbose progress messages for
+// calls like write_file that include large content payloads.
+func truncateToolArgs(data string, maxLen int) string {
+	if len(data) <= maxLen {
+		return data
+	}
+	return data[:maxLen] + fmt.Sprintf("… [%d more bytes]", len(data)-maxLen)
+}
+
 // ── Singleton Lock ─────────────────────────────────────────────────────
 //
 // Prevents two bot instances from polling Telegram simultaneously (which

cmd/odek/telegram_test.go

@@ -731,3 +731,32 @@ func TestToolLatencyTracking(t *testing.T) {
 		t.Errorf("expected empty after draining queue, got %q", lat)
 	}
 }
+
+// ── truncateToolArgs tests ────────────────────────────────────────────
+
+func TestTruncateToolArgs_Short(t *testing.T) {
+	data := `{"path": "test.go"}`
+	got := truncateToolArgs(data, 2000)
+	if got != data {
+		t.Errorf("short data should not be truncated: got %q", got)
+	}
+}
+
+func TestTruncateToolArgs_Long(t *testing.T) {
+	data := `{"content": "` + strings.Repeat("A", 5000) + `"}`
+	got := truncateToolArgs(data, 100)
+	if len(got) >= len(data) {
+		t.Error("long data should be truncated")
+	}
+	if !strings.Contains(got, "more bytes") {
+		t.Error("truncated data should include byte count")
+	}
+}
+
+func TestTruncateToolArgs_ExactBoundary(t *testing.T) {
+	data := strings.Repeat("x", 100)
+	got := truncateToolArgs(data, 100)
+	if got != data {
+		t.Errorf("data at exact maxLen should not be truncated: got len=%d", len(got))
+	}
+}

internal/loop/loop.go

@@ -372,6 +372,99 @@ func (e *Engine) trimContext(messages []llm.Message, toolDefs []llm.ToolDef) []l
 	return messages
 }
 
+// isContextLengthError returns true for API errors that indicate the
+// input exceeded the model's context window. These errors are retryable
+// with aggressive trimming rather than killing the session.
+func isContextLengthError(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := err.Error()
+	// Common error patterns across providers:
+	// DeepSeek: "context_length_exceeded", "maximum context length"
+	// OpenAI:   "maximum context length", "token limit"
+	// Anthropic: "input is too long", "context window"
+	return strings.Contains(msg, "context_length_exceeded") ||
+		strings.Contains(msg, "maximum context length") ||
+		strings.Contains(msg, "context length") ||
+		strings.Contains(msg, "token limit") ||
+		strings.Contains(msg, "context window") ||
+		strings.Contains(msg, "max_input_tokens") ||
+		strings.Contains(msg, "input length") ||
+		strings.Contains(msg, "too many tokens") ||
+		strings.Contains(msg, "input is too long") ||
+		strings.Contains(msg, "reduce the length")
+}
+
+// trimToSurvival drops all but the system prompt, first user message,
+// and the most recent 2 complete turn groups. This is the nuclear option
+// used when the API rejects the request as context-length-exceeded.
+// Unlike trimContext which gives up when it can't stay under budget,
+// trimToSurvival always produces a drastically reduced message list
+// that nearly every model can handle.
+func trimToSurvival(msgs []llm.Message) []llm.Message {
+	if len(msgs) <= 3 {
+		return msgs // already minimal enough
+	}
+	start := 0
+	if msgs[0].Role == "system" {
+		start = 1 // keep system
+	}
+	// Last user message (the current task/input) — always keep it.
+	var lastUser llm.Message
+	lastUserIdx := -1
+	for i := len(msgs) - 1; i >= 0; i-- {
+		if msgs[i].Role == "user" {
+			lastUser = msgs[i]
+			lastUserIdx = i
+			break
+		}
+	}
+
+	// Collect the last 2 complete assistant→tool groups before the user msg.
+	var groups []llm.Message
+	seen := 0
+	for i := lastUserIdx - 1; i > start && seen < 2; i-- {
+		if msgs[i].Role == "assistant" && len(msgs[i].ToolCalls) > 0 {
+			// This assistant message has tool calls — collect it and
+			// its following tool results.
+			groupEnd := i + 1
+			for groupEnd < len(msgs) && msgs[groupEnd].Role == "tool" {
+				groupEnd++
+			}
+			groups = append(groups, msgs[i:groupEnd]...)
+			// Also include any preceding system messages (corrections, warnings).
+			preStart := i - 1
+			for preStart > start && msgs[preStart].Role == "system" {
+				preStart--
+			}
+			for k := preStart + 1; k < i; k++ {
+				groups = append(groups, msgs[k])
+			}
+			seen++
+		}
+	}
+
+	// Build survival set: system + task + recent groups + last user
+	survival := make([]llm.Message, 0, start+1+len(groups)+1)
+	if start > 0 {
+		survival = append(survival, msgs[0]) // system message
+	}
+	// Add a context-warning system message
+	warning := "[Context trimmed to survive: the conversation history exceeded the model's context window. Earlier turns have been dropped. If you need information from earlier in the conversation, the agent may ask for a summary.]"
+	survival = append(survival, llm.Message{Role: "system", Content: warning})
+
+	// Add the recent groups (in chronological order, not reversed)
+	for i := len(groups) - 1; i >= 0; i-- {
+		survival = append(survival, groups[i])
+	}
+
+	// Add the last user message
+	survival = append(survival, lastUser)
+
+	return survival
+}
+
 // ── Loop ──────────────────────────────────────────────────────────────
 
 // Run executes the loop for a given task and returns the final response.
@@ -562,6 +655,26 @@ func (e *Engine) runLoop(ctx context.Context, messages []llm.Message) (string, [
 		result, err := e.client.Call(ctx, callMsgs, systemBlocks, tools)
 		latency := time.Since(start)
 		if err != nil {
+			// Context-length-exceeded errors: don't die — try aggressive
+			// trimming and retry once. The trimContext at the top of the
+			// loop may have been too conservative (75% budget) or the
+			// provider's reported context window may be smaller than
+			// the actual model limit.
+			if isContextLengthError(err) {
+				trimmed := trimToSurvival(messages)
+				if len(trimmed) < len(messages) {
+					messages = trimmed
+					// Reset memory index — trimToSurvival drops it.
+					e.memMsgIdx = -1
+					// Inject survival warning as the final message
+					// so the agent knows context was lost.
+					messages = append(messages, llm.Message{
+						Role:    "system",
+						Content: "[Context survival mode: the conversation was aggressively reduced to fit the model's context window. Continue from where you left off using the most recent context available.]",
+					})
+					continue // retry this iteration
+				}
+			}
 			return "", messages, fmt.Errorf("iteration %d: %w", i, err)
 		}
 

internal/loop/loop_test.go

@@ -1953,3 +1953,162 @@ func TestToolPanic_DoesNotKillAgent(t *testing.T) {
 		t.Errorf("agent result = %q, want 'Agent survived'", result)
 	}
 }
+
+// ── Context Length Error Detection ────────────────────────────────────
+
+func TestIsContextLengthError_Nil(t *testing.T) {
+	if isContextLengthError(nil) {
+		t.Error("nil should not be a context length error")
+	}
+}
+
+func TestIsContextLengthError_DeepSeek(t *testing.T) {
+	err := fmt.Errorf("llm: 400 Bad Request (status 400): context_length_exceeded")
+	if !isContextLengthError(err) {
+		t.Error("DeepSeek context_length_exceeded should be detected")
+	}
+}
+
+func TestIsContextLengthError_OpenAI(t *testing.T) {
+	err := fmt.Errorf("llm: 400 Bad Request (status 400): maximum context length is 128000 tokens")
+	if !isContextLengthError(err) {
+		t.Error("OpenAI 'maximum context length' should be detected")
+	}
+}
+
+func TestIsContextLengthError_Anthropic(t *testing.T) {
+	err := fmt.Errorf("llm: 400 Bad Request: input is too long: token count 150000 exceeds max context window 200000")
+	if !isContextLengthError(err) {
+		t.Error("Anthropic 'input is too long' should be detected")
+	}
+}
+
+func TestIsContextLengthError_Negative(t *testing.T) {
+	errors := []error{
+		fmt.Errorf("llm: 401 Unauthorized (status 401)"),
+		fmt.Errorf("llm: connection refused"),
+		fmt.Errorf("llm: 429 Too Many Requests"),
+		fmt.Errorf("llm: timeout while awaiting headers"),
+		fmt.Errorf("llm: invalid API key"),
+		fmt.Errorf("internal server error"),
+	}
+	for _, err := range errors {
+		if isContextLengthError(err) {
+			t.Errorf("should not detect context length for: %v", err)
+		}
+	}
+}
+
+// ── trimToSurvival ────────────────────────────────────────────────────
+
+func TestTrimToSurvival_AlreadyMinimal(t *testing.T) {
+	msgs := []llm.Message{
+		{Role: "system", Content: "you are a helpful agent"},
+		{Role: "user", Content: "do something"},
+	}
+	got := trimToSurvival(msgs)
+	if len(got) != 2 { // Already minimal — no warning needed
+		t.Errorf("expected 2 messages for minimal input, got %d", len(got))
+	}
+	if got[0].Content != msgs[0].Content {
+		t.Errorf("system message preserved: got %q, want %q", got[0].Content, msgs[0].Content)
+	}
+	if got[1].Content != msgs[1].Content {
+		t.Errorf("user message preserved: got %q, want %q", got[1].Content, msgs[1].Content)
+	}
+}
+
+func TestTrimToSurvival_DropsOldTurns(t *testing.T) {
+	msgs := []llm.Message{
+		{Role: "system", Content: "system prompt"},
+		{Role: "user", Content: "original task"},
+		// Turn 1
+		{Role: "assistant", Content: "", ToolCalls: []llm.ToolCall{{ID: "c1", Function: struct {
+			Name      string `json:"name"`
+			Arguments string `json:"arguments"`
+		}{Name: "read_file", Arguments: `{"path":"a.go"}`}}}},
+		{Role: "tool", Content: "result 1", Name: "read_file", ToolCallID: "c1"},
+		// Turn 2
+		{Role: "assistant", Content: "", ToolCalls: []llm.ToolCall{{ID: "c2", Function: struct {
+			Name      string `json:"name"`
+			Arguments string `json:"arguments"`
+		}{Name: "write_file", Arguments: `{"path":"b.go"}`}}}},
+		{Role: "tool", Content: "result 2", Name: "write_file", ToolCallID: "c2"},
+		// Turn 3 (most recently completed)
+		{Role: "assistant", Content: "", ToolCalls: []llm.ToolCall{{ID: "c3", Function: struct {
+			Name      string `json:"name"`
+			Arguments string `json:"arguments"`
+		}{Name: "search_files", Arguments: `{"pattern":"*.go"}`}}}},
+		{Role: "tool", Content: "result 3", Name: "search_files", ToolCallID: "c3"},
+		// Current user input
+		{Role: "user", Content: "continue working"},
+	}
+	got := trimToSurvival(msgs)
+	// Should have: system + warning + last 2 turns + last user
+	// Turn 1 should be dropped (only keep 2 most recent turns)
+	if len(got) < 5 {
+		t.Fatalf("expected at least 5 messages, got %d: %v", len(got), got)
+	}
+	// System preserved
+	if got[0].Content != "system prompt" {
+		t.Errorf("expected system prompt, got %q", got[0].Content)
+	}
+	// Warning injected
+	if !strings.Contains(got[1].Content, "Context trimmed") {
+		t.Errorf("expected context trim warning at index 1, got %q", got[1].Content)
+	}
+	// Last user message preserved as final message
+	last := got[len(got)-1]
+	if last.Role != "user" || last.Content != "continue working" {
+		t.Errorf("expected last user message preserved, got role=%q content=%q", last.Role, last.Content)
+	}
+	// Turn 1 (read_file) should be dropped — only last 2 turns survive
+	for _, m := range got {
+		if m.ToolCallID == "c1" {
+			t.Error("Turn 1 should have been dropped")
+		}
+	}
+	// Turn 2 and 3 should survive
+	foundTurn2 := false
+	foundTurn3 := false
+	for _, m := range got {
+		if m.ToolCallID == "c2" {
+			foundTurn2 = true
+		}
+		if m.ToolCallID == "c3" {
+			foundTurn3 = true
+		}
+	}
+	if !foundTurn2 {
+		t.Error("Turn 2 (recent) should survive")
+	}
+	if !foundTurn3 {
+		t.Error("Turn 3 (most recent) should survive")
+	}
+}
+
+func TestTrimToSurvival_NoSystem(t *testing.T) {
+	// Without system message, trimToSurvival still works
+	msgs := []llm.Message{
+		{Role: "user", Content: "task"},
+		{Role: "assistant", Content: "", ToolCalls: []llm.ToolCall{{ID: "c1", Function: struct {
+			Name      string `json:"name"`
+			Arguments string `json:"arguments"`
+		}{Name: "echo", Arguments: `{}`}}}},
+		{Role: "tool", Content: "result", Name: "echo", ToolCallID: "c1"},
+		{Role: "user", Content: "continue"},
+	}
+	got := trimToSurvival(msgs)
+	if len(got) < 2 {
+		t.Fatalf("expected at least 2 messages, got %d", len(got))
+	}
+	// Warning message should be first
+	if !strings.Contains(got[0].Content, "Context trimmed") {
+		t.Errorf("expected warning at index 0, got %q", got[0].Content)
+	}
+	// Last user message preserved
+	last := got[len(got)-1]
+	if last.Content != "continue" {
+		t.Errorf("expected last user message, got %q", last.Content)
+	}
+}