bonecode 1.0.0 → 1.2.0

package/dist/src/engine/session/prompt.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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
+ */
+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;
+}
+export declare function runAgentLoop(input: PromptInput): Promise<LoopResult>;

package/dist/src/engine/session/prompt.js

@@ -0,0 +1,584 @@
+"use strict";
+/**
+ * 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentLoop = void 0;
+const ai_1 = require("ai");
+const anthropic_1 = require("@ai-sdk/anthropic");
+const openai_1 = require("@ai-sdk/openai");
+const google_1 = require("@ai-sdk/google");
+const uuid_1 = require("uuid");
+const db_1 = require("../../../bone/output/session/src/db");
+const events_1 = require("../../../bone/output/session/src/events");
+const logger_1 = require("../../../bone/output/session/src/logger");
+const metrics_1 = require("../../../bone/output/session/src/metrics");
+const websocket_1 = require("../../../bone/output/session/src/websocket");
+const ProviderTransform = __importStar(require("./provider_transform"));
+const retry_logic_1 = require("./retry_logic");
+const overflow_check_1 = require("./overflow_check");
+const compaction_logic_1 = require("./compaction_logic");
+const system_prompt_1 = require("./system_prompt");
+const instruction_loader_1 = require("./instruction_loader");
+const tool_registry_1 = require("./tool_registry");
+const DOOM_LOOP_THRESHOLD = 3;
+const MAX_TURNS = 20; // safety cap — most tasks complete in 1-3 turns
+// ─── Main Agent Loop ──────────────────────────────────────────────────────────
+async function runAgentLoop(input) {
+    const { session_id, message_id, model_id, provider_id, agent_name = "build" } = input;
+    // Load session + project context
+    const sessionRow = await db_1.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 = (0, uuid_1.v4)();
+    await db_1.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 db_1.pool.query(`UPDATE sessions SET state = 'busy', updated_at = NOW() WHERE id = $1`, [session_id]);
+    await events_1.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_1.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, p) => 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 ((0, overflow_check_1.isOverflow)(estimatedTokens, model_id)) {
+                logger_1.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 (0, tool_registry_1.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 = (0, uuid_1.v4)();
+            await db_1.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 events_1.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 db_1.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 db_1.pool.query(`UPDATE agent_instances SET state = 'done', updated_at = NOW() WHERE id = $1`, [agentId]);
+        await db_1.pool.query(`UPDATE sessions SET state = 'active', updated_at = NOW() WHERE id = $1`, [session_id]);
+        await events_1.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");
+        (0, metrics_1.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) {
+        await db_1.pool.query(`UPDATE agent_instances SET state = 'failed', updated_at = NOW() WHERE id = $1`, [agentId]);
+        await db_1.pool.query(`UPDATE sessions SET state = 'active', updated_at = NOW() WHERE id = $1`, [session_id]);
+        await events_1.eventBus.publish("AgentFailed", { agent_id: agentId, session_id, error: e.message, failed_at: new Date().toISOString() }, "AgentLoop");
+        logger_1.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 };
+    }
+}
+exports.runAgentLoop = runAgentLoop;
+// ─── Stream with Retry ────────────────────────────────────────────────────────
+async function streamWithRetry(ctx) {
+    let attempt = 0;
+    const MAX_RETRIES = 5;
+    let currentCtx = { ...ctx };
+    while (true) {
+        try {
+            return await streamOnce(currentCtx);
+        }
+        catch (e) {
+            // On Bad Request with tools, retry without tools
+            if (e.message?.includes("Bad Request") && Object.keys(currentCtx.tools).length > 0 && attempt === 0) {
+                // Local model doesn't support function calling — silently retry without tools
+                currentCtx = { ...currentCtx, tools: {} };
+                attempt++;
+                continue;
+            }
+            const retryInfo = (0, retry_logic_1.retryable)(e, ctx.provider_id);
+            if (!retryInfo || attempt >= MAX_RETRIES)
+                throw e;
+            const waitMs = (0, retry_logic_1.delay)(attempt, e);
+            logger_1.logger.info("llm_retry", { event: "retry", metadata: { attempt, wait_ms: waitMs, reason: retryInfo.message } });
+            (0, websocket_1.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) {
+    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 } }, {});
+    let currentTextPartId = null;
+    let currentTextContent = "";
+    let hasToolCalls = false;
+    let finishReason = "unknown";
+    const toolCallsThisTurn = [];
+    const result = (0, ai_1.streamText)({
+        model: languageModel,
+        system: systemPrompt,
+        messages: aiMessages,
+        tools,
+        maxRetries: 0,
+        temperature: ProviderTransform.temperature({ id: model_id, providerID: provider_id }) ?? 0.7,
+        topP: ProviderTransform.topP({ id: model_id, providerID: provider_id }),
+        topK: ProviderTransform.topK({ id: model_id, providerID: provider_id }),
+        // 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) => {
+            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.textDelta || event.text || "";
+                if (!text)
+                    break;
+                if (!currentTextPartId) {
+                    // Start a new text part on first delta
+                    currentTextPartId = (0, uuid_1.v4)();
+                    currentTextContent = "";
+                    await db_1.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
+                (0, websocket_1.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 db_1.pool.query(`UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`, [currentTextPartId, JSON.stringify({ text: currentTextContent })]);
+                    await events_1.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.args || event.input || {};
+                toolCallsThisTurn.push({ id: event.toolCallId, name: event.toolName, input: toolArgs });
+                // Record tool call in DB
+                const toolCallDbId = (0, uuid_1.v4)();
+                await db_1.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 = (0, uuid_1.v4)();
+                await db_1.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 events_1.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_1.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 db_1.pool.query(`UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`, [currentTextPartId, JSON.stringify({ text: currentTextContent })]);
+                    await events_1.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.usage;
+                const tokensIn = usage?.promptTokens || 0;
+                const tokensOut = usage?.completionTokens || 0;
+                ctx.stats.tokens_in += tokensIn;
+                ctx.stats.tokens_out += tokensOut;
+                await db_1.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.finishReason || "stop";
+                break;
+            }
+            case "error": {
+                throw event.error;
+            }
+        }
+    }
+    // Final flush — ensure any pending text part is saved
+    if (currentTextPartId && currentTextContent) {
+        await db_1.pool.query(`UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`, [currentTextPartId, JSON.stringify({ text: currentTextContent })]);
+        await events_1.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 = (0, uuid_1.v4)();
+                await db_1.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 events_1.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, agentId, model_id, provider_id, messages) {
+    try {
+        // Transition session to compacting
+        await db_1.pool.query(`UPDATE sessions SET state = 'compacting', updated_at = NOW() WHERE id = $1`, [session_id]);
+        await events_1.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 (0, compaction_logic_1.buildCompactionSummary)({
+            messages,
+            model_id,
+            provider_id,
+            session_id,
+        });
+        if (!summary)
+            return false;
+        // Store summary as a special assistant message
+        const summaryMsgId = (0, uuid_1.v4)();
+        await db_1.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 = (0, uuid_1.v4)();
+        await db_1.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 db_1.pool.query(`UPDATE sessions SET state = 'busy', updated_at = NOW() WHERE id = $1`, [session_id]);
+        await events_1.eventBus.publish("SessionCompacted", {
+            session_id, tokens_before: 0, tokens_after: 0, compacted_at: new Date().toISOString(),
+        }, "AgentLoop");
+        (0, websocket_1.broadcastToChannel)("session_events", { type: "session.compacted", session_id });
+        return true;
+    }
+    catch (e) {
+        logger_1.logger.error("compaction_failed", { event: "compaction_error", metadata: { session_id, error: e.message } });
+        await db_1.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) {
+    const result = await db_1.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, messages, model_id) {
+    const aiMessages = [];
+    for (const msg of messages) {
+        const parts = msg.parts || [];
+        if (msg.role === "user") {
+            const content = [];
+            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 = [];
+            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 = [];
+            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) {
+    const lastUser = messages.filter(m => m.role === "user").slice(-1)[0];
+    if (!lastUser)
+        return "";
+    return (lastUser.parts || [])
+        .filter((p) => p.part_type === "text")
+        .map((p) => p.data?.text || "")
+        .join(" ");
+}
+// ─── System Prompt with RAG ───────────────────────────────────────────────────
+async function buildSystemPromptWithRAG(session_id, worktree, model_id, provider_id, agent_name, userText) {
+    // Base system prompt (provider-specific, from OpenCode)
+    const base = (0, system_prompt_1.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 (0, instruction_loader_1.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 Promise.resolve().then(() => __importStar(require("../../context_builder")));
+            const sessionRow = await db_1.pool.query(`SELECT project_id FROM sessions WHERE id = $1`, [session_id]);
+            const project_id = sessionRow.rows[0]?.project_id || "";
+            if (!project_id) {
+                // No project linked yet — skip RAG context
+                return [base, envContext, instructions].filter(Boolean).join("\n\n");
+            }
+            const ctxResult = await buildContext({
+                session_id,
+                project_id,
+                worktree,
+                query: userText,
+                max_chunks: 10,
+                max_chars: 10000,
+            });
+            codebaseContext = formatContextForPrompt(ctxResult, worktree);
+            if (ctxResult.summary !== "no relevant context found") {
+                logger_1.logger.info("context_injected", { event: "context", metadata: { summary: ctxResult.summary } });
+            }
+        }
+        catch (e) {
+            logger_1.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, model_id) {
+    const pid = provider_id.toLowerCase();
+    // "local" shorthand — use .env defaults
+    const resolvedProvider = pid === "local"
+        ? (process.env.DEFAULT_PROVIDER || "openai_compatible").toLowerCase()
+        : pid;
+    const resolvedModel = pid === "local"
+        ? (process.env.DEFAULT_MODEL || model_id)
+        : model_id;
+    const apiKey = (process.env[`${resolvedProvider.toUpperCase()}_API_KEY`] ||
+        process.env.OPENAI_API_KEY ||
+        "not-needed");
+    const baseUrl = (process.env[`${resolvedProvider.toUpperCase()}_BASE_URL`] ||
+        process.env.OPENAI_BASE_URL);
+    switch (resolvedProvider) {
+        case "anthropic":
+            return (0, anthropic_1.createAnthropic)({ apiKey, baseURL: baseUrl })(resolvedModel);
+        case "google":
+            return (0, google_1.createGoogleGenerativeAI)({ apiKey })(resolvedModel);
+        case "groq": {
+            const { createGroq } = require("@ai-sdk/groq");
+            return createGroq({ apiKey: process.env.GROQ_API_KEY || apiKey })(resolvedModel);
+        }
+        case "cerebras": {
+            const { createCerebras } = require("@ai-sdk/cerebras");
+            return createCerebras({ apiKey: process.env.CEREBRAS_API_KEY || apiKey })(resolvedModel);
+        }
+        case "deepseek": {
+            // DeepSeek is OpenAI-compatible
+            return (0, openai_1.createOpenAI)({
+                apiKey: process.env.DEEPSEEK_API_KEY || apiKey,
+                baseURL: "https://api.deepseek.com/v1",
+            })(resolvedModel);
+        }
+        case "openrouter": {
+            const { createOpenRouter } = require("@openrouter/ai-sdk-provider");
+            return createOpenRouter({
+                apiKey: process.env.OPENROUTER_API_KEY || apiKey,
+            })(resolvedModel);
+        }
+        case "ollama": {
+            // Ollama is OpenAI-compatible on localhost:11434
+            return (0, openai_1.createOpenAI)({
+                apiKey: "ollama",
+                baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
+            })(resolvedModel);
+        }
+        case "openai":
+            return (0, openai_1.createOpenAI)({ apiKey, baseURL: baseUrl })(resolvedModel);
+        case "openai_compatible":
+        default:
+            return (0, openai_1.createOpenAI)({ apiKey, baseURL: baseUrl })(resolvedModel);
+    }
+}
+function providerToNpm(provider_id) {
+    const map = {
+        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) {
+    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;
+}
+//# sourceMappingURL=prompt.js.map