teapot-coding-agent 0.15.2 → 0.15.4

package/dist/agent/llm.js

@@ -47,6 +47,37 @@ function client(cfg) {
  * empty text content in user/assistant messages makes many of them 400.
  * Fill blanks with a harmless placeholder before sending.
  */
+/**
+ * Providers occasionally glue MULTIPLE tool calls into one entry, or leak
+ * their internal framing into the name field (seen live: a name of
+ * `get_goal\uFFFD\uFFFDlist_dir` whose raw bytes were
+ * `get_goal</tool_call><…><tool_call><…>`). Detect the tag boundaries and
+ * split the blob back into individual calls so the round stays usable
+ * instead of failing with "unknown tool".
+ */
+function repairMangledToolName(raw) {
+    const calls = [];
+    // Form 1 — framing tags survived: <name></tool_call>[<id>…]<tool_call><name>
+    const tagRe = /([a-zA-Z_][\w.]*)<\/tool_call>|<tool_call>\s*<?([a-zA-Z_][\w.]*)?/g;
+    let m;
+    while ((m = tagRe.exec(raw))) {
+        const name = m[1] ?? m[2];
+        if (name && !calls.some((c) => c.name === name))
+            calls.push({ name, arguments: "{}" });
+    }
+    if (calls.length)
+        return calls;
+    // Form 2 — tags were already destroyed into U+FFFD replacement chars:
+    // "get_goal\uFFFD\uFFFDlist_dir" → split on the replacement runs
+    const parts = raw.split(/[\ufffd]+/).filter((p) => /^[a-zA-Z_][\w.]*$/.test(p));
+    for (const p of parts)
+        calls.push({ name: p, arguments: "{}" });
+    return calls;
+}
+/** true when a tool name can't possibly be one of ours (framing leaked in) */
+function looksMangled(name) {
+    return !name || /[\ufffd<>]/.test(name) || /<tool_call>|<\/tool/.test(name);
+}
 function sanitize(messages) {
     return messages.map((m) => {
         if ((m.role === "user" || m.role === "assistant") && !m.content) {
@@ -78,11 +109,26 @@ export async function chat(cfg, messages, tools, signal, onDelta) {
         const reasoning = typeof rm.reasoning === "string" && rm.reasoning ? rm.reasoning : undefined;
         const calls = rm.tool_calls;
         if (calls?.length) {
-            message.tool_calls = calls.map((c, i) => ({
-                id: c.id ?? `call_${i}`,
-                type: "function",
-                function: { name: c.function?.name ?? "", arguments: c.function?.arguments ?? "{}" },
-            }));
+            message.tool_calls = calls.flatMap((c, i) => {
+                const name = c.function?.name ?? "";
+                // provider glued several calls together / leaked framing into the
+                // name — split the blob back into real calls so the round survives
+                if (looksMangled(name)) {
+                    const repaired = repairMangledToolName(name);
+                    if (repaired.length)
+                        return repaired.map((r, k) => ({
+                            id: `${c.id ?? `call_${i}`}_${k}`,
+                            type: "function",
+                            function: { name: r.name, arguments: r.arguments },
+                        }));
+                    return []; // unsalvageable — drop rather than feed "unknown tool"
+                }
+                return [{
+                        id: c.id ?? `call_${i}`,
+                        type: "function",
+                        function: { name, arguments: c.function?.arguments ?? "{}" },
+                    }];
+            });
         }
         // some gateways answer 200 with finish_reason "error"; those tool calls /
         // text are often truncated garbage — discard the whole completion so the
@@ -177,11 +223,23 @@ export async function chatStream(cfg, messages, tools, signal, onDelta) {
             .sort((a, b) => a - b)
             .map((i) => calls[i]);
         if (list.length)
-            message.tool_calls = list.map((c, i) => ({
-                id: c.id || `call_${i}`,
-                type: "function",
-                function: { name: c.name, arguments: c.args || "{}" },
-            }));
+            message.tool_calls = list.flatMap((c, i) => {
+                if (looksMangled(c.name)) {
+                    const repaired = repairMangledToolName(c.name);
+                    if (repaired.length)
+                        return repaired.map((r, k) => ({
+                            id: `${c.id || `call_${i}`}_${k}`,
+                            type: "function",
+                            function: { name: r.name, arguments: r.arguments },
+                        }));
+                    return [];
+                }
+                return [{
+                        id: c.id || `call_${i}`,
+                        type: "function",
+                        function: { name: c.name, arguments: c.args || "{}" },
+                    }];
+            });
         if (!message.content && !message.tool_calls)
             throw new Error("LLM API error: empty completion");
         return { message, reasoning: reasoning || undefined, usage };

package/dist/server/api.js

@@ -45,6 +45,43 @@ async function listModels(baseUrl, apiKey) {
 import path from "node:path";
 import { bus } from "../bus.js";
 import { readEvents } from "../log/events.js";
+/** media categories the file tree can preview inline */
+const IMAGE_EXT = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico", "avif"]);
+const VIDEO_EXT = new Set(["mp4", "webm", "mov", "mkv", "avi", "m4v"]);
+const AUDIO_EXT = new Set(["mp3", "wav", "ogg", "m4a", "flac", "aac", "opus"]);
+function mediaKind(p) {
+    const ext = p.split(".").pop()?.toLowerCase() ?? "";
+    if (IMAGE_EXT.has(ext))
+        return "image";
+    if (VIDEO_EXT.has(ext))
+        return "video";
+    if (AUDIO_EXT.has(ext))
+        return "audio";
+    return null;
+}
+/** extension → MIME (used for the media preview endpoint) */
+export const MEDIA_MIME = (() => {
+    const m = {};
+    for (const e of IMAGE_EXT)
+        m[e] = `image/${e === "jpg" ? "jpeg" : e}`;
+    Object.assign(m, { svg: "image/svg+xml", ico: "image/x-icon", avif: "image/avif" });
+    for (const e of VIDEO_EXT)
+        m[e] = `video/${e === "mov" ? "quicktime" : e === "mkv" ? "x-matroska" : e}`;
+    for (const e of AUDIO_EXT)
+        m[e] = `audio/${e}`;
+    Object.assign(m, { m4a: "audio/mp4", mp3: "audio/mpeg" });
+    return m;
+})();
+/** category → generic fallback when no specific extension match exists */
+const KIND_MIME = {
+    image: "application/octet-stream",
+    video: "application/octet-stream",
+    audio: "application/octet-stream",
+};
+function mimeFor(rel, kind) {
+    const ext = rel.split(".").pop()?.toLowerCase() ?? "";
+    return MEDIA_MIME[ext] ?? KIND_MIME[kind];
+}
 export function buildApp(master) {
     const app = new Hono();
     // Optional bearer auth for LAN exposure — TEAPOT_API_TOKEN env wins, else
@@ -328,6 +365,44 @@ export function buildApp(master) {
                 path: rel,
                 truncated: buf.length > 100_000,
                 content: buf.subarray(0, 100_000).toString("utf8"),
+                media: mediaKind(rel),
+            });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
+    // raw bytes for media previews (images / video / audio) — auth-gated like
+    // every other agent route, workspace-confined, served with the right MIME
+    app.get("/api/agents/:id/raw", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const rel = c.req.query("path") ?? "";
+        if (!rel.trim())
+            return c.json({ error: "path required" }, 400);
+        let abs;
+        try {
+            abs = safeJoin(a.workspace, rel);
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+        try {
+            const buf = await fs.readFile(abs);
+            const kind = mediaKind(rel);
+            if (!kind)
+                return c.json({ error: "not a previewable media file" }, 400);
+            if (buf.length > 200 * 1024 * 1024)
+                return c.json({ error: "file too large to preview (>200MB)" }, 413);
+            // hono-native body API — a raw `new Response(...)` returned here lost
+            // its headers somewhere in the middleware chain (content-type arrived
+            // as undefined), while c.body() passes them through correctly
+            return c.body(new Uint8Array(buf), 200, {
+                "content-type": mimeFor(rel, kind),
+                // previews only; the browser shouldn't cache stale workspace files
+                "cache-control": "no-store",
+                "content-disposition": `inline; filename="${encodeURIComponent(path.basename(rel))}"`,
             });
         }
         catch (err) {
@@ -781,7 +856,8 @@ export function buildApp(master) {
         const a = master.agents.get(c.req.param("id"));
         if (!a)
             return c.json({ error: "not found" }, 404);
-        const events = await readEvents(a.log.filePath);
+        // cached like /events — this used to bypass it and re-read the whole log
+        const events = await readEventsCached(a.log.filePath);
         const branches = new Map();
         for (const e of events) {
             const b = branches.get(e.branch) ?? { branch: e.branch, events: 0 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",