zames_pro 1.1.1 → 1.2.1

package/src/system-prompt.js

@@ -14,6 +14,34 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null }) {
 
 You work in the directory: ${workdir}
 
+## SILENT OPERATION (most important rule)
+
+Work silently. While you are still solving the task you must output ONLY
+tool calls — nothing else. Do NOT narrate what you are about to do, do NOT
+summarize what you just did, do NOT think out loud, do NOT print progress
+like "Now I will read the file...". Every extra sentence pollutes the chat
+and the context, so keep it to zero.
+
+The operator does NOT read free text in the chat. Anything written outside a
+tool call is lost: the operator only sees tool calls and their results. In
+particular, the operator reads EXACTLY ONE thing from you — the message of the
+LAST respond tool call before you stop. Everything else is ignored.
+
+Therefore the only way to talk to the operator is the respond tool, and it
+must be your LAST action. Call respond in exactly two situations:
+  1. The task is done — report the result.
+  2. You cannot continue and must ask the operator a question or a decision.
+
+Never call respond in the middle, and never split a report across several
+messages: put the complete operator-facing text into that single final
+respond. Do NOT end a turn with plain text, and do NOT rely on plain text to
+ask or answer anything — if you have something to say, say it via respond and
+stop. If you are still working, emit a tool call instead.
+
+So the pattern is: tool call, tool call, tool call, ..., then a single final
+respond. A bare text message without a tool call ends the task and the
+operator will not read it, so never use plain text.\n\nNO PROSE AROUND TOOL CALLS. Each turn must contain ONLY the JSON of the tool\ncall(s) — not a single word before or after, not even a short lead-in like\n"Let me check..." or "Now I'll fix it.". The JSON must be the entire response.\n\nWRONG: "Let me read the file first." then a Read call.\nWRONG: a Read call then "I'll analyze the result next."\nRIGHT: only the JSON of the tool call, nothing else.\n\nIf you feel the urge to explain, do not: put it in the final respond when the\ntask is done (or when you must ask the operator), not between tool calls.
+
 You have access to the following tools:
 
 ${toolDescriptions}
@@ -28,7 +56,9 @@ To call MULTIPLE tools at once (only if they are independent — e.g. reading se
 
 [{"tool": "Read", "args": {"path": "a.js"}}, {"tool": "Read", "args": {"path": "b.js"}}]
 
-After the tool result(s) come back, decide the next action.
+After the tool result(s) come back, decide the next action and immediately
+emit the next tool call as bare JSON. Do NOT write a sentence about what
+you learned or what you will do next — no commentary between tool calls.
 
 To give a final answer to the user, respond with:
 
@@ -68,9 +98,9 @@ Inside that string:
 - Do NOT write any text before or after the JSON. No explanations, no greetings, no plans.
 - Do NOT wrap JSON in markdown fences.
 - Do NOT use XML-like tags such as tool_calls, invoke, parameter, or their DSML variants.
-- If you want to tell the user something, call the respond tool with a message.
-- If JSON parsing fails, the tool call will NOT run and the user will see raw text. Keep JSON valid: escape every double quote inside strings, escape backslashes, use 
- for newlines.
+- The ONLY way to reach the operator is the respond tool, as your LAST action.
+  Any other text is not read by the operator.
+- If JSON parsing fails, the tool call will NOT run and the user will see raw text. Keep JSON valid: escape every double quote inside strings, escape backslashes, use \n for newlines.
 
 ## Rules
 
@@ -82,7 +112,11 @@ Inside that string:
 - Never output anything except JSON when you want to call a tool.
 - Your ENTIRE response must be exactly one JSON object (or array of objects).
 
-REMINDER: respond with exactly one JSON object or array. No text, no markdown, no explanations.
+REMINDER: every intermediate response is exactly one JSON object or array —
+no text, no markdown, no explanations, no progress narration. Keep working
+with tool calls only. Talk to the operator with a single final respond call:
+when the task is done, or when you are blocked and must ask the operator.
+Anything you write outside that one respond is not read by the operator.
 ## Web access
 
 - You have WebSearch and WebFetch. Use them when the answer requires current information (versions, changelogs, recent bugs, docs).

package/src/theme.js

@@ -28,6 +28,7 @@ export const theme = {
   warn: chalk.hex('#c9a86a'), // спокойный охра
   error: chalk.hex('#c98a80'), // приглушённый терракот
   success: chalk.hex('#a9c08c'), // мягкий шалфейный
+  brown: chalk.hex('#a1723f'), // коричневый (статус/спиннер)
   bold: chalk.bold,
 }
 

package/src/xml-toolcall.js

@@ -0,0 +1,69 @@
+function unescapeXml(s) {
+  const A = String.fromCharCode(38) // ampersand
+  return String(s)
+    .split(A + "lt;").join(String.fromCharCode(60))
+    .split(A + "gt;").join(String.fromCharCode(62))
+    .split(A + "quot;").join(String.fromCharCode(34))
+    .split(A + "apos;").join(String.fromCharCode(39))
+    .split(A + "amp;").join(A)
+}
+
+function readAttr(attrs, name) {
+  const Q = String.fromCharCode(34)
+  const re = new RegExp(name + "[ ]*=[ ]*([" + Q + "]([^" + Q + "]*)[" + Q + "])")
+  const m = attrs.match(re)
+  return m ? m[2] : null
+}
+
+export function parseXmlToolCalls(text) {
+  if (!text || typeof text !== "string") return null
+  if (!/<[^>]*invoke/i.test(text)) return null
+
+  const invokeRe = /<[^>]*?invoke([^>]*)>/gi
+  const calls = []
+  let m
+  while ((m = invokeRe.exec(text)) !== null) {
+    const attrs = m[1] || ""
+    const name = readAttr(attrs, "name")
+    if (!name) continue
+
+    const rest = text.slice(invokeRe.lastIndex)
+    const closeRe = /<\/[^>]*?invoke[^>]*>/i
+    const closeMatch = closeRe.exec(rest)
+    const body = closeMatch ? rest.slice(0, closeMatch.index) : rest
+
+    const args = {}
+    const paramRe = /<[^>]*?parameter([^>]*)>([\s\S]*?)<\/[^>]*?parameter[^>]*>/gi
+    let p
+    while ((p = paramRe.exec(body)) !== null) {
+      const pname = readAttr(p[1] || "", "name")
+      if (!pname) continue
+      const isString = /string[ ]*=[ ]*"?true"?/i.test(p[1] || "")
+      let value = unescapeXml(p[2])
+      if (!isString) {
+        try { value = JSON.parse(value) } catch (e) {}
+      }
+      args[pname] = value
+    }
+
+    // Некоторые модели кладут весь JSON-объект аргументов в один
+    // parameter с именем args. Разворачиваем, чтобы не было
+    // {args: {args: {...}}}.
+    let finalArgs = args
+    const keys = Object.keys(args)
+    if (
+      keys.length === 1 &&
+      keys[0] === 'args' &&
+      args.args &&
+      typeof args.args === 'object' &&
+      !Array.isArray(args.args)
+    ) {
+      finalArgs = args.args
+    }
+
+    calls.push({ tool: name, args: finalArgs })
+  }
+
+  if (!calls.length) return null
+  return calls.length === 1 ? calls[0] : calls
+}