bonecode 1.3.0 → 1.4.2

package/src/engine/session/build_mode_helpers.ts

@@ -0,0 +1,72 @@
+/**
+ * Provider/model factory used by build_mode.ts for structured-output prompts.
+ * Mirrors the factory in prompt.ts so the build orchestrator can issue
+ * non-streaming model calls without depending on the streaming agent loop.
+ */
+
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+
+export function getLanguageModel(provider_id: string, model_id: string): any {
+  const pid = provider_id.toLowerCase();
+
+  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 createAnthropic({ apiKey, baseURL: baseUrl })(resolvedModel);
+
+    case "google":
+      return 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":
+      return 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":
+      return createOpenAI({
+        apiKey: "ollama",
+        baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
+      })(resolvedModel);
+
+    case "openai":
+    case "openai_compatible":
+    default:
+      return createOpenAI({ apiKey, baseURL: baseUrl })(resolvedModel);
+  }
+}

package/src/engine/session/leaked_tool_call.ts

@@ -0,0 +1,166 @@
+/**
+ * Pure, side-effect-free parser for leaked tool-call markers.
+ *
+ * Some local models (gemma, qwen, llama variants) emit their internal
+ * tool-call markers as raw text instead of producing structured tool_call
+ * events. The AI SDK's parser misses these, so the model's prose appears in
+ * the output but no tool ever runs.
+ *
+ * This module recovers the intended call by pattern-matching the leaked text.
+ * No DB, no network, no global state — pure functions only, fully testable.
+ *
+ * Patterns recognized (across multiple template formats):
+ *   <|tool_call|>{"name":"write","arguments":{...}}<|/tool_call|>
+ *   <|tool_call>name:write{...args...}<tool_call|>
+ *   <tool_call>{"name":"write","arguments":{...}}</tool_call>
+ *   <function_call>{"name":"write","arguments":{...}}</function_call>
+ *   ```tool_code\nwrite(path="x", content="y")\n```
+ *   <|python_tag|>write({"path": "x"})<|/python_tag|>
+ */
+
+export interface LeakedToolCall {
+  toolName: string;
+  toolInput: Record<string, any>;
+  startIndex: number;
+  endIndex: number;
+}
+
+export function extractLeakedToolCall(text: string): LeakedToolCall | null {
+  // Pattern 1: <|tool_call|>...<|/tool_call|> or <tool_call>...</tool_call>
+  const blockPatterns = [
+    /<\|tool_call\|?>([\s\S]*?)<\|?\/?tool_call\|?>/i,
+    /<tool_call>([\s\S]*?)<\/?tool_call>/i,
+    /<function_call>([\s\S]*?)<\/?function_call>/i,
+    /<\|python_tag\|>([\s\S]*?)<\|?\/?python_tag\|?>/i,
+  ];
+  for (const re of blockPatterns) {
+    const m = text.match(re);
+    if (!m || m.index === undefined) continue;
+    const body = m[1];
+    const parsed = parseLeakedBody(body);
+    if (parsed) {
+      return { ...parsed, startIndex: m.index, endIndex: m.index + m[0].length };
+    }
+  }
+
+  // Pattern 2: ```tool_code ... ```
+  const codeBlock = text.match(/```(?:tool_code|tool_call|function|python)\s*\n([\s\S]*?)\n```/i);
+  if (codeBlock && codeBlock.index !== undefined) {
+    const parsed = parseLeakedBody(codeBlock[1]);
+    if (parsed) {
+      return { ...parsed, startIndex: codeBlock.index, endIndex: codeBlock.index + codeBlock[0].length };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Parse the body of a leaked tool-call block. Tries multiple formats:
+ *   - JSON: {"name": "write", "arguments": {...}} or {"tool":"write","args":{...}}
+ *   - Function-call style: write(path="x", content="y")
+ *   - Pseudo-syntax: call:write{path:"x"}
+ */
+export function parseLeakedBody(body: string): { toolName: string; toolInput: Record<string, any> } | null {
+  if (!body) return null;
+  const trimmed = body.trim();
+
+  // Try JSON first
+  try {
+    const json = JSON.parse(trimmed);
+    if (json && typeof json === "object") {
+      const name = json.name || json.tool || json.tool_name || json.function;
+      const args = json.arguments || json.args || json.parameters || json.input || {};
+      if (typeof name === "string" && name.length > 0) {
+        const parsedArgs = typeof args === "string" ? safeParseJson(args) : args;
+        return { toolName: name, toolInput: parsedArgs ?? {} };
+      }
+    }
+  } catch {}
+
+  // Try function-call style: name(arg1=val1, arg2="val2")
+  const fnMatch = trimmed.match(/^([a-zA-Z_][\w]*)\s*\(([\s\S]*)\)\s*$/);
+  if (fnMatch) {
+    const toolName = fnMatch[1];
+    const argsStr = fnMatch[2];
+    // Try JSON-shaped arg first: write({"path": "x"})
+    const innerJson = safeParseJson(argsStr);
+    if (innerJson && typeof innerJson === "object" && !Array.isArray(innerJson)) {
+      return { toolName, toolInput: innerJson };
+    }
+    const toolInput = parseKwargs(argsStr);
+    if (toolInput) return { toolName, toolInput };
+  }
+
+  // Try pseudo-syntax: call:name{key:"val", ...} or name:foo{...}
+  const callMatch = trimmed.match(/(?:call:|name:|tool:|function:)([a-zA-Z_][\w]*)\s*\{([\s\S]*)\}\s*/i);
+  if (callMatch) {
+    const toolName = callMatch[1];
+    const innerJson = "{" + callMatch[2] + "}";
+    const toolInput = safeParseJson(innerJson) || parseLooseObject(callMatch[2]);
+    if (toolInput) return { toolName, toolInput };
+  }
+
+  return null;
+}
+
+export function safeParseJson(s: string): any | null {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse Python-style kwargs from a function-call body:
+ *   path="x", content="y", count=42
+ * Strips `<|"|>` style escape markers some templates inject.
+ */
+export function parseKwargs(s: string): Record<string, any> | null {
+  if (!s.trim()) return {};
+  const cleaned = s.replace(/<\|"\|>/g, '"').replace(/<\|'\|>/g, "'");
+  const result: Record<string, any> = {};
+  const re = /([a-zA-Z_][\w]*)\s*=\s*("([^"\\]|\\.)*"|'([^'\\]|\\.)*'|-?\d+(?:\.\d+)?|true|false|null)/g;
+  let m: RegExpExecArray | null;
+  let matched = false;
+  while ((m = re.exec(cleaned)) !== null) {
+    matched = true;
+    const key = m[1];
+    const raw = m[2];
+    let value: any = raw;
+    if (raw === "true") value = true;
+    else if (raw === "false") value = false;
+    else if (raw === "null") value = null;
+    else if (/^-?\d/.test(raw)) value = parseFloat(raw);
+    else value = raw.slice(1, -1).replace(/\\(.)/g, "$1");
+    result[key] = value;
+  }
+  return matched ? result : null;
+}
+
+/**
+ * Parse a loose key:value object body (no surrounding braces, no enforced
+ * JSON quoting). Used for pseudo-syntax fallbacks like:
+ *   file_path:<|"|>medieval_market.bone<|"|>
+ */
+export function parseLooseObject(s: string): Record<string, any> | null {
+  const cleaned = s.replace(/<\|"\|>/g, '"').replace(/<\|'\|>/g, "'");
+  const result: Record<string, any> = {};
+  const re = /([a-zA-Z_][\w]*)\s*[:=]\s*("([^"\\]|\\.)*"|'([^'\\]|\\.)*'|-?\d+(?:\.\d+)?|true|false|null|[^\s,}]+)/g;
+  let m: RegExpExecArray | null;
+  let matched = false;
+  while ((m = re.exec(cleaned)) !== null) {
+    matched = true;
+    const key = m[1];
+    const raw = m[2];
+    let value: any = raw;
+    if (raw === "true") value = true;
+    else if (raw === "false") value = false;
+    else if (raw === "null") value = null;
+    else if (/^-?\d/.test(raw)) value = parseFloat(raw);
+    else if (raw.startsWith('"') || raw.startsWith("'")) value = raw.slice(1, -1).replace(/\\(.)/g, "$1");
+    result[key] = value;
+  }
+  return matched ? result : null;
+}

package/src/engine/session/prompt/bonescript.txt

@@ -31,6 +31,17 @@ Use plain Python/TypeScript/etc. only for:
 
 If the request is ambiguous (e.g. "a 2D market simulation"), ask the user: "Is this a self-contained simulation script (plain code) or a backend service with persistence (BoneScript)?"
 
+## Build mode
+
+When the user starts a session with a project-scoped prompt ("build me X", "create a full Y"), BoneCode runs you in **build mode**. Build mode is a state machine: clarify → plan → execute → verify → done. You will receive structured prompts at each stage. Specifically:
+
+- **Clarify stage**: you'll be asked to either propose a design document (JSON) or ask 1-3 questions. Be concrete. Don't ramble.
+- **Plan stage**: you'll be asked for a JSON todo list. Each todo must be a single concrete file action.
+- **Execute stage**: you'll receive one todo at a time. **YOU MUST CALL TOOLS** — `write`, `edit`, `bash`. Prose-only responses are detected and rejected. The system will inject a reminder if you describe edits without calling tools.
+- **Verify stage**: for each requirement, you'll be asked yes/no whether it's satisfied. Be honest. If a requirement is not yet met, say so — the orchestrator will create fix-up tasks.
+
+The user can resume a build session at any time. Build state is persisted.
+
 ## BoneScript syntax — authoritative reference
 
 ### `system` block

package/src/engine/session/prompt.ts

@@ -42,6 +42,7 @@ import { buildCompactionSummary } from "./compaction_logic";
 import { getSystemPrompt } from "./system_prompt";
 import { loadInstructionFiles } from "./instruction_loader";
 import { buildToolRegistry } from "./tool_registry";
+import { extractLeakedToolCall } from "./leaked_tool_call";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -96,6 +97,7 @@ export async function runAgentLoop(input: PromptInput): Promise<LoopResult> {
 
   const stats = { tokens_in: 0, tokens_out: 0, cost: 0, compacted: false };
   let turn = 0;
+  let lazyReminderSent = false;
   let lastFinishReason = "unknown";
 
   try {
@@ -174,6 +176,39 @@ export async function runAgentLoop(input: PromptInput): Promise<LoopResult> {
       // 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"]);
+
+      // Detect "lazy assistant" — the model claims it's editing/creating files
+      // in prose but never actually called a tool. Common with non-tool-tuned
+      // local models. Once per session, push a synthetic reminder and re-run.
+      const lazyAssistant = !result.has_tool_calls &&
+        Object.keys(tools).length > 0 &&
+        !lazyReminderSent &&
+        await wasLazyResponse(session_id, assistantMsgId);
+
+      if (lazyAssistant) {
+        lazyReminderSent = true;
+        broadcastToChannel("session_events", {
+          type: "session.warning",
+          session_id,
+          message: "Model claimed it would edit files but didn't call any tools. Reminding it to actually use the tools.",
+        });
+        // Insert a synthetic user reminder so the next turn sees it
+        const reminderMsgId = uuid();
+        await pool.query(
+          `INSERT INTO messages (id, session_id, role) VALUES ($1, $2, 'user')`,
+          [reminderMsgId, session_id]
+        );
+        const reminderPartId = uuid();
+        await pool.query(
+          `INSERT INTO parts (id, message_id, session_id, part_type, data, order_index) VALUES ($1, $2, $3, 'text', $4, 0)`,
+          [reminderPartId, reminderMsgId, session_id, JSON.stringify({
+            text: "<system-reminder>You described file changes but did not actually invoke any tools. The user cannot see prose descriptions of edits — only real tool calls produce file changes. Call the `write` or `edit` tool now to perform the actions you described. Do not respond with prose; emit a tool call.</system-reminder>",
+            synthetic: true,
+          })]
+        );
+        continue; // re-run the loop with the reminder appended
+      }
+
       if (terminalReasons.has(result.finish_reason) && !result.has_tool_calls) {
         break;
       }
@@ -222,9 +257,19 @@ async function streamWithRetry(ctx: {
     try {
       return await streamOnce(currentCtx);
     } catch (e: any) {
-      // On Bad Request with tools, retry without tools
+      // On Bad Request with tools, retry without tools BUT log it visibly so
+      // the user knows their model can't do tool calls — otherwise they get
+      // pure-prose responses with no real edits.
       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
+        logger.error("model_tools_unsupported", {
+          event: "tools_stripped",
+          metadata: { model: ctx.model_id, provider: ctx.provider_id, error: e.message },
+        });
+        broadcastToChannel("session_events", {
+          type: "session.warning",
+          session_id: ctx.session_id,
+          message: `Model ${ctx.model_id} rejected tool definitions — running without tools (no file edits possible). Set MODEL_SUPPORTS_TOOLS=false to suppress this warning, or use a tool-capable model.`,
+        });
         currentCtx = { ...currentCtx, tools: {} };
         attempt++;
         continue;
@@ -305,6 +350,36 @@ async function streamOnce(ctx: {
         }
 
         currentTextContent += text;
+
+        // Detect models leaking their internal tool-call markers as raw text
+        // (gemma, qwen, llama variants do this when the tokenizer template
+        // doesn't match the AI SDK's expected format). When we find a complete
+        // leaked call, synthesize a real tool execution.
+        const leak = extractLeakedToolCall(currentTextContent);
+        if (leak) {
+          // Strip the leaked markers from the displayed text part
+          currentTextContent = currentTextContent.slice(0, leak.startIndex) +
+            currentTextContent.slice(leak.endIndex);
+          await pool.query(
+            `UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`,
+            [currentTextPartId, JSON.stringify({ text: currentTextContent })]
+          );
+
+          // Execute the synthesized tool call directly via the registry
+          await executeSynthesizedToolCall({
+            session_id,
+            agentId: ctx.agentId,
+            assistantMsgId,
+            toolName: leak.toolName,
+            toolInput: leak.toolInput,
+            tools,
+          });
+
+          // Mark the turn as having tool calls so the loop continues
+          hasToolCalls = true;
+          break;
+        }
+
         // Broadcast delta to WebSocket part_stream for live streaming
         broadcastToChannel("part_stream", {
           type: "part.delta",
@@ -519,6 +594,29 @@ async function runCompaction(
 
 // ─── Message History Builder ──────────────────────────────────────────────────
 
+// Detect a "lazy" response — assistant text says it will edit/create files
+// but no tool was actually invoked. Common with non-tool-tuned local models.
+async function wasLazyResponse(session_id: string, messageId: string): Promise<boolean> {
+  const r = await pool.query(
+    `SELECT data FROM parts WHERE message_id = $1 AND part_type = 'text' ORDER BY order_index ASC`,
+    [messageId]
+  );
+  const text = r.rows.map((row: any) => row.data?.text || "").join(" ").toLowerCase();
+  if (!text || text.length < 30) return false;
+  // Phrases that imply the model is committing to a file edit it didn't make
+  const editIntentPatterns = [
+    /\bi['']ll\s+(create|write|update|edit|modify|add|implement|generate)\b/,
+    /\bi['']m\s+(creating|writing|updating|editing|modifying|adding|implementing|generating)\b/,
+    /\b(creating|writing|updating|editing|generating)\s+(?:the\s+)?(?:file|files|spec)\b/,
+    /\bi\s+(?:will|am\s+going\s+to)\s+(create|write|update|edit|implement|generate)\b/,
+    /\blet\s+me\s+(create|write|update|edit|implement)\b/,
+    /\bhere['']s\s+(?:the\s+)?(?:updated|new)\s+(?:file|version|content)\b/,
+    /\.(bone|ts|tsx|js|jsx|py|md|json|yaml|yml|sql|sh|html|css)\b.*\b(updated|created|written|modified|added)\b/,
+    /\b(updated|created|written|modified|added)\b.*\.(bone|ts|tsx|js|jsx|py|md|json|yaml|yml|sql|sh|html|css)\b/,
+  ];
+  return editIntentPatterns.some(re => re.test(text));
+}
+
 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,
@@ -770,3 +868,122 @@ function supportsTools(model_id: string): boolean {
   // Default: try with tools, fall back gracefully on error
   return true;
 }
+
+// ─── Synthesized tool-call execution ──────────────────────────────────────────
+
+/**
+ * Execute a synthesized tool call when we detect a leak. Mirrors the work the
+ * AI SDK would normally do: insert a tool_invocation part, broadcast events,
+ * run the registered tool's execute() function.
+ */
+async function executeSynthesizedToolCall(input: {
+  session_id: string;
+  agentId: string;
+  assistantMsgId: string;
+  toolName: string;
+  toolInput: Record<string, any>;
+  tools: Record<string, any>;
+}): Promise<void> {
+  const { session_id, agentId, assistantMsgId, toolName, toolInput, tools } = input;
+
+  // Map common aliases (write_file → write, edit_file → edit, etc.)
+  const aliases: Record<string, string> = {
+    write_file: "write",
+    edit_file: "edit",
+    read_file: "read",
+    run_command: "bash",
+    shell: "bash",
+    search_files: "grep",
+  };
+  const resolvedName = aliases[toolName] || toolName;
+  const tool = tools[resolvedName];
+  if (!tool || !tool.execute) {
+    logger.warn("synthesized_tool_unknown", { event: "leak", metadata: { toolName, resolvedName } });
+    return;
+  }
+
+  const callId = uuid();
+  // Persist the tool call record
+  try {
+    await pool.query(
+      `INSERT INTO tool_calls (id, session_id, agent_id, tool_name, tool_input, state) VALUES ($1, $2, $3, $4, $5, 'running')`,
+      [callId, session_id, agentId, resolvedName, JSON.stringify(toolInput)]
+    );
+  } catch {}
+
+  // Broadcast tool.requested so the TUI shows "← Edit foo.bone"
+  broadcastToChannel("part_stream", {
+    type: "tool.requested",
+    session_id,
+    tool_call_id: callId,
+    tool_name: resolvedName,
+    tool_input: toolInput,
+  });
+
+  // Persist as a tool_invocation part on the assistant message
+  const partId = 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)`,
+    [partId, assistantMsgId, session_id, JSON.stringify({ tool_call_id: callId, tool_name: resolvedName, args: toolInput, state: "running" })]
+  );
+
+  // Run the actual tool — emit ToolCallRequested so the same machinery as a
+  // real tool call kicks in.
+  await eventBus.publish("ToolCallRequested", {
+    tool_call_id: callId,
+    session_id,
+    agent_id: agentId,
+    tool_name: resolvedName,
+    tool_input: toolInput,
+    requested_at: new Date().toISOString(),
+  }, "AgentLoop").catch(() => {});
+
+  const startMs = Date.now();
+  let success = true;
+  let output = "";
+  try {
+    const result = await tool.execute(toolInput, { toolCallId: callId });
+    output = typeof result === "string" ? result : (result?.output || "");
+  } catch (e: any) {
+    success = false;
+    output = e?.message || "tool execution failed";
+  }
+
+  // Update the part with the result
+  const durationMs = Date.now() - startMs;
+  try {
+    await pool.query(
+      `UPDATE parts SET data = $2, updated_at = NOW() WHERE id = $1`,
+      [partId, JSON.stringify({
+        tool_call_id: callId,
+        tool_name: resolvedName,
+        args: toolInput,
+        state: success ? "done" : "failed",
+        output,
+      })]
+    );
+    await pool.query(
+      `UPDATE tool_calls SET state = $2, tool_output = $3, duration_ms = $4, updated_at = NOW() WHERE id = $1`,
+      [callId, success ? "done" : "failed", JSON.stringify({ output }), durationMs]
+    );
+  } catch {}
+
+  // Broadcast completion
+  broadcastToChannel("part_stream", {
+    type: success ? "tool.completed" : "tool.failed",
+    session_id,
+    tool_call_id: callId,
+    tool_name: resolvedName,
+    tool_input: toolInput,
+    duration_ms: durationMs,
+    ...(success ? {} : { error: output }),
+  });
+
+  await eventBus.publish("ToolCallCompleted", {
+    tool_call_id: callId,
+    session_id,
+    tool_name: resolvedName,
+    duration_ms: durationMs,
+    completed_at: new Date().toISOString(),
+  }, "AgentLoop").catch(() => {});
+}