tarsk 0.4.13 → 0.4.14

package/dist/index.js

@@ -663,7 +663,7 @@ function isValidPackageManager(value) {
 
 // src/server.ts
 import fs3 from "fs";
-import { Hono as Hono20 } from "hono";
+import { Hono as Hono21 } from "hono";
 import { cors } from "hono/cors";
 import open3 from "open";
 import path5 from "path";
@@ -671,6 +671,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/agent/agent.executor.ts
 import { Agent as Agent2 } from "@mariozechner/pi-agent-core";
+import { streamSimple } from "@mariozechner/pi-ai";
 import { resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
 
 // src/tools/bash.ts
@@ -3285,6 +3286,8 @@ async function createMCPTools(projectPath) {
 
 // src/tools/generate-image.ts
 import { Type as Type13 } from "@sinclair/typebox";
+import { mkdir as fsMkdir2, writeFile as fsWriteFile3 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 
 // src/features/models/models-catalog.ts
 init_database();
@@ -3610,6 +3613,29 @@ async function generateWithOpenRouter(apiKey, model, prompt, options = {}) {
   };
 }
 
+// src/features/image/image-search.client.ts
+var IMAGE_SEARCH_API = "https://api.webnative.dev/images";
+async function searchImage(query, size, signal) {
+  const url = new URL(IMAGE_SEARCH_API);
+  url.searchParams.set("query", query);
+  if (size) {
+    url.searchParams.set("size", size);
+  }
+  const response = await fetch(url.toString(), { signal });
+  if (!response.ok) {
+    throw new Error(`Image search failed (${response.status}): ${await response.text()}`);
+  }
+  const contentType = response.headers.get("content-type") ?? "image/jpeg";
+  const buffer = await response.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  const imageData = btoa(binary);
+  return { imageData, contentType };
+}
+
 // src/tools/generate-image.ts
 var generateImageSchema = Type13.Object({
   prompt: Type13.String({ description: "Text description of the image to generate" }),
@@ -3617,16 +3643,19 @@ var generateImageSchema = Type13.Object({
     Type13.String({
       description: "Image model name or ID to use (e.g. 'dall-e-3', 'gpt-image-1', 'google/gemini-2.5-flash-image'). If omitted the first enabled image model is used."
     })
-  )
+  ),
+  save_to_file: Type13.String({
+    description: "File path (relative to the project root) to save the generated image to, e.g. 'assets/logo.png' or 'docs/diagram.png'. The file and any parent directories will be created automatically. The image is also returned as data so it can be displayed."
+  })
 });
 function createGenerateImageTool(options) {
-  const { metadataManager } = options;
+  const { metadataManager, cwd } = options;
   return {
     name: "generate_image",
     label: "generate_image",
-    description: "Generate an image from a text prompt. Returns a URL or base64 data for the generated image. Use this when the user asks you to create, draw, design, or generate an image.",
+    description: "Generate an image from a text prompt. Returns a URL or base64 data for the generated image. Use this when the user asks you to create, draw, design, or generate an image. Use the save_to_file parameter to save the image directly to a file in the project (e.g. 'assets/hero.png').",
     parameters: generateImageSchema,
-    execute: async (_toolCallId, { prompt, model: requestedModel }, signal) => {
+    execute: async (_toolCallId, { prompt, model: requestedModel, save_to_file }, signal) => {
       return withAbortSignal(signal, async (isAborted) => {
         const modelManager = new ModelManager(metadataManager);
         const enabledByProvider = await modelManager.getAllEnabledImageModels();
@@ -3639,14 +3668,59 @@ function createGenerateImageTool(options) {
           }
         }
         if (imageModels.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "No image models are enabled. Please enable an image model in settings before generating images."
+          console.log(
+            `[generate_image] No image models enabled \u2014 falling back to image search for: "${prompt.substring(0, 100)}"`
+          );
+          let imageData2;
+          let contentType;
+          try {
+            const result = await searchImage(prompt, void 0, signal);
+            imageData2 = result.imageData;
+            contentType = result.contentType;
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No image models are enabled and the image search fallback also failed: ${message}`
+                }
+              ],
+              details: void 0
+            };
+          }
+          if (isAborted()) return { content: [], details: void 0 };
+          let savedPath2;
+          if (cwd) {
+            try {
+              const absolutePath = resolveToCwd(save_to_file, cwd);
+              validatePathWithinCwd(absolutePath, cwd);
+              const binary = atob(imageData2);
+              const bytes = new Uint8Array(binary.length);
+              for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
               }
-            ],
-            details: void 0
+              await fsMkdir2(dirname2(absolutePath), { recursive: true });
+              await fsWriteFile3(absolutePath, bytes);
+              savedPath2 = save_to_file;
+            } catch (saveError) {
+              const errMsg = saveError instanceof Error ? saveError.message : String(saveError);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Stock image found but failed to save to "${save_to_file}": ${errMsg}`
+                  }
+                ],
+                details: { imageData: imageData2, contentType }
+              };
+            }
+          }
+          const fallbackPayload = { imageData: imageData2, contentType };
+          if (savedPath2) fallbackPayload.savedPath = savedPath2;
+          return {
+            content: [{ type: "text", text: JSON.stringify(fallbackPayload) }],
+            details: { imageData: imageData2, contentType }
           };
         }
         let selectedModel = imageModels[0];
@@ -3766,12 +3840,52 @@ function createGenerateImageTool(options) {
           imageData = imageResult.b64_json;
         }
         if (isAborted()) return { content: [], details: void 0 };
+        let savedPath;
+        if (cwd) {
+          try {
+            const absolutePath = resolveToCwd(save_to_file, cwd);
+            validatePathWithinCwd(absolutePath, cwd);
+            let imageBytes;
+            if (imageData) {
+              const binary = atob(imageData);
+              imageBytes = new Uint8Array(binary.length);
+              for (let i = 0; i < binary.length; i++) {
+                imageBytes[i] = binary.charCodeAt(i);
+              }
+            } else if (imageUrl) {
+              const res = await fetch(imageUrl);
+              if (!res.ok) {
+                throw new Error(`Failed to fetch image from URL: ${res.status}`);
+              }
+              imageBytes = new Uint8Array(await res.arrayBuffer());
+            } else {
+              throw new Error("No image data or URL available to save");
+            }
+            await fsMkdir2(dirname2(absolutePath), { recursive: true });
+            await fsWriteFile3(absolutePath, imageBytes);
+            savedPath = save_to_file;
+            console.log(`[generate_image] Saved image to ${absolutePath}`);
+          } catch (saveError) {
+            console.error("[generate_image] Failed to save image to file:", saveError);
+            const errMsg = saveError instanceof Error ? saveError.message : String(saveError);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Image was generated but failed to save to "${save_to_file}": ${errMsg}`
+                }
+              ],
+              details: { imageUrl, imageData, model: selectedModel.id }
+            };
+          }
+        }
         const resultPayload = {
           model: `${selectedModel.provider}/${selectedModel.id}`,
           imageUrl,
           imageData
         };
         if (text) resultPayload.text = text;
+        if (savedPath) resultPayload.savedPath = savedPath;
         return {
           content: [
             {
@@ -3786,9 +3900,288 @@ function createGenerateImageTool(options) {
   };
 }
 
+// src/tools/find-images.ts
+import { Type as Type14 } from "@sinclair/typebox";
+import { mkdir as fsMkdir3, writeFile as fsWriteFile4 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+var findImagesSchema = Type14.Object({
+  query: Type14.String({ description: "Search term for the image (e.g. 'sunset over mountains')" }),
+  size: Type14.Optional(
+    Type14.Union(
+      [
+        Type14.Literal("original"),
+        Type14.Literal("large2x"),
+        Type14.Literal("large"),
+        Type14.Literal("medium"),
+        Type14.Literal("small"),
+        Type14.Literal("portrait"),
+        Type14.Literal("landscape"),
+        Type14.Literal("tiny")
+      ],
+      {
+        description: "Image size variant: original, large2x, large, medium (default), small, portrait, landscape, tiny"
+      }
+    )
+  ),
+  save_to_file: Type14.Optional(
+    Type14.String({
+      description: "File path relative to the project root to save the image to (e.g. 'assets/hero.jpg'). Parent directories are created automatically. If omitted the image is returned as base64 data only."
+    })
+  )
+});
+function createFindImagesTool(cwd) {
+  return {
+    name: "find_images",
+    label: "find_images",
+    description: "Find a stock image matching a search query. Returns the image as base64 data and optionally saves it to a file. Use this when the user needs an image and the user has not requested it be generated.",
+    parameters: findImagesSchema,
+    execute: async (_toolCallId, { query, size, save_to_file }, signal) => {
+      return withAbortSignal(signal, async (isAborted) => {
+        console.log(
+          `[find_images] Searching for image \u2014 query: "${query}"${size ? `, size: ${size}` : ""}`
+        );
+        let imageData;
+        let contentType;
+        try {
+          const result = await searchImage(query, size, signal);
+          imageData = result.imageData;
+          contentType = result.contentType;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `Image search failed: ${message}` }],
+            details: void 0
+          };
+        }
+        if (isAborted()) return { content: [], details: void 0 };
+        let savedPath;
+        if (cwd && save_to_file) {
+          try {
+            const absolutePath = resolveToCwd(save_to_file, cwd);
+            validatePathWithinCwd(absolutePath, cwd);
+            const binary = atob(imageData);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+              bytes[i] = binary.charCodeAt(i);
+            }
+            await fsMkdir3(dirname3(absolutePath), { recursive: true });
+            await fsWriteFile4(absolutePath, bytes);
+            savedPath = save_to_file;
+            console.log(`[find_images] Saved image to ${absolutePath}`);
+          } catch (saveError) {
+            const errMsg = saveError instanceof Error ? saveError.message : String(saveError);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Image was found but failed to save to "${save_to_file}": ${errMsg}`
+                }
+              ],
+              details: { imageData, contentType }
+            };
+          }
+        }
+        const resultPayload = { imageData, contentType };
+        if (savedPath) resultPayload.savedPath = savedPath;
+        return {
+          content: [{ type: "text", text: JSON.stringify(resultPayload) }],
+          details: { imageData, contentType }
+        };
+      });
+    }
+  };
+}
+
+// src/tools/execute-browser-js.ts
+import { Type as Type15 } from "@sinclair/typebox";
+var runWebWorkerSchema = Type15.Object({
+  intention: Type15.String({
+    description: "A short description of what this code execution is trying to accomplish."
+  }),
+  code: Type15.String({
+    description: "The javascript code to execute in browser context(not nodejs). The environment provides an async function `callTool(toolName, params)` which allows calling any of the other available tools by name. callTool always returns `{ text: string | null, error: string | null }`. On success `text` contains the result and `error` is null. On failure `error` contains the error message and `text` is null. Example: `const r = await callTool('read', { path: 'foo.ts' }); if (r.error) return r.error; return r.text;`."
+  })
+});
+var pendingTasks = /* @__PURE__ */ new Map();
+function submitWebWorkerResult(toolCallId, result) {
+  const pending = pendingTasks.get(toolCallId);
+  if (!pending) return false;
+  pending.resolve(result);
+  pendingTasks.delete(toolCallId);
+  return true;
+}
+function cancelPendingWebWorker(toolCallId) {
+  const pending = pendingTasks.get(toolCallId);
+  if (!pending) return false;
+  pending.reject(new Error("Web worker execution cancelled"));
+  pendingTasks.delete(toolCallId);
+  return true;
+}
+function buildDescription(tools) {
+  let desc = "Execute javascript code in a web worker (not nodejs). Use this when running JS code is the easiest way to accomplish the goal, such as data transformations, calculations, or orchestrating multiple tool calls programmatically. Returns the result of the execution. You can call other tools by using `await callTool('toolName', { arg: 'value' })`. callTool always returns `{ text: string | null, error: string | null }`. On success `text` contains the result and `error` is null. On failure `error` contains the error message and `text` is null. Example: `const r = await callTool('read', { path: 'foo.ts' }); if (r.error) return r.error; return r.text;`. Write the most compact code possible: no comments, short variable names, minimal whitespace.";
+  if (tools && tools.length > 0) {
+    const signatures = tools.map((t) => `${t.name}: ${JSON.stringify(t.parameters?.properties ?? {})}`).join("\n");
+    desc += `
+
+Available tools:
+${signatures}`;
+  }
+  return desc;
+}
+function createRunWebWorkerTool(options) {
+  return {
+    name: "run_js",
+    label: "run_js",
+    description: buildDescription(options?.tools),
+    parameters: runWebWorkerSchema,
+    execute: async (toolCallId, { intention: _intention, code }, signal) => {
+      console.log(`[ai] run_js: executing script of length ${code.length}`);
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const result = await new Promise((resolve6, reject) => {
+        pendingTasks.set(toolCallId, {
+          resolve: resolve6,
+          reject,
+          code
+        });
+        const onAbort = () => {
+          cancelPendingWebWorker(toolCallId);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2) || "undefined"
+          }
+        ],
+        details: void 0
+      };
+    }
+  };
+}
+var runWebWorkerTool = createRunWebWorkerTool();
+
+// src/tools/tool-search.ts
+import { Type as Type16 } from "@sinclair/typebox";
+var toolSearchSchema = Type16.Object({
+  query: Type16.String({
+    description: 'Search query to find tools. Use "select:name1,name2" to fetch exact tools by name, or keywords to search by description.'
+  }),
+  max_results: Type16.Optional(
+    Type16.Number({
+      description: "Maximum number of results to return (default: 5)"
+    })
+  )
+});
+function formatToolSchema(tool) {
+  const schema = JSON.stringify(tool.parameters, null, 2);
+  return `<function>{"name": "${tool.name}", "description": ${JSON.stringify(tool.description)}, "parameters": ${schema}}</function>`;
+}
+function parseQuery(query) {
+  const trimmed = query.trim();
+  if (trimmed.startsWith("select:")) {
+    const names = trimmed.slice(7).split(",").map((n) => n.trim().toLowerCase()).filter(Boolean);
+    return { mode: "select", names };
+  }
+  if (trimmed.startsWith("+")) {
+    const parts = trimmed.slice(1).trim().split(/\s+/);
+    const requiredName = parts[0]?.toLowerCase();
+    const terms2 = parts.slice(1).map((t) => t.toLowerCase());
+    return { mode: "search", terms: terms2, requiredName };
+  }
+  const terms = trimmed.toLowerCase().split(/\s+/).filter(Boolean);
+  return { mode: "search", terms };
+}
+function scoreTool(tool, terms) {
+  if (terms.length === 0) return 1;
+  const name = tool.name.toLowerCase();
+  const label = ("label" in tool ? tool.label : "").toLowerCase();
+  const desc = tool.description.toLowerCase();
+  let score = 0;
+  for (const term of terms) {
+    if (name === term) score += 10;
+    else if (name.includes(term)) score += 5;
+    if (label.includes(term)) score += 3;
+    if (desc.includes(term)) score += 1;
+  }
+  return score;
+}
+function createToolSearchTool(options) {
+  const { liveTools, deferredTools } = options;
+  const activated = /* @__PURE__ */ new Set();
+  return {
+    name: "tool_search",
+    label: "tool_search",
+    description: 'Search for and activate deferred tools. Returns full schema definitions so you can call them. Use "select:name1,name2" to fetch exact tools, or keywords to search by description.',
+    parameters: toolSearchSchema,
+    execute: async (_toolCallId, input) => {
+      const maxResults = input.max_results ?? 5;
+      const parsed = parseQuery(input.query);
+      let matched = [];
+      if (parsed.mode === "select") {
+        for (const name of parsed.names) {
+          const tool = deferredTools.get(name);
+          if (tool) matched.push(tool);
+        }
+      } else {
+        const candidates = [];
+        for (const tool of deferredTools.values()) {
+          if (parsed.requiredName) {
+            const name = tool.name.toLowerCase();
+            if (!name.includes(parsed.requiredName)) continue;
+          }
+          const score = scoreTool(tool, parsed.terms);
+          if (score > 0) {
+            candidates.push({ tool, score });
+          }
+        }
+        candidates.sort((a, b) => b.score - a.score);
+        matched = candidates.slice(0, maxResults).map((c) => c.tool);
+      }
+      if (matched.length === 0) {
+        const available = Array.from(deferredTools.keys()).join(", ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No tools matched query "${input.query}". Available deferred tools: ${available || "none"}`
+            }
+          ],
+          details: void 0
+        };
+      }
+      for (const tool of matched) {
+        if (!activated.has(tool.name)) {
+          activated.add(tool.name);
+          liveTools.push(tool);
+        }
+      }
+      const schemaBlocks = matched.map(formatToolSchema).join("\n");
+      const text = `Found ${matched.length} tool(s). They are now available for use.
+
+<functions>
+${schemaBlocks}
+</functions>`;
+      return {
+        content: [{ type: "text", text }],
+        details: void 0
+      };
+    }
+  };
+}
+function formatDeferredToolsList(deferredTools) {
+  if (deferredTools.size === 0) return "";
+  const names = Array.from(deferredTools.keys()).join(", ");
+  return "\n\n# Deferred Tools\n\nThe following tools are available but deferred. Use the `tool_search` tool to fetch their full definitions before calling them:\n" + names;
+}
+
 // src/tools/index.ts
 async function createCodingTools(cwd, options) {
-  const baseTools = [
+  const deferOption = options?.deferTools ?? true;
+  const coreTools = [
     createReadTool(cwd, options?.read),
     createBashTool(cwd, options?.bash),
     createEditTool(cwd),
@@ -3796,30 +4189,81 @@ async function createCodingTools(cwd, options) {
     createAskUserTool(),
     createTodoTool(options?.threadId ?? ""),
     createFindTool(cwd),
-    createAstGrepTool(cwd)
+    createAstGrepTool(cwd),
+    createRunWebWorkerTool()
   ];
+  const optionalTools = [];
   if (options?.metadataManager) {
-    baseTools.push(createGenerateImageTool({ metadataManager: options.metadataManager }));
+    optionalTools.push(createGenerateImageTool({ metadataManager: options.metadataManager, cwd }));
   }
-  const toolsWithSkills = [...baseTools];
+  optionalTools.push(createFindImagesTool(cwd));
   if (options?.skills && options.skills.length > 0) {
-    const skillTools = [
+    optionalTools.push(
       createSkillScriptTool(options.skills, cwd),
       createSkillReferenceTool(options.skills)
-    ];
-    toolsWithSkills.push(...skillTools);
+    );
   }
+  let mcpTools = [];
   try {
-    const mcpTools = await createMCPTools(cwd);
-    toolsWithSkills.push(...mcpTools);
+    mcpTools = await createMCPTools(cwd);
   } catch (error) {
     console.warn(`[Tools] Failed to load MCP tools for ${cwd}:`, error);
   }
-  return toolsWithSkills;
+  const deferredTools = /* @__PURE__ */ new Map();
+  if (deferOption === false) {
+    coreTools.push(...optionalTools, ...mcpTools);
+  } else if (deferOption === true) {
+    for (const tool of [...mcpTools, ...optionalTools]) {
+      deferredTools.set(tool.name, tool);
+    }
+  } else {
+    const deferSet = new Set(deferOption.map((n) => n.toLowerCase()));
+    for (const tool of [...optionalTools, ...mcpTools]) {
+      if (deferSet.has(tool.name.toLowerCase())) {
+        deferredTools.set(tool.name, tool);
+      } else {
+        coreTools.push(tool);
+      }
+    }
+  }
+  const tools = [...coreTools];
+  if (deferredTools.size > 0) {
+    const toolSearch = createToolSearchTool({
+      liveTools: tools,
+      deferredTools
+    });
+    tools.push(toolSearch);
+    console.log(
+      `[Tools] ${deferredTools.size} tool(s) deferred behind tool_search: ${Array.from(deferredTools.keys()).join(", ")}`
+    );
+  }
+  return { tools, deferredToolNames: deferredTools };
+}
+function createAllTools(cwd, options) {
+  const tools = {
+    read: createReadTool(cwd, options?.read),
+    bash: createBashTool(cwd, options?.bash),
+    edit: createEditTool(cwd),
+    write: createWriteTool(cwd),
+    grep: createGrepTool(cwd),
+    ast_grep: createAstGrepTool(cwd),
+    find: createFindTool(cwd),
+    ask_user: createAskUserTool(),
+    ls: createLsTool(cwd),
+    run_js: createRunWebWorkerTool()
+  };
+  if (options?.metadataManager) {
+    tools.generate_image = createGenerateImageTool({
+      metadataManager: options.metadataManager,
+      cwd
+    });
+  }
+  tools.find_images = createFindImagesTool(cwd);
+  return tools;
 }
 
 // src/tools/agent-tool.ts
-import { Type as Type14 } from "@sinclair/typebox";
+import { Type as Type17 } from "@sinclair/typebox";
 
 // src/agent/agent.subagent-executor.ts
 import { Agent } from "@mariozechner/pi-agent-core";
@@ -4090,6 +4534,7 @@ async function executeSubagent(options) {
       model: resolvedModel,
       tools
     },
+    streamFn: cachedStreamFn,
     getApiKey: async () => apiKey
   });
   const eventQueue = new EventQueue();
@@ -4166,15 +4611,15 @@ async function executeSubagent(options) {
 }
 
 // src/tools/agent-tool.ts
-var agentToolSchema = Type14.Object({
-  prompt: Type14.String({ description: "The task or question for the subagent to work on" }),
-  agentName: Type14.Optional(
-    Type14.String({
+var agentToolSchema = Type17.Object({
+  prompt: Type17.String({ description: "The task or question for the subagent to work on" }),
+  agentName: Type17.Optional(
+    Type17.String({
       description: "Name of a defined agent (from AGENT.md) to use. If omitted, a general-purpose subagent is created."
     })
   ),
-  description: Type14.Optional(
-    Type14.String({
+  description: Type17.Optional(
+    Type17.String({
       description: "A short (3-5 word) label describing what the subagent will do"
     })
   )
@@ -4880,7 +5325,7 @@ function formatAgentsSection(agents) {
   );
   return section;
 }
-async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents) {
+async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents, deferredTools) {
   let prompt = buildDefaultPrompt(tools);
   const agentsContent = loadDeveloperContext(threadPath);
   if (agentsContent) {
@@ -4909,15 +5354,50 @@ async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents
   if (agentsSection) {
     prompt += agentsSection;
   }
+  if (deferredTools && deferredTools.size > 0) {
+    prompt += formatDeferredToolsList(deferredTools);
+  }
   return prompt;
 }
 
 // src/agent/agent.executor.ts
+var cachedStreamFn = (model, context, options) => {
+  return streamSimple(model, context, { ...options, cacheRetention: "long" });
+};
+function buildHistoryMessages(history) {
+  const messages = [];
+  const now = Date.now();
+  for (const exchange of history) {
+    messages.push({
+      role: "user",
+      content: exchange.userMessage,
+      timestamp: now
+    });
+    messages.push({
+      role: "assistant",
+      content: [{ type: "text", text: exchange.assistantResponse }],
+      api: "",
+      provider: "",
+      model: "",
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "stop",
+      timestamp: now
+    });
+  }
+  return messages;
+}
 var PiExecutorImpl = class {
   constructor(metadataManager) {
     this.metadataManager = metadataManager;
   }
-  async *execute(userPrompt, context, signal) {
+  async *execute(userPrompt, context, signal, conversationHistory) {
     try {
       const providerName = context.provider;
       if (!providerName) {
@@ -4970,7 +5450,7 @@ var PiExecutorImpl = class {
         api: resolvedModel.api,
         provider: resolvedModel.provider
       });
-      const tools = await createCodingTools(cwd, {
+      const { tools, deferredToolNames } = await createCodingTools(cwd, {
         skills: context.skills,
         threadId: context.threadId,
         metadataManager: this.metadataManager
@@ -4980,7 +5460,8 @@ var PiExecutorImpl = class {
         tools,
         context.skills,
         context.planMode,
-        context.agents
+        context.agents,
+        deferredToolNames
       );
       console.log(
         "[ai] System prompt loaded from thread path",
@@ -5002,12 +5483,15 @@ var PiExecutorImpl = class {
         });
         tools.push(agentToolInstance);
       }
+      const historyMessages = buildHistoryMessages(conversationHistory ?? []);
       const agent = new Agent2({
         initialState: {
           systemPrompt,
           model: resolvedModel,
-          tools
+          tools,
+          messages: historyMessages
         },
+        streamFn: cachedStreamFn,
         getApiKey: async () => apiKey
       });
       let done = false;
@@ -5894,18 +6378,6 @@ function streamAsyncGenerator(c, generator, options) {
 }
 
 // src/features/conversations/conversations.content.ts
-var DEFAULT_MAX_CONTEXT_MESSAGES = 10;
-function formatConversationContext(messages, maxMessages = DEFAULT_MAX_CONTEXT_MESSAGES) {
-  const completed = messages.filter((m) => m.response != null);
-  const recent = completed.slice(-maxMessages);
-  if (recent.length === 0) return "";
-  const lines = ["Previous conversation:"];
-  for (const m of recent) {
-    lines.push(`User: ${m.request.message}`);
-    lines.push(`Assistant: ${m.response.content}`);
-  }
-  return lines.join("\n");
-}
 var extractTextBlocksFromContent = (content) => {
   const trimmed = content.trim();
   if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) {
@@ -6505,11 +6977,10 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
     const priorMessages = (history?.messages ?? []).filter(
       (m) => m.id !== messageId && m.response != null
     );
-    const contextBlock = formatConversationContext(priorMessages);
-    const promptWithContext = contextBlock.length > 0 ? `${contextBlock}
-
-Current message:
-User: ${content}` : content;
+    const conversationHistory = priorMessages.slice(-10).map((m) => ({
+      userMessage: m.request.message,
+      assistantResponse: m.response.content
+    }));
     const abortController = new AbortController();
     const requestSignal = c.req.raw.signal;
     if (requestSignal.aborted) {
@@ -6530,9 +7001,10 @@ User: ${content}` : content;
       let fullContent = "";
       try {
         for await (const event of agentExecutor.execute(
-          promptWithContext,
+          content,
           context,
-          abortController.signal
+          abortController.signal,
+          conversationHistory
         )) {
           capturedEvents.push(event);
           if (event.type === "message" && event.content) {
@@ -14455,6 +14927,8 @@ async function handleGetThreadMessages(c, threadManager, conversationManager) {
       if (!message.response) {
         return [userMessage];
       }
+      const tokenCount = message.inputTokens || message.outputTokens ? (message.inputTokens ?? 0) + (message.outputTokens ?? 0) : void 0;
+      const processingTimeMs = message.timestamp && message.response.completedAt ? new Date(message.response.completedAt).getTime() - new Date(message.timestamp).getTime() : void 0;
       const agentMessage = {
         messageId: `agent-${message.id}`,
         sender: "agent",
@@ -14465,6 +14939,12 @@ async function handleGetThreadMessages(c, threadManager, conversationManager) {
         contentType: "markdown",
         timestamp: message.response.completedAt,
         model: message.request.model,
+        ...(tokenCount || processingTimeMs) && {
+          metadata: {
+            ...tokenCount && { tokenCount },
+            ...processingTimeMs && processingTimeMs > 0 && { processingTimeMs }
+          }
+        },
         ...message.response.imageUrl && { generatedImageUrl: message.response.imageUrl }
       };
       return [userMessage, agentMessage];
@@ -14973,7 +15453,7 @@ import { existsSync as existsSync16 } from "fs";
 
 // src/features/git/git-download-folder.ts
 import { mkdir as mkdir7, writeFile as writeFile5 } from "fs/promises";
-import { join as join24, dirname as dirname2 } from "path";
+import { join as join24, dirname as dirname4 } from "path";
 async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   const { token, ref } = options;
   const match = repoUrl.replace(/\.git$/, "").match(/github\.com\/([^/]+)\/([^/]+)/);
@@ -15010,7 +15490,7 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
     files.map(async (file) => {
       const relativePath = file.path.slice(prefix.length);
       const localPath = join24(destPath, relativePath);
-      await mkdir7(dirname2(localPath), { recursive: true });
+      await mkdir7(dirname4(localPath), { recursive: true });
       const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${refParam}/${file.path}`;
       const fileRes = await fetch(rawUrl, { headers });
       if (!fileRes.ok) {
@@ -15646,7 +16126,7 @@ function createThreadRoutes(threadManager, gitManager, conversationManager) {
 // src/features/git/git.manager.ts
 init_utils();
 import { mkdir as mkdir9 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname5 } from "path";
 var GitManagerImpl = class {
   /**
    * Regular expressions for validating different git URL formats
@@ -15716,7 +16196,7 @@ var GitManagerImpl = class {
       return;
     }
     try {
-      const parentDir = dirname3(targetPath);
+      const parentDir = dirname5(targetPath);
       await mkdir9(parentDir, { recursive: true });
       const gitProcess = spawnProcess("git", ["clone", "--progress", gitUrl, targetPath]);
       const eventQueue = [];
@@ -18511,7 +18991,7 @@ function createUpdateRoutes(updater) {
 // src/features/mcp/mcp.routes.ts
 import { Hono as Hono13 } from "hono";
 import { readFile as readFile15, writeFile as writeFile7, mkdir as mkdir10, access as access6 } from "fs/promises";
-import { join as join28, dirname as dirname4 } from "path";
+import { join as join28, dirname as dirname6 } from "path";
 
 // src/features/mcp/mcp.popular.json
 var mcp_popular_default = [
@@ -18637,7 +19117,7 @@ async function readMCPConfig(projectPath) {
 async function writeMCPConfig(projectPath, config) {
   const existing = await readMCPConfig(projectPath);
   const targetPath = existing?.filePath ?? join28(projectPath, ".agents/mcp.json");
-  await mkdir10(dirname4(targetPath), { recursive: true });
+  await mkdir10(dirname6(targetPath), { recursive: true });
   await writeFile7(targetPath, JSON.stringify(config, null, 2), "utf-8");
 }
 function createMCPRoutes() {
@@ -19025,9 +19505,35 @@ function createProjectTodosRoutes(metadataManager) {
 
 // src/features/account/account.routes.ts
 import { Hono as Hono17 } from "hono";
+
+// src/features/account/account-settings.route.ts
+init_database();
+var KEY_USE_TOOLS_THROUGH_CODE = "UseToolsThroughCode";
+async function getAccountSettings(c) {
+  const db = await getDatabase();
+  const raw = await getState(db, KEY_USE_TOOLS_THROUGH_CODE);
+  return c.json({
+    useToolsThroughCode: raw !== false
+  });
+}
+async function updateAccountSettings(c) {
+  const body = await c.req.json();
+  const db = await getDatabase();
+  if (typeof body.useToolsThroughCode === "boolean") {
+    await setState(db, KEY_USE_TOOLS_THROUGH_CODE, body.useToolsThroughCode);
+  }
+  const raw = await getState(db, KEY_USE_TOOLS_THROUGH_CODE);
+  return c.json({
+    useToolsThroughCode: raw !== false
+  });
+}
+
+// src/features/account/account.routes.ts
 function createAccountRoutes() {
   const router = new Hono17();
   router.get("/info", (c) => getAccountInfo(c));
+  router.get("/settings", (c) => getAccountSettings(c));
+  router.put("/settings", (c) => updateAccountSettings(c));
   return router;
 }
 
@@ -19311,13 +19817,89 @@ function createImageRoutes(metadataManager, conversationManager, threadManager)
   return router;
 }
 
+// src/features/browser-js/browser-js.routes.ts
+import { Hono as Hono20 } from "hono";
+function createBrowserJsRoutes(threadManager) {
+  const router = new Hono20();
+  router.post("/respond", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { toolCallId, result } = body;
+      if (!toolCallId || typeof toolCallId !== "string") {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "toolCallId is required and must be a string",
+          400
+        );
+      }
+      const resolved = submitWebWorkerResult(toolCallId, result);
+      if (!resolved) {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "No pending web worker execution found for this toolCallId",
+          404
+        );
+      }
+      return c.json({ success: true });
+    } catch (error) {
+      return errorResponse(
+        c,
+        ErrorCodes.REQUEST_PARSE_ERROR,
+        "Failed to parse request body",
+        400,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.post("/execute-tool", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { threadId, toolName, params } = body;
+      if (!threadId || typeof threadId !== "string") {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "threadId is required and must be a string",
+          400
+        );
+      }
+      if (!toolName || typeof toolName !== "string") {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "toolName is required and must be a string",
+          400
+        );
+      }
+      const thread = await threadManager.getThread(threadId);
+      if (!thread) {
+        return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, "Thread not found", 404);
+      }
+      const tools = createAllTools(thread.path);
+      const tool = tools[toolName];
+      if (!tool) {
+        return errorResponse(c, ErrorCodes.INVALID_REQUEST, `Tool ${toolName} not found`, 404);
+      }
+      const executionId = "web-worker-" + Date.now().toString() + "-" + Math.random().toString(36).substr(2, 9);
+      const result = await tool.execute(executionId, params);
+      return c.json(result);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      return errorResponse(c, ErrorCodes.REQUEST_PARSE_ERROR, detail, 500, detail);
+    }
+  });
+  return router;
+}
+
 // src/server.ts
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = path5.dirname(__filename);
 async function startTarskServer(options) {
   const { isDebug: isDebug2, publicDir: publicDirOverride } = options;
   const port = isDebug2 ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
-  const app = new Hono20();
+  const app = new Hono21();
   app.use("/*", cors());
   app.use("/*", async (c, next) => {
     if (c.req.path.startsWith("/api/")) {
@@ -19388,6 +19970,7 @@ async function startTarskServer(options) {
   app.route("/api/image", createImageRoutes(metadataManager, conversationManager, threadManager));
   app.route("/api/scaffold", createScaffoldRoutes(projectManager));
   app.route("/api/ask-user", createAskUserRoutes());
+  app.route("/api/browser-js", createBrowserJsRoutes(threadManager));
   app.route("/api/update", createUpdateRoutes(options.updater));
   createSlashCommandRoutes(app, threadManager);
   createRuleRoutes(app, projectManager);