@agentprojectcontext/apx 1.25.0 → 1.27.1

package/src/{daemon → core/agent}/tool-call-parser.js

@@ -56,7 +56,16 @@ function readBalancedJson(s, i) {
 // before/after.
 export function extractPseudoToolCalls(text) {
   if (!text || typeof text !== "string") return [];
-  const out = [];
+
+  // First pass: the Llama-3.3 (via Groq / OpenRouter) "dotted function"
+  // format: <function.NAME({...JSON...})</function>. The model emits this
+  // when it tries to do structured tool calling without proper SDK support.
+  // We translate each match into a regular pseudo-tool-call entry; the
+  // run-agent loop then treats them identically.
+  const llamaCalls = extractLlamaDottedFunctionCalls(text);
+
+  // Second pass: balanced `{name, arguments}` JSON anywhere in the text.
+  const jsonCalls = [];
   for (let i = 0; i < text.length; i++) {
     if (text[i] !== "{") continue;
     const balanced = readBalancedJson(text, i);
@@ -77,18 +86,75 @@ export function extractPseudoToolCalls(text) {
       parsed.arguments !== null &&
       !Array.isArray(parsed.arguments)
     ) {
-      out.push({
+      // Skip JSON that is actually the args object inside a dotted-function
+      // wrapper we already captured — otherwise we'd double-fire the tool.
+      const insideLlamaWrap = llamaCalls.some(
+        (lc) => lc._rawStart <= i && balanced.end <= lc._rawEnd
+      );
+      if (insideLlamaWrap) {
+        i = balanced.end - 1;
+        continue;
+      }
+      jsonCalls.push({
         id: nextId(),
-        function: {
-          name: parsed.name,
-          arguments: parsed.arguments,
-        },
+        function: { name: parsed.name, arguments: parsed.arguments },
         _pseudo: true,
         _raw: candidate,
       });
       i = balanced.end - 1;
     }
   }
+
+  // Strip internal markers used to dedupe against JSON pass.
+  return [
+    ...llamaCalls.map(({ _rawStart, _rawEnd, ...rest }) => rest),
+    ...jsonCalls,
+  ];
+}
+
+// Parse the dotted-function format emitted by some Llama instructions:
+//
+//   <function.send_telegram({"text": "hi"})</function>
+//   <function.list_projects({})</function>
+//
+// We accept missing closing tags (model sometimes truncates) and tolerate
+// whitespace between the name, the parens, and the args object.
+function extractLlamaDottedFunctionCalls(text) {
+  const out = [];
+  const re = /<function\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*(\{)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const name = m[1];
+    const argsStart = m.index + m[0].length - 1; // position of the `{`
+    const balanced = readBalancedJson(text, argsStart);
+    if (!balanced.ok) continue;
+    const argsBlob = text.slice(argsStart, balanced.end);
+    let args;
+    try {
+      args = JSON.parse(argsBlob);
+    } catch {
+      continue;
+    }
+    if (!args || typeof args !== "object" || Array.isArray(args)) continue;
+
+    // Find the end of the wrapper: optional ")", optional "</function>".
+    let cursor = balanced.end;
+    if (text[cursor] === ")") cursor++;
+    const tail = text.slice(cursor, cursor + 16);
+    const closeMatch = tail.match(/^\s*<\/function>/i);
+    if (closeMatch) cursor += closeMatch[0].length;
+
+    out.push({
+      id: nextId(),
+      function: { name, arguments: args },
+      _pseudo: true,
+      _raw: text.slice(m.index, cursor),
+      _rawStart: m.index,
+      _rawEnd: cursor,
+    });
+    // Advance regex past the closing brace so we don't double-match.
+    re.lastIndex = cursor;
+  }
   return out;
 }
 
@@ -105,11 +171,18 @@ export function cleanTextOfPseudoToolCalls(text) {
   out = out.replace(/_icall\(\s*\)/g, "");
   out = out.replace(/```tool_(?:call|use)\s*([\s\S]*?)```/gi, "");
 
-  // Now drop balanced JSON objects that were tool-call-shaped
-  const calls = extractPseudoToolCalls(out);
-  for (const c of calls) {
-    out = out.replace(c._raw, "");
+  // The Llama "dotted-function" wrapper. Drop the whole block — both the
+  // opening `<function.NAME(` and the trailing `)</function>` — so the user
+  // never sees the wire format. Greedy on balanced braces would be wrong
+  // (model might emit JSON later in the same message), so we use the same
+  // extractor we built for the call-parsing pass and remove its raw spans.
+  for (const call of extractPseudoToolCalls(out)) {
+    if (call._raw) out = out.replace(call._raw, "");
   }
+  // Some models emit a stray `</function>` after the args without the
+  // opening tag — sweep those too.
+  out = out.replace(/<\/?function(?:\.[a-zA-Z_][a-zA-Z0-9_]*)?>/gi, "");
+
   // Tidy up whitespace & blank lines
   out = out.replace(/\n{3,}/g, "\n\n").trim();
   return out;

package/src/core/agent/tools-overlap.js

@@ -0,0 +1,66 @@
+// Tools that overlap with post_command output sinks.
+//
+// A routine of kind=super_agent that has post_commands like
+//   `apx telegram send "$APX_LLM_OUTPUT"`
+// will already pipe the model's final text into Telegram. If the agent's tool
+// registry still exposes `send_telegram`, the model can also call it inside
+// the loop — producing two messages. See spec/backlog/01-routine-output-coherence.md.
+//
+// The map below pairs shell command prefixes with the tools that would
+// duplicate them. We match prefixes (not exact strings) because users join
+// commands with pipes, $vars, and quoting.
+
+export const POSTCMD_TOOL_OVERLAP = Object.freeze({
+  "apx telegram send":       ["send_telegram"],
+  "apx telegram notify":     ["send_telegram"],
+  "apx telegram send_photo": ["send_telegram"],
+  "apx telegram send_voice": ["send_telegram"],
+  "apx telegram send_audio": ["send_telegram"],
+  "apx voice say":           ["say_voice"], // reserved for the future voice tool
+});
+
+/**
+ * Given a list of post_commands shell strings, return the set of tool names
+ * that should be suppressed for the same routine's LLM invocation.
+ *
+ * Matching is by command prefix after trimming leading whitespace. Pipelines
+ * (`curl ... | apx telegram send`) and `&&`/`;` chains are walked so the
+ * detection isn't fooled by `cmd1 && apx telegram send …`.
+ */
+export function computeSuppressedTools(postCommands) {
+  if (!Array.isArray(postCommands) || postCommands.length === 0) return [];
+  const suppressed = new Set();
+  for (const raw of postCommands) {
+    if (typeof raw !== "string") continue;
+    // Split on shell-ish boundaries that introduce a new command.
+    // Keep this conservative — false negatives (under-suppression) are
+    // recoverable; false positives (over-suppression) silently disable tools.
+    const segments = raw.split(/\s*(?:&&|\|\||;|\|)\s*/);
+    for (const segRaw of segments) {
+      const seg = segRaw.trim();
+      for (const [prefix, tools] of Object.entries(POSTCMD_TOOL_OVERLAP)) {
+        if (seg.startsWith(prefix)) {
+          for (const t of tools) suppressed.add(t);
+        }
+      }
+    }
+  }
+  return [...suppressed];
+}
+
+/**
+ * Filter a tool-schemas array, removing any tool whose name appears in the
+ * suppress set. Returns a new array; the original is not mutated.
+ *
+ * Works with the OpenAI-style schema (`{ type: "function", function: { name } }`)
+ * and bare `{ name }` shapes — anything else is kept as-is.
+ */
+export function filterToolSchemas(toolSchemas, suppress) {
+  if (!Array.isArray(toolSchemas) || toolSchemas.length === 0) return toolSchemas;
+  if (!Array.isArray(suppress) || suppress.length === 0) return toolSchemas;
+  const drop = new Set(suppress);
+  return toolSchemas.filter((t) => {
+    const name = t?.function?.name || t?.name;
+    return !drop.has(name);
+  });
+}

package/src/core/apc-skill-sync.js

@@ -0,0 +1,97 @@
+// Sync apc-context skill from canonical APC sources (never owned by APX repo).
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+
+export const APC_SKILL_REL = path.join("skills", "apc-context", "SKILL.md");
+export const APC_SKILL_REMOTE =
+  "https://raw.githubusercontent.com/agentprojectcontext/agentprojectcontext/main/skills/apc-context/SKILL.md";
+
+export const APC_SKILL_SIBLINGS = [
+  path.resolve(PACKAGE_ROOT, "..", "apc", "skills", "apc-context", "SKILL.md"),
+  path.resolve(PACKAGE_ROOT, "..", "agentprojectcontext", "skills", "apc-context", "SKILL.md"),
+];
+
+export function apcSkillDest(packageRoot = PACKAGE_ROOT) {
+  return path.join(packageRoot, APC_SKILL_REL);
+}
+
+export function looksLikeApcContextSkill(text) {
+  return typeof text === "string"
+    && text.startsWith("---")
+    && /name:\s*apc-context/.test(text);
+}
+
+export function readApcContextSkill({ packageRoot = PACKAGE_ROOT } = {}) {
+  const dest = apcSkillDest(packageRoot);
+  if (fs.existsSync(dest)) {
+    const text = fs.readFileSync(dest, "utf8");
+    if (looksLikeApcContextSkill(text)) return { text, source: dest };
+  }
+  for (const candidate of APC_SKILL_SIBLINGS) {
+    if (!fs.existsSync(candidate)) continue;
+    const text = fs.readFileSync(candidate, "utf8");
+    if (looksLikeApcContextSkill(text)) return { text, source: candidate };
+  }
+  return null;
+}
+
+async function fetchRemote(timeoutMs = 5000) {
+  const fetchImpl = globalThis.fetch || (await import("node-fetch")).default;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(APC_SKILL_REMOTE, { signal: ac.signal });
+    if (!res.ok) return null;
+    return await res.text();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Refresh skills/apc-context/SKILL.md from APC canonical source.
+ * Non-fatal: returns { ok, source, reason }.
+ */
+export async function refreshApcContextSkill({ packageRoot = PACKAGE_ROOT, timeoutMs = 5000 } = {}) {
+  const dest = apcSkillDest(packageRoot);
+  let text = null;
+  let source = "unknown";
+
+  for (const candidate of APC_SKILL_SIBLINGS) {
+    if (!fs.existsSync(candidate)) continue;
+    const t = fs.readFileSync(candidate, "utf8");
+    if (looksLikeApcContextSkill(t)) {
+      text = t;
+      source = candidate;
+      break;
+    }
+  }
+
+  if (!text) {
+    try {
+      const t = await fetchRemote(timeoutMs);
+      if (looksLikeApcContextSkill(t)) {
+        text = t;
+        source = APC_SKILL_REMOTE;
+      }
+    } catch {
+      // fall through
+    }
+  }
+
+  if (!text) {
+    const existing = readApcContextSkill({ packageRoot });
+    if (existing) {
+      return { ok: true, source: existing.source, refreshed: false, reason: "kept-existing" };
+    }
+    return { ok: false, source: null, refreshed: false, reason: "no-source" };
+  }
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, text, "utf8");
+  return { ok: true, source, refreshed: true };
+}

package/src/core/code-sessions-store.js

@@ -0,0 +1,150 @@
+// Code sessions — persistent, structured transcripts for the web Code module
+// (the OpenCode-style coding surface). Unlike the human-readable per-agent
+// markdown sessions (api/sessions.js), these hold the RICH turn shape the UI
+// needs: interleaved text + tool parts, per-turn usage/model/mode, and a git
+// baseline for the changes/diff view. One JSON file per session:
+//
+//   ~/.apx/projects/<apxId>/code-sessions/<id>.json
+//
+// The `parts` shape mirrors the front-end ChatPart union (hooks/useChat.ts) so
+// stored turns render with the existing MessageBubble/ToolCall with zero
+// translation.
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+function sessionsDir(storagePath) {
+  return path.join(storagePath, "code-sessions");
+}
+
+function sessionFile(storagePath, id) {
+  return path.join(sessionsDir(storagePath), `${id}.json`);
+}
+
+function nowIso() {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+function shortId() {
+  const hex = randomUUID().replace(/-/g, "").slice(0, 8);
+  return "cs_" + parseInt(hex, 16).toString(36).padStart(6, "0").slice(-6);
+}
+
+// Atomic write: tmp file + rename so a crash mid-write can't corrupt a session.
+function writeJson(file, obj) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2));
+  fs.renameSync(tmp, file);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Lightweight row for the session list (no messages). */
+function toRow(s) {
+  return {
+    id: s.id,
+    title: s.title,
+    mode: s.mode,
+    model: s.model || null,
+    createdAt: s.createdAt,
+    updatedAt: s.updatedAt,
+    messageCount: Array.isArray(s.messages) ? s.messages.length : 0,
+    hasGit: !!(s.git && s.git.baselineTree),
+  };
+}
+
+/** List sessions for a project, newest-updated first. */
+export function listCodeSessions(storagePath) {
+  const dir = sessionsDir(storagePath);
+  if (!fs.existsSync(dir)) return [];
+  const rows = [];
+  for (const f of fs.readdirSync(dir)) {
+    if (!f.endsWith(".json")) continue;
+    const s = readJson(path.join(dir, f));
+    if (s && s.id) rows.push(toRow(s));
+  }
+  rows.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+  return rows;
+}
+
+/** Full session (with messages) or null. */
+export function getCodeSession(storagePath, id) {
+  if (!id || typeof id !== "string") return null;
+  return readJson(sessionFile(storagePath, id));
+}
+
+/**
+ * Create a new session.
+ * fields: { projectId, title?, model?, mode?, git? }
+ */
+export function createCodeSession(storagePath, fields = {}) {
+  const id = shortId();
+  const ts = nowIso();
+  const session = {
+    id,
+    projectId: fields.projectId != null ? String(fields.projectId) : null,
+    title: (fields.title && String(fields.title).trim()) || "New session",
+    createdAt: ts,
+    updatedAt: ts,
+    model: fields.model || null,
+    mode: fields.mode === "plan" ? "plan" : "build",
+    git: fields.git && typeof fields.git === "object" ? fields.git : null,
+    messages: [],
+  };
+  writeJson(sessionFile(storagePath, id), session);
+  return session;
+}
+
+/**
+ * Shallow-merge a patch into a session. Whitelisted keys only; `messages`,
+ * `id`, `createdAt`, `projectId` are never overwritten here.
+ */
+export function updateCodeSession(storagePath, id, patch = {}) {
+  const session = getCodeSession(storagePath, id);
+  if (!session) return null;
+  if (patch.title != null) session.title = String(patch.title).trim() || session.title;
+  if (patch.model !== undefined) session.model = patch.model || null;
+  if (patch.mode === "plan" || patch.mode === "build") session.mode = patch.mode;
+  if (patch.git !== undefined) session.git = patch.git;
+  session.updatedAt = nowIso();
+  writeJson(sessionFile(storagePath, id), session);
+  return session;
+}
+
+/** Delete a session file. Returns true if it existed. */
+export function removeCodeSession(storagePath, id) {
+  const file = sessionFile(storagePath, id);
+  if (!fs.existsSync(file)) return false;
+  fs.unlinkSync(file);
+  return true;
+}
+
+/**
+ * Append a turn (user or assistant) to a session and bump updatedAt.
+ * turn: { role, parts, model?, mode?, usage?, ts? }
+ * Returns the updated session, or null if the session is gone.
+ */
+export function appendTurn(storagePath, id, turn) {
+  const session = getCodeSession(storagePath, id);
+  if (!session) return null;
+  const entry = {
+    role: turn.role === "user" ? "user" : "assistant",
+    parts: Array.isArray(turn.parts) ? turn.parts : [],
+    ts: turn.ts || nowIso(),
+  };
+  if (turn.model) entry.model = turn.model;
+  if (turn.mode) entry.mode = turn.mode;
+  if (turn.usage) entry.usage = turn.usage;
+  if (turn.notes && turn.notes.length) entry.notes = turn.notes;
+  session.messages.push(entry);
+  session.updatedAt = entry.ts;
+  writeJson(sessionFile(storagePath, id), session);
+  return session;
+}