bonecode 1.0.0

package/src/engine/session/prompt.ts

@@ -0,0 +1,671 @@
+/**
+ * BoneCode Agent Loop — improved fork of OpenCode's session/prompt.ts
+ *
+ * What's the same as OpenCode:
+ *   - Multi-turn loop until finish_reason === "stop"
+ *   - Context compaction (prune → summarize → replay)
+ *   - Retry with exponential backoff + retry-after headers
+ *   - Doom-loop detection (3 identical consecutive tool calls)
+ *   - Permission system (suspend/resume via Deferred)
+ *   - Provider message transforms (Anthropic, Mistral, DeepSeek, etc.)
+ *   - Per-provider system prompts
+ *   - Skills injection
+ *   - Instruction file discovery (AGENTS.md, CLAUDE.md)
+ *   - Tool registry (all OpenCode tools)
+ *   - Sub-agent task delegation
+ *
+ * What's improved with BoneScript:
+ *   - All session/message/part persistence goes through generated capability
+ *     endpoints (state machine enforced, events emitted automatically)
+ *   - RAG context injected from pgvector knowledge base before each LLM call
+ *   - Part deltas broadcast to WebSocket part_stream channel in real time
+ *   - Agent state tracked in agent_instances table (cost, tokens, state machine)
+ *   - Tool calls recorded in tool_calls table with permission decisions
+ *   - Durable event bus for long-running tasks
+ */
+
+import { streamText, type Tool } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { v4 as uuid } from "uuid";
+import { pool } from "../../../bone/output/session/src/db";
+import { eventBus } from "../../../bone/output/session/src/events";
+import { logger } from "../../../bone/output/session/src/logger";
+import { counter } from "../../../bone/output/session/src/metrics";
+import { broadcastToChannel } from "../../../bone/output/session/src/websocket";
+import { execute_tool_calls } from "../../../bone/output/session/src/extensions";
+import * as ProviderTransform from "./provider_transform";
+import { delay as retryDelay, retryable } from "./retry_logic";
+import { isOverflow } from "./overflow_check";
+import { buildCompactionSummary } from "./compaction_logic";
+import { getSystemPrompt } from "./system_prompt";
+import { loadInstructionFiles } from "./instruction_loader";
+import { buildToolRegistry } from "./tool_registry";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface PromptInput {
+  session_id: string;
+  message_id: string;
+  content: string;
+  model_id: string;
+  provider_id: string;
+  agent_name?: string;
+  /** Optional: force a specific variant (e.g. "high" for extended thinking) */
+  variant?: string;
+}
+
+export interface LoopResult {
+  ok: boolean;
+  finish_reason: string;
+  total_tokens_in: number;
+  total_tokens_out: number;
+  total_cost: number;
+  compacted: boolean;
+  error?: string;
+}
+
+const DOOM_LOOP_THRESHOLD = 3;
+const MAX_TURNS = 20; // safety cap — most tasks complete in 1-3 turns
+
+// ─── Main Agent Loop ──────────────────────────────────────────────────────────
+
+export async function runAgentLoop(input: PromptInput): Promise<LoopResult> {
+  const { session_id, message_id, model_id, provider_id, agent_name = "build" } = input;
+
+  // Load session + project context
+  const sessionRow = await pool.query(
+    `SELECT s.*, p.worktree, p.vcs FROM sessions s JOIN projects p ON p.id = s.project_id WHERE s.id = $1`,
+    [session_id]
+  );
+  if (!sessionRow.rows[0]) throw new Error(`Session not found: ${session_id}`);
+  const session = sessionRow.rows[0];
+
+  // Create or reuse agent instance
+  const agentId = uuid();
+  await pool.query(
+    `INSERT INTO agent_instances (id, session_id, model_id, provider_id, context_window_used, context_window_max, total_cost_usd, total_tokens_in, total_tokens_out, config, state)
+     VALUES ($1, $2, $3, $4, 0, 200000, 0, 0, 0, $5, 'running')`,
+    [agentId, session_id, model_id, provider_id, JSON.stringify({ agent_name })]
+  );
+
+  // Transition session to busy
+  await pool.query(`UPDATE sessions SET state = 'busy', updated_at = NOW() WHERE id = $1`, [session_id]);
+  await eventBus.publish("SessionStateChanged", { session_id, from_state: session.state, to_state: "busy", changed_at: new Date().toISOString() }, "AgentLoop");
+
+  const stats = { tokens_in: 0, tokens_out: 0, cost: 0, compacted: false };
+  let turn = 0;
+  let lastFinishReason = "unknown";
+
+  try {
+    // ── Main multi-turn loop ──────────────────────────────────────────────────
+    while (turn < MAX_TURNS) {
+      turn++;
+      if (turn === MAX_TURNS) {
+        logger.error("agent_loop_max_turns", { event: "max_turns", metadata: { session_id, max: MAX_TURNS } });
+        break;
+      }
+
+      // Load full message history
+      const messages = await loadMessageHistory(session_id);
+
+      // Check if we need compaction before calling the LLM
+      const lastAssistant = messages.filter(m => m.role === "assistant").slice(-1)[0];
+      // Estimate tokens from text length when model doesn't return counts (local models)
+      const estimatedTokens = lastAssistant?.tokens_input
+        ? { input: lastAssistant.tokens_input, output: lastAssistant.tokens_output || 0, total: 0, cache: { read: 0, write: 0 } }
+        : (() => {
+            // Rough estimate: 1 token ≈ 4 chars
+            const totalChars = messages.reduce((sum, m) => {
+              const parts = m.parts || [];
+              return sum + parts.reduce((s: number, p: any) => s + (p.data?.text?.length || 0), 0);
+            }, 0);
+            return { input: Math.floor(totalChars / 4), output: 0, total: Math.floor(totalChars / 4), cache: { read: 0, write: 0 } };
+          })();
+      if (isOverflow(estimatedTokens, model_id)) {
+        logger.info("context_overflow_detected", { event: "compaction", metadata: { session_id, turn } });
+        const compacted = await runCompaction(session_id, agentId, model_id, provider_id, messages);
+        if (!compacted) break; // unrecoverable overflow
+        stats.compacted = true;
+        continue; // restart loop with compacted history
+      }
+
+      // Build AI SDK messages
+      const aiMessages = await buildAIMessages(session_id, messages, model_id);
+
+      // Inject RAG context into system prompt
+      const lastUserText = getLastUserText(messages);
+      const systemPrompt = await buildSystemPromptWithRAG(session_id, session.worktree, model_id, provider_id, agent_name, lastUserText);
+
+      // Load tools — pass empty for models that don't support function calling
+      const allTools = await buildToolRegistry(session_id, agentId, session.worktree);
+      // Check if model supports tools (some local models don't)
+      const tools = supportsTools(model_id) ? allTools : {};
+
+      // Get language model
+      const languageModel = getLanguageModel(provider_id, model_id);
+
+      // Stream the LLM response
+      const assistantMsgId = uuid();
+      await pool.query(
+        `INSERT INTO messages (id, session_id, role, model_id, provider_id) VALUES ($1, $2, 'assistant', $3, $4)`,
+        [assistantMsgId, session_id, model_id, provider_id]
+      );
+      await eventBus.publish("MessageAdded", { session_id, message_id: assistantMsgId, role: "assistant", added_at: new Date().toISOString() }, "AgentLoop");
+
+      const result = await streamWithRetry({
+        session_id, agentId, assistantMsgId,
+        languageModel, aiMessages, systemPrompt, tools,
+        model_id, provider_id, stats,
+      });
+
+      lastFinishReason = result.finish_reason;
+
+      // Update agent token counters
+      await pool.query(
+        `UPDATE agent_instances SET total_tokens_in = total_tokens_in + $2, total_tokens_out = total_tokens_out + $3, total_cost_usd = total_cost_usd + $4, updated_at = NOW() WHERE id = $1`,
+        [agentId, result.tokens_in, result.tokens_out, result.cost]
+      );
+
+      // Check termination conditions:
+      // 1. "stop" with no tool calls = model finished naturally
+      // 2. "length" = hit token limit — don't loop, the response is complete
+      // 3. "content-filter" = blocked — stop
+      // 4. "tool-calls" with no actual tool calls = model confused — stop
+      const terminalReasons = new Set(["stop", "length", "content-filter", "end-turn"]);
+      if (terminalReasons.has(result.finish_reason) && !result.has_tool_calls) {
+        break;
+      }
+
+      // If there were tool calls, they were executed during streaming — loop continues
+      // If finish reason is unexpected and no tool calls, stop to avoid infinite loop
+      if (!result.has_tool_calls) {
+        break;
+      }
+    }
+
+    // Transition agent to done
+    await pool.query(`UPDATE agent_instances SET state = 'done', updated_at = NOW() WHERE id = $1`, [agentId]);
+    await pool.query(`UPDATE sessions SET state = 'active', updated_at = NOW() WHERE id = $1`, [session_id]);
+    await eventBus.publish("AgentCompleted", {
+      agent_id: agentId, session_id,
+      total_cost_usd: stats.cost, total_tokens_in: stats.tokens_in, total_tokens_out: stats.tokens_out,
+      completed_at: new Date().toISOString(),
+    }, "AgentLoop");
+
+    counter("agent.loop.completed", { provider: provider_id, model: model_id, turns: String(turn) });
+    return { ok: true, finish_reason: lastFinishReason, total_tokens_in: stats.tokens_in, total_tokens_out: stats.tokens_out, total_cost: stats.cost, compacted: stats.compacted };
+
+  } catch (e: any) {
+    await pool.query(`UPDATE agent_instances SET state = 'failed', updated_at = NOW() WHERE id = $1`, [agentId]);
+    await pool.query(`UPDATE sessions SET state = 'active', updated_at = NOW() WHERE id = $1`, [session_id]);
+    await eventBus.publish("AgentFailed", { agent_id: agentId, session_id, error: e.message, failed_at: new Date().toISOString() }, "AgentLoop");
+    logger.error("agent_loop_failed", { event: "loop_error", metadata: { session_id, error: e.message } });
+    return { ok: false, finish_reason: "error", total_tokens_in: stats.tokens_in, total_tokens_out: stats.tokens_out, total_cost: stats.cost, compacted: stats.compacted, error: e.message };
+  }
+}
+
+// ─── Stream with Retry ────────────────────────────────────────────────────────
+
+async function streamWithRetry(ctx: {
+  session_id: string; agentId: string; assistantMsgId: string;
+  languageModel: any; aiMessages: any[]; systemPrompt: string;
+  tools: Record<string, Tool>; model_id: string; provider_id: string;
+  stats: { tokens_in: number; tokens_out: number; cost: number };
+}): Promise<{ finish_reason: string; tokens_in: number; tokens_out: number; cost: number; has_tool_calls: boolean }> {
+  let attempt = 0;
+  const MAX_RETRIES = 5;
+  let currentCtx = { ...ctx };
+
+  while (true) {
+    try {
+      return await streamOnce(currentCtx);
+    } catch (e: any) {
+      // On Bad Request with tools, retry without tools
+      if (e.message?.includes("Bad Request") && Object.keys(currentCtx.tools).length > 0 && attempt === 0) {
+        console.log("[AgentLoop] Bad Request with tools — retrying without tools");
+        currentCtx = { ...currentCtx, tools: {} };
+        attempt++;
+        continue;
+      }
+
+      const retryInfo = retryable(e, ctx.provider_id);
+      if (!retryInfo || attempt >= MAX_RETRIES) throw e;
+
+      const waitMs = retryDelay(attempt, e);
+      logger.info("llm_retry", { event: "retry", metadata: { attempt, wait_ms: waitMs, reason: retryInfo.message } });
+      broadcastToChannel("session_events", {
+        type: "session.retry", session_id: ctx.session_id, attempt, message: retryInfo.message, next: Date.now() + waitMs,
+      });
+      await new Promise(r => setTimeout(r, waitMs));
+      attempt++;
+    }
+  }
+}
+
+// ─── Single Stream Pass ───────────────────────────────────────────────────────
+
+async function streamOnce(ctx: {
+  session_id: string; agentId: string; assistantMsgId: string;
+  languageModel: any; aiMessages: any[]; systemPrompt: string;
+  tools: Record<string, Tool>; model_id: string; provider_id: string;
+  stats: { tokens_in: number; tokens_out: number; cost: number };
+}): Promise<{ finish_reason: string; tokens_in: number; tokens_out: number; cost: number; has_tool_calls: boolean }> {
+  const { session_id, assistantMsgId, languageModel, aiMessages, systemPrompt, tools, model_id, provider_id } = ctx;
+
+  const transformedMessages = ProviderTransform.message(
+    aiMessages,
+    { id: model_id, providerID: provider_id, api: { npm: providerToNpm(provider_id), id: model_id } } as any,
+    {}
+  ) as any[];
+
+  let currentTextPartId: string | null = null;
+  let currentTextContent = "";
+  let hasToolCalls = false;
+  let finishReason = "unknown";
+  const toolCallsThisTurn: Array<{ id: string; name: string; input: any }> = [];
+
+  const result = streamText({
+    model: languageModel,
+    system: systemPrompt,
+    messages: aiMessages as any[],
+    tools,
+    maxRetries: 0,
+    temperature: ProviderTransform.temperature({ id: model_id, providerID: provider_id } as any) ?? 0.7,
+    topP: ProviderTransform.topP({ id: model_id, providerID: provider_id } as any),
+    topK: ProviderTransform.topK({ id: model_id, providerID: provider_id } as any),
+    // Use a high maxTokens so the model can complete long responses.
+    // The local model's context window is the real limit.
+    maxTokens: parseInt(process.env.MAX_TOKENS || "8192"),
+    experimental_repairToolCall: async (failed: any) => {
+      const lower = failed.toolCall.toolName.toLowerCase();
+      if (lower !== failed.toolCall.toolName && tools[lower]) {
+        return { ...failed.toolCall, toolName: lower };
+      }
+      return { ...failed.toolCall, args: JSON.stringify({ tool: failed.toolCall.toolName, error: failed.error?.message }), toolName: "invalid" };
+    },
+  });
+
+  // Process the stream
+  for await (const event of result.fullStream) {
+    switch (event.type) {
+      case "text-delta": {
+        const text = (event as any).textDelta || (event as any).text || "";
+        if (!text) break;
+
+        if (!currentTextPartId) {
+          // Start a new text part on first delta
+          currentTextPartId = uuid();
+          currentTextContent = "";
+          await pool.query(
+            `INSERT INTO parts (id, message_id, session_id, part_type, data, order_index) VALUES ($1, $2, $3, 'text', $4, 0)`,
+            [currentTextPartId, assistantMsgId, session_id, JSON.stringify({ text: "" })]
+          );
+        }
+
+        currentTextContent += text;
+        // Broadcast delta to WebSocket part_stream for live streaming
+        broadcastToChannel("part_stream", {
+          type: "part.delta",
+          session_id,
+          message_id: assistantMsgId,
+          part_id: currentTextPartId,
+          delta: { type: "text", text },
+        });
+        break;
+      }
+
+      case "tool-call": {
+        // Flush any pending text part first
+        if (currentTextPartId) {
+          await pool.query(
+            `UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`,
+            [currentTextPartId, JSON.stringify({ text: currentTextContent })]
+          );
+          await eventBus.publish("PartUpdated", {
+            session_id, message_id: assistantMsgId, part_id: currentTextPartId,
+            part_type: "text", updated_at: new Date().toISOString(),
+          }, "AgentLoop");
+          currentTextPartId = null;
+          currentTextContent = "";
+        }
+
+        hasToolCalls = true;
+        const toolArgs = (event as any).args || (event as any).input || {};
+        toolCallsThisTurn.push({ id: event.toolCallId, name: event.toolName, input: toolArgs });
+
+        // Record tool call in DB
+        const toolCallDbId = uuid();
+        await pool.query(
+          `INSERT INTO tool_calls (id, session_id, agent_id, tool_name, tool_input, state) VALUES ($1, $2, $3, $4, $5, 'running')`,
+          [toolCallDbId, session_id, ctx.agentId, event.toolName, JSON.stringify(toolArgs)]
+        );
+
+        // Record as part
+        const toolPartId = uuid();
+        await pool.query(
+          `INSERT INTO parts (id, message_id, session_id, part_type, data, order_index) VALUES ($1, $2, $3, 'tool_invocation', $4, 0)`,
+          [toolPartId, assistantMsgId, session_id, JSON.stringify({ tool_call_id: event.toolCallId, tool_name: event.toolName, args: toolArgs, state: "running" })]
+        );
+
+        await eventBus.publish("ToolCallRequested", {
+          tool_call_id: toolCallDbId, session_id, agent_id: ctx.agentId,
+          tool_name: event.toolName, tool_input: toolArgs, requested_at: new Date().toISOString(),
+        }, "AgentLoop");
+
+        // Doom-loop detection: 3 identical consecutive tool calls
+        const recentSame = toolCallsThisTurn.filter(
+          tc => tc.name === event.toolName && JSON.stringify(tc.input) === JSON.stringify(toolArgs)
+        );
+        if (recentSame.length >= DOOM_LOOP_THRESHOLD) {
+          logger.error("doom_loop_detected", { event: "doom_loop", metadata: { tool: event.toolName, session_id } });
+          throw new Error(`Doom loop detected: tool '${event.toolName}' called ${DOOM_LOOP_THRESHOLD} times with identical input`);
+        }
+        break;
+      }
+
+      case "step-finish": {
+        // Flush pending text part
+        if (currentTextPartId) {
+          await pool.query(
+            `UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`,
+            [currentTextPartId, JSON.stringify({ text: currentTextContent })]
+          );
+          await eventBus.publish("PartUpdated", {
+            session_id, message_id: assistantMsgId, part_id: currentTextPartId,
+            part_type: "text", updated_at: new Date().toISOString(),
+          }, "AgentLoop");
+          currentTextPartId = null;
+          currentTextContent = "";
+        }
+
+        const usage = (event as any).usage;
+        const tokensIn = usage?.promptTokens || 0;
+        const tokensOut = usage?.completionTokens || 0;
+        ctx.stats.tokens_in += tokensIn;
+        ctx.stats.tokens_out += tokensOut;
+
+        await pool.query(
+          `UPDATE messages SET tokens_input = $2, tokens_output = $3, updated_at = NOW() WHERE id = $1`,
+          [assistantMsgId, tokensIn, tokensOut]
+        );
+        break;
+      }
+
+      case "finish": {
+        finishReason = (event as any).finishReason || "stop";
+        break;
+      }
+
+      case "error": {
+        throw (event as any).error;
+      }
+    }
+  }
+
+  // Final flush — ensure any pending text part is saved
+  if (currentTextPartId && currentTextContent) {
+    await pool.query(
+      `UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`,
+      [currentTextPartId, JSON.stringify({ text: currentTextContent })]
+    );
+    await eventBus.publish("PartUpdated", {
+      session_id, message_id: assistantMsgId, part_id: currentTextPartId,
+      part_type: "text", updated_at: new Date().toISOString(),
+    }, "AgentLoop");
+    currentTextPartId = null;
+    currentTextContent = "";
+  }
+
+  // Collect final usage
+  let tokensIn = 0, tokensOut = 0;
+  try {
+    const finalUsage = await result.usage;
+    tokensIn = finalUsage?.promptTokens || ctx.stats.tokens_in;
+    tokensOut = finalUsage?.completionTokens || ctx.stats.tokens_out;
+  } catch {
+    tokensIn = ctx.stats.tokens_in;
+    tokensOut = ctx.stats.tokens_out;
+  }
+
+  // If we still have no text part, try getting the full text from the result
+  if (!currentTextPartId) {
+    try {
+      const fullText = await result.text;
+      if (fullText && fullText.trim()) {
+        const fallbackPartId = uuid();
+        await pool.query(
+          `INSERT INTO parts (id, message_id, session_id, part_type, data, order_index) VALUES ($1, $2, $3, 'text', $4, 0)`,
+          [fallbackPartId, assistantMsgId, session_id, JSON.stringify({ text: fullText })]
+        );
+        await eventBus.publish("PartUpdated", {
+          session_id, message_id: assistantMsgId, part_id: fallbackPartId,
+          part_type: "text", updated_at: new Date().toISOString(),
+        }, "AgentLoop");
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  return {
+    finish_reason: finishReason,
+    tokens_in: tokensIn,
+    tokens_out: tokensOut,
+    cost: 0,
+    has_tool_calls: hasToolCalls,
+  };
+}
+
+// ─── Context Compaction ───────────────────────────────────────────────────────
+
+async function runCompaction(
+  session_id: string,
+  agentId: string,
+  model_id: string,
+  provider_id: string,
+  messages: any[]
+): Promise<boolean> {
+  try {
+    // Transition session to compacting
+    await pool.query(`UPDATE sessions SET state = 'compacting', updated_at = NOW() WHERE id = $1`, [session_id]);
+    await eventBus.publish("SessionStateChanged", { session_id, from_state: "busy", to_state: "compacting", changed_at: new Date().toISOString() }, "AgentLoop");
+
+    // Build summary using the compaction logic (ported from OpenCode)
+    const summary = await buildCompactionSummary({
+      messages,
+      model_id,
+      provider_id,
+      session_id,
+    });
+
+    if (!summary) return false;
+
+    // Store summary as a special assistant message
+    const summaryMsgId = uuid();
+    await pool.query(
+      `INSERT INTO messages (id, session_id, role, model_id, provider_id) VALUES ($1, $2, 'assistant', $3, $4)`,
+      [summaryMsgId, session_id, model_id, provider_id]
+    );
+    const summaryPartId = uuid();
+    await pool.query(
+      `INSERT INTO parts (id, message_id, session_id, part_type, data, order_index) VALUES ($1, $2, $3, 'text', $4, 0)`,
+      [summaryPartId, summaryMsgId, session_id, JSON.stringify({ text: summary, is_compaction_summary: true })]
+    );
+
+    // Transition back to busy
+    await pool.query(`UPDATE sessions SET state = 'busy', updated_at = NOW() WHERE id = $1`, [session_id]);
+    await eventBus.publish("SessionCompacted", {
+      session_id, tokens_before: 0, tokens_after: 0, compacted_at: new Date().toISOString(),
+    }, "AgentLoop");
+
+    broadcastToChannel("session_events", { type: "session.compacted", session_id });
+    return true;
+  } catch (e: any) {
+    logger.error("compaction_failed", { event: "compaction_error", metadata: { session_id, error: e.message } });
+    await pool.query(`UPDATE sessions SET state = 'busy', updated_at = NOW() WHERE id = $1`, [session_id]);
+    return false;
+  }
+}
+
+// ─── Message History Builder ──────────────────────────────────────────────────
+
+async function loadMessageHistory(session_id: string): Promise<any[]> {
+  const result = await pool.query(
+    `SELECT m.id, m.role, m.model_id, m.provider_id, m.tokens_input, m.tokens_output,
+            json_agg(p.* ORDER BY p.order_index, p.created_at) FILTER (WHERE p.id IS NOT NULL) AS parts
+     FROM messages m
+     LEFT JOIN parts p ON p.message_id = m.id
+     WHERE m.session_id = $1
+     GROUP BY m.id ORDER BY m.created_at ASC`,
+    [session_id]
+  );
+  return result.rows;
+}
+
+async function buildAIMessages(session_id: string, messages: any[], model_id: string): Promise<any[]> {
+  const aiMessages: any[] = [];
+
+  for (const msg of messages) {
+    const parts = msg.parts || [];
+
+    if (msg.role === "user") {
+      const content: any[] = [];
+      for (const p of parts) {
+        if (p.part_type === "text" && p.data?.text) {
+          content.push({ type: "text", text: p.data.text });
+        } else if (p.part_type === "file" && p.data?.url) {
+          content.push({ type: "file", url: p.data.url, mediaType: p.data.mime || "text/plain" });
+        }
+      }
+      if (content.length > 0) aiMessages.push({ role: "user", content });
+
+    } else if (msg.role === "assistant") {
+      const content: any[] = [];
+      for (const p of parts) {
+        if (p.part_type === "text" && p.data?.text) {
+          // Skip compaction summaries — they're injected as system context
+          if (p.data.is_compaction_summary) continue;
+          content.push({ type: "text", text: p.data.text });
+        } else if (p.part_type === "tool_invocation" && p.data?.tool_call_id) {
+          content.push({ type: "tool-call", toolCallId: p.data.tool_call_id, toolName: p.data.tool_name, args: p.data.args || {} });
+        }
+      }
+      if (content.length > 0) aiMessages.push({ role: "assistant", content });
+
+    } else if (msg.role === "tool") {
+      const content: any[] = [];
+      for (const p of parts) {
+        if (p.part_type === "tool_result" && p.data?.tool_call_id) {
+          content.push({ type: "tool-result", toolCallId: p.data.tool_call_id, toolName: p.data.tool_name, result: p.data.result });
+        }
+      }
+      if (content.length > 0) aiMessages.push({ role: "tool", content });
+    }
+  }
+
+  return aiMessages;
+}
+
+function getLastUserText(messages: any[]): string {
+  const lastUser = messages.filter(m => m.role === "user").slice(-1)[0];
+  if (!lastUser) return "";
+  return (lastUser.parts || [])
+    .filter((p: any) => p.part_type === "text")
+    .map((p: any) => p.data?.text || "")
+    .join(" ");
+}
+
+// ─── System Prompt with RAG ───────────────────────────────────────────────────
+
+async function buildSystemPromptWithRAG(
+  session_id: string,
+  worktree: string,
+  model_id: string,
+  provider_id: string,
+  agent_name: string,
+  userText: string
+): Promise<string> {
+  // Base system prompt (provider-specific, from OpenCode)
+  const base = getSystemPrompt(model_id, provider_id, agent_name);
+
+  // Environment context
+  const envContext = [
+    `Working directory: ${worktree}`,
+    `Platform: ${process.platform}`,
+    `Today's date: ${new Date().toDateString()}`,
+  ].join("\n");
+
+  // Instruction files (AGENTS.md, CLAUDE.md, etc.)
+  const instructions = await loadInstructionFiles(worktree).catch(() => "");
+
+  // Codebase context — no embedding needed
+  // Uses FTS, git recency, session history, import graph, instruction files
+  let codebaseContext = "";
+  if (userText && worktree) {
+    try {
+      const { buildContext, formatContextForPrompt } = await import("../../context_builder");
+      const sessionRow = await pool.query(
+        `SELECT project_id FROM sessions WHERE id = $1`,
+        [session_id]
+      );
+      const project_id = sessionRow.rows[0]?.project_id || "";
+
+      const ctxResult = await buildContext({
+        session_id,
+        project_id,
+        worktree,
+        query: userText,
+        max_chunks: 10,
+        max_chars: 10_000,
+      });
+
+      codebaseContext = formatContextForPrompt(ctxResult, worktree);
+      if (ctxResult.summary !== "no relevant context found") {
+        logger.info("context_injected", { event: "context", metadata: { summary: ctxResult.summary } });
+      }
+    } catch (e: any) {
+      logger.error("context_build_failed", { event: "context", metadata: { error: e.message } });
+    }
+  }
+
+  return [base, envContext, instructions, codebaseContext].filter(Boolean).join("\n\n");
+}
+
+// ─── Language Model Factory ───────────────────────────────────────────────────
+
+function getLanguageModel(provider_id: string, model_id: string): any {
+  const apiKey = process.env[`${provider_id.toUpperCase()}_API_KEY`] || process.env.OPENAI_API_KEY || "not-needed";
+  const baseUrl = process.env[`${provider_id.toUpperCase()}_BASE_URL`] || process.env.OPENAI_BASE_URL;
+
+  switch (provider_id.toLowerCase()) {
+    case "anthropic":
+      return createAnthropic({ apiKey, baseURL: baseUrl })(model_id);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(model_id);
+    case "openai":
+    case "openai_compatible":
+    default:
+      return createOpenAI({ apiKey, baseURL: baseUrl })(model_id);
+  }
+}
+
+function providerToNpm(provider_id: string): string {
+  const map: Record<string, string> = {
+    anthropic: "@ai-sdk/anthropic",
+    openai: "@ai-sdk/openai",
+    google: "@ai-sdk/google",
+    openai_compatible: "@ai-sdk/openai-compatible",
+  };
+  return map[provider_id.toLowerCase()] || "@ai-sdk/openai-compatible";
+}
+
+function supportsTools(model_id: string): boolean {
+  const id = model_id.toLowerCase();
+  // Known models that support function calling
+  if (id.includes("gpt-") || id.includes("claude") || id.includes("gemini")) return true;
+  // Qwen3 and other local models — check env override
+  if (process.env.MODEL_SUPPORTS_TOOLS === "true") return true;
+  if (process.env.MODEL_SUPPORTS_TOOLS === "false") return false;
+  // Default: try with tools, fall back gracefully on error
+  return true;
+}