thincoder 0.11.0 → 0.11.1

package/src/agent-tools/verify.mjs

@@ -19,6 +19,7 @@ const MODULE_TO_TEST = {
   skills: "test/tools.test.mjs",
   distill: "test/tools.test.mjs",
   markdown: "test/agent.test.mjs",
+  advisor: "test/advisor.test.mjs",
   mcp: null,
   prompts: null,
   context: null,

package/src/agent-tools.mjs

@@ -11,3 +11,4 @@ export { goalTool } from "./agent-tools/goal.mjs"
 export { verifyTool } from "./agent-tools/verify.mjs"
 export { recentChangesTool } from "./agent-tools/recent-changes.mjs"
 export { timerTool } from "./agent-tools/timer.mjs"
+export { advisorTool } from "./agent-tools/advisor.mjs"

package/src/agent.mjs

@@ -31,7 +31,7 @@ export const EXPLORE_OVERLAY = _EXPLORE
 export const CODER_OVERLAY = _CODER
 export const PLAN_OVERLAY = _PLAN
 
-// Re-exported for consumption by agent-tools.mjs
+// exported for consumption by agent-tools.mjs
 export {
   ContinueError,
   repairHistory, listWorkDir, loadProjectInstructions,
@@ -61,8 +61,8 @@ export function createAgent({
     provider, tools, config, cwd, memory, _role: role,
     overlay, tasks, history,
     planMode, autoApprove, goal,
-    _mutatedThisRun: false, _verifiedThisRun: false, _verifyPassed: undefined,
-    _touchedFiles: [], _verifyRetries: 0,
+    _mutatedThisRun: false, _verifiedThisRun: false, _verifyPassed: undefined, _calledAdvisorThisRun: false,
+    _touchedFiles: [], _verifyRetries: 0, _advisorRound: 0,
     _pendingReminders: [],
     _pendingTimers: [],
     _sessionStart: sessionStart,
@@ -81,11 +81,16 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
   agent._mutatedThisRun = false
   agent._verifiedThisRun = false
   agent._verifyPassed = undefined
+  agent._calledAdvisorThisRun = false
   agent._touchedFiles = []
   agent._verifyRetries = 0
+  agent._advisorRound = 0
   let guardPushbacks = 0
   let honestReminderInjected = false
   const recentCallSigs = []
+  // repeat: "once" stream rules fire at most once per runAgent call (user turn):
+  // this set survives across chat() calls (rule abort-retry, tool loop) within the turn.
+  const streamRuleFired = new Set()
 
   for (let turn = 0; turn < maxTurns; turn++) {
 
@@ -94,6 +99,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       try {
         if (await compressIfNeeded(agent, threshold, callbacks)) {
           agent._compressFailures = 0
+          agent._planReminderAtLen = 0 // After compression history shrinks, reset cadence so reminders resume
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
           callbacks.onCompress?.()
           if (agent.autoApprove && !agent.history.some((m) => m.content === AUTO_REMINDER)) {
@@ -111,6 +117,24 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
     }
 
+    // Plan-mode reminder cadence: re-inject constraint reminders while plan mode is active
+    // (sparse every 2 turns, full every 5 turns or when the user sends a new message),
+    // so the read-only restriction never fades from context.
+    if (agent.planMode) {
+      const lastMsg = agent.history.at(-1)
+      const realUserMsg = lastMsg?.role === "user"
+        && typeof lastMsg.content === "string"
+        && !lastMsg.content.startsWith("[System reminder:")
+        && !lastMsg.content.startsWith("[User interrupt:")
+      const newUserSince = realUserMsg && agent.history.length > (agent._planReminderAtLen ?? 0)
+      const { planReminderForTurn } = await import("./agent-tools/plan.mjs")
+      const reminder = planReminderForTurn(agent, newUserSince)
+      if (reminder) {
+        agent._planReminderAtLen = agent.history.length + 1
+        agent.history.push({ role: "user", content: reminder, transient: true })
+      }
+    }
+
     const messages = [{ role: "system", content: systemPrompt }, ...agent.history]
     let response
 
@@ -129,15 +153,18 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
         onWait: callbacks.onWait,
         signal,
         streamRules: agent.config.agent?.streamRules ?? [],
+        firedPatterns: streamRuleFired,
       })
     } catch (e) {
       // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
       // Inject the message into history and let the outer loop recreate the controller.
       if (e.name === "AbortError" && signal?.reason?.interrupt) {
-        agent.history.push({
-          role: "user",
-          content: `[User interrupt: ${signal.reason.message}]`,
-        })
+        const msg = `[User interrupt: ${signal.reason.message}]`
+        // Dedup: if the interrupt was already handled during tool execution (L302-310),
+        // don't push a duplicate — the outer loop will still recreate the controller.
+        if (agent.history.at(-1)?.content !== msg) {
+          agent.history.push({ role: "user", content: msg })
+        }
       }
       throw e
     }
@@ -219,6 +246,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           role: "user",
           content: `[System reminder: you still have pending tasks: ${pending}. Update their status with the task tool before finishing — if they're done, mark them done; if they're not applicable, remove them.]`,
         })
+        callbacks.onTurnEnd?.(agent, turn)
         continue
       }
       // --- verify guard: push model to verify mutated files before completion ---
@@ -230,15 +258,15 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
             role: "user",
             content: "[System reminder: you modified files in this run but have not verified the changes. Before finishing: call the verify tool to run syntax checks and tests. If verify reports failures, fix them and run verify again. If verification is genuinely impossible here, say so explicitly in your reply.]",
           })
+          callbacks.onTurnEnd?.(agent, turn)
           continue
-        }
-        if (agent._verifiedThisRun && agent._verifyPassed === false && agent._verifyRetries < MAX_VERIFY_RETRIES) {
           agent._verifyRetries++
           agent.history.push({ role: "assistant", content: response.content })
           agent.history.push({
             role: "user",
             content: `[System reminder: verify reported test failures (retry ${agent._verifyRetries}/${MAX_VERIFY_RETRIES}). Review the failures, fix the issues, then run verify again. If you cannot fix after ${MAX_VERIFY_RETRIES} attempts, explain honestly what's blocking you.]`,
           })
+          callbacks.onTurnEnd?.(agent, turn)
           continue
         }
         if (agent._verifyPassed === false && agent._verifyRetries >= MAX_VERIFY_RETRIES) {
@@ -252,6 +280,22 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
             role: "user",
             content: `[System reminder: ${MAX_VERIFY_RETRIES} verify attempts exhausted and tests are still failing. In your response to the user, you MUST state explicitly: (1) what tests are still failing, (2) what you tried, (3) what you believe the root cause is. Do not present this as complete — the user needs to know the work is unfinished.]`,
           })
+          callbacks.onTurnEnd?.(agent, turn)
+          continue
+        }
+      }
+      // --- advisor guard: push model to review changes before completion ---
+      // When advisor is enabled and guard is not explicitly disabled, mutated files
+      // must be reviewed before the turn ends. No hard round cap — convergence protocol
+      // (round 3+ strict verification) naturally limits divergence.
+      if (depth === 0 && agent.config?.advisor?.enabled && agent.config?.advisor?.guard !== false) {
+        if (agent._mutatedThisRun && !agent._calledAdvisorThisRun && (agent._touchedFiles ?? []).length > 0) {
+          agent.history.push({ role: "assistant", content: response.content })
+          agent.history.push({
+            role: "user",
+            content: `[System reminder: you changed code in this run but haven't reviewed with advisor (round ${agent._advisorRound + 1}). Call the \`advisor\` tool to get an independent code review. After the review, produce a response table for every issue found (see discipline rules for format). If the changes are trivial (typo, one-liner, formatting only), you may skip and explain why in your reply.]`,
+          })
+          callbacks.onTurnEnd?.(agent, turn)
           continue
         }
       }
@@ -276,6 +320,17 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
 
     const results = await executeToolCalls(agent, toolByName, response.toolCalls, callbacks, depth, signal)
 
+    // Ctrl+I interrupt during tool execution: skip committing partial results —
+    // the tool failure messages would mislead the model. Inject the interrupt and retry.
+    if (signal?.reason?.interrupt) {
+      agent.history.push({
+        role: "user",
+        content: `[User interrupt: ${signal.reason.message}]`,
+      })
+      callbacks.onTurnEnd?.(agent, turn)
+      continue
+    }
+
     // Model is executing tools → doing real work, reset guard pushback counter
     guardPushbacks = 0
 
@@ -308,8 +363,16 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
       agent.history.push({ role: "tool", tool_call_id: toolCall.id, content: result })
       if (tool && ok) {
-        if (!tool.readonly && !tool.sideEffectExempt) agent._mutatedThisRun = true
+        if (!tool.readonly && !tool.sideEffectExempt) {
+          agent._mutatedThisRun = true
+          // Any mutation after advisor invalidates the review — need re-review
+          if (agent._calledAdvisorThisRun) agent._calledAdvisorThisRun = false
+        }
         if (toolCall.name === "verify") agent._verifiedThisRun = true
+        if (toolCall.name === "advisor") {
+          agent._calledAdvisorThisRun = true
+          agent._advisorRound++  // advance convergence round
+        }
         if (FILE_MUTATORS.has(toolCall.name)) {
           const args = JSON.parse(toolCall.arguments)
           const paths = tool.touchedPaths ? tool.touchedPaths(args) : [args.path]
@@ -386,17 +449,6 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     callbacks.onTurnEnd?.(agent, turn)
-
-    // Advisor: automated code review after each tool-execution turn.
-    // Runs asynchronously — failure is silent, main loop continues regardless.
-    if (agent.config?.advisor?.enabled) {
-      const { runAdvisor } = await import("./advisor.mjs")
-      const note = await runAdvisor(agent)
-      if (note) {
-        agent.history.push({ role: "user", content: note })
-        callbacks.onAdvisor?.(note)
-      }
-    }
   }
 
   throw new ContinueError(maxTurns)

package/src/auto-think.mjs

@@ -31,6 +31,26 @@ const EFFORT_MAP = {
   high: ["max", "max", "xhigh", "max"],
 }
 
+/**
+ * Build classifier input from history: the latest real user message (reminders and
+ * interrupt injections excluded), plus the previous user message as context when the
+ * latest is too short to classify on its own (e.g. "继续" / "还有几个问题").
+ * Exported for tests.
+ */
+export function buildClassifierInput(history) {
+  const isRealUser = (m) =>
+    m.role === "user" && typeof m.content === "string"
+    && !m.content.startsWith("[System reminder:") && !m.content.startsWith("[User interrupt:")
+  const users = history.filter(isRealUser)
+  const last = users.at(-1)
+  if (!last) return null
+  let prompt = last.content
+  if (prompt.length < 200 && users.length > 1) {
+    prompt = `Previous request (context):\n${users.at(-2).content.slice(0, 1200)}\n\nLatest message:\n${prompt}`
+  }
+  return prompt.slice(0, 2000)
+}
+
 /**
  * Classify the difficulty of the user's prompt and adjust reasoning effort.
  * Only runs on the first turn (turn === 0) of a user message.
@@ -47,10 +67,8 @@ export async function classifyAndApply(agent, turn) {
   const validEfforts = spec.reasoningEffortEnum
   if (!validEfforts) return null // Model doesn't support reasoning effort
 
-  // Get the last user message (should be the most recent history entry or the input)
-  const lastUser = [...agent.history].reverse().find(m => m.role === "user")
-  if (!lastUser) return null
-  const prompt = typeof lastUser.content === "string" ? lastUser.content : ""
+  const prompt = buildClassifierInput(agent.history)
+  if (prompt == null) return null
 
   // Classification call: use same provider, minimal tokens, no tools, no streaming
   let level
@@ -59,7 +77,7 @@ export async function classifyAndApply(agent, turn) {
     const response = await chat(classifierProvider, {
       messages: [
         { role: "system", content: CLASSIFY_PROMPT },
-        { role: "user", content: prompt.slice(0, 2000) },
+        { role: "user", content: prompt },
       ],
       tools: [],
       signal: AbortSignal.timeout(5_000),

package/src/config.mjs

@@ -39,7 +39,7 @@ const DEFAULTS = {
     compactThreshold: 100000,
     verifyGuard: false,  // push model back to verify when files were mutated but verify not run (opt-in)
     streamRules: [],      // time-traveling stream rules: [{ pattern: "regex", message: "reminder", action: "abort"|"warn", repeat: "always"|"once" }]
-    advisor: { enabled: false },  // automated code review after each tool-execution turn; optionally: { enabled: true, provider: "deepseek", model: "deepseek-chat" }
+    advisor: { enabled: false },  // code review; { enabled: true, provider: "deepseek", model: "deepseek-chat", thinking: { type: "enabled" }, reasoningEffort: "max", guard: true }
     autoThink: false,     // auto-classify task difficulty and set reasoning effort per-turn
   },
   memory: {

package/src/prompts/advisor-round1.md

@@ -0,0 +1,23 @@
+You are a code review advisor.
+Perform a full-scope review of the code changes.
+You have read-only tools to explore the codebase.
+
+Review workflow:
+1. Read AGENTS.md and any design documents to understand project conventions, version requirements, and architecture decisions.
+2. Run git diff HEAD to discover uncommitted changes.
+3. Read changed files for full context.
+4. Use grep or lsp to trace callers, imports, and dependencies.
+5. Produce your review table.
+
+Rules:
+- Reply in the same language as the task summary.
+- Respect the project's stated platform requirements — do not flag features as errors if they are valid under the project's target environment.
+- Output a Markdown table. This table becomes the sole basis for convergence in later rounds — be thorough.
+| # | File | Severity | Issue | Suggestion |
+|---|------|----------|-------|------------|
+| 1 | src/x.mjs | 🔴 | ... | ... |
+- Order by severity: 🔴 Critical · 🟡 Advisory · 🔵 Style.
+- For each issue state: which file, what the problem is, why it is a problem, how to fix it.
+- If the code is clean, say exactly: "No issues found — code quality looks good."
+- Cover everything now. Subsequent rounds only check fix status of items in this table — they will NOT find new issues.
+- Stop calling tools once you are ready to produce the review table.

package/src/prompts/advisor-round2.md

@@ -0,0 +1,26 @@
+You are a code review advisor.
+Verify the prior issue table (provided in the review context).
+You may note obvious new issues introduced by the fixes.
+You have read-only tools to explore the codebase.
+
+Review workflow:
+1. Read AGENTS.md and any design documents to understand project conventions, version requirements, and architecture decisions.
+2. Run git diff HEAD to see what changed since the last review.
+3. Read changed files for full context.
+4. Use grep or lsp to trace callers, imports, and dependencies.
+5. Produce your review table.
+
+Rules:
+- Respect the project's stated platform requirements — do not flag features as errors if they are valid under the project's target environment.
+- Primarily check fix status of items in the prior issue table.
+- For items marked "fixed": verify they were actually fixed.
+- For items marked "not an issue": evaluate whether the reasoning is sound.
+- You may flag obvious new problems — but only if clearly visible in the diff and would cause crashes, data loss, or logic errors.
+- Do NOT nitpick style or naming.
+- Output a Markdown table listing all remaining problems (old or new):
+| # | Orig# | File | Severity | Status | Notes |
+|---|-------|------|----------|--------|-------|
+| 1 | 3     | src/x.mjs | 🔴 | Unfixed | ... |
+| N | (new) | src/y.mjs | 🔴 | New: null check missing after fix | ... |
+- If all issues are resolved, say exactly: "All issues resolved — review passed."
+- Stop calling tools once you are ready to produce the review table.

package/src/prompts/advisor-round3.md

@@ -0,0 +1,24 @@
+You are a code review advisor.
+Strictly verify only the prior issue table (provided in the review context).
+Do NOT look for new issues.
+You have read-only tools to explore the codebase.
+
+Review workflow:
+1. Read AGENTS.md and any design documents to understand project conventions, version requirements, and architecture decisions.
+2. Run git diff HEAD to see what changed since the last review.
+3. Read changed files for full context.
+4. Verify fix status of each item in the prior issue table.
+5. Produce your review table.
+
+Rules:
+- Respect the project's stated platform requirements — do not flag features as errors if they are valid under the project's target environment.
+- Only check fix status of items in the prior issue table.
+- For items marked "fixed": verify they were actually fixed.
+- For items marked "not an issue": evaluate whether the reasoning is sound.
+- Output a Markdown table. Only list items that still have problems:
+| # | Orig# | File | Severity | Status | Notes |
+|---|-------|------|----------|--------|-------|
+| 1 | 3     | src/x.mjs | 🔴 | Unfixed | ... |
+| 2 | 5     | src/y.mjs | 🟡 | Reasoning invalid | ... |
+- If all issues are resolved, say exactly: "All issues resolved — review passed."
+- Stop calling tools once you are ready to produce the review table.

package/src/prompts/coder.md

@@ -3,6 +3,7 @@ You are a coding subagent. The parent agent dispatched you to handle a self-cont
 Guidelines:
 - Work independently: use doc_search to learn project conventions and design, repo_outline to understand structure, then code_search to find implementations.
   Don't write code until you know what the project intends.
+- MINIMAL changes: solve the task, nothing more. No opportunistic cleanup, no speculative generality, no half-finished refactors. Keep the diff small enough to review at a glance — the parent agent evaluates your work by reading the diff, and every unrelated change dilutes it.
 - Write code in small, verified steps — don't write multiple files at once without checking each along the way:
   1. After every write/edit of a file: run a syntax/lint check to catch parse errors immediately
   2. After a logical group of changes: run the relevant tests to confirm behavior

package/src/prompts/discipline.md

@@ -68,9 +68,23 @@ Testing discipline (right check at the right time):
 - When verify reports "ACTION REQUIRED: write a test", stop. Do NOT proceed to "done." Write a test that validates the change, then re-run verify.
 - If verify reports syntax errors, test failures, or a missing-test warning, fix them before claiming completion — never mark work done with known failures.
 - When you change behavior or add code, add at least one test that covers the change. If no related test file exists for the module, create one. Untested code is incomplete code — the verify tool will enforce this.
+- **Code review (advisor) — convergence protocol:**
+  Call `advisor` to get an independent review of your changes. The advisor uses a separate LLM with access to your git diff, changed files, and review criteria from `.thincoder/advisor.md`.
+  - **Round 1**: full-scope review. Advisor produces a numbered issue table (`| # | File | Severity | Issue | Suggestion |`).
+  - **After every advisor call that finds issues**: produce a response table in your reply. Format:
+    | # | Action | Detail |
+    |---|--------|--------|
+    | 1 | ✅ Fixed | (what you changed) |
+    | 2 | ❌ Not an issue | (reasoning — why this is not a bug) |
+  - **Round 2**: semi-convergence — advisor primarily verifies the prior table, but may flag obvious new issues introduced by the fixes (crashes, data loss, logic errors — not style).
+  - **Round 3+**: strict convergence — advisor ONLY checks items in the prior issue table, will NOT find new issues. The response table you wrote guides its verification.
+  - If advisor says "all clear": proceed to verify.
+  - If issues persist: fix them, update your response table, re-run advisor.
+  - No hard round cap — the convergence protocol naturally limits divergence.
+  - The advisor is optional if you only made trivial changes (typo, one-liner).
 
 Debugging strategy (when something goes wrong, three steps before anything else):
-- **Step 0 — Set a timer before you start reasoning**: immediately call `timer(30, "试试加个日志？")` to give yourself a bounded thinking window.
+- **Step 0 — Set a timer before you start reasoning**: immediately call `timer(180, "试试加个日志？")` to give yourself a bounded thinking window.
   When the timer fires, a reminder will suggest trying to run the code or add a debug log.
   You are more likely to over-think than to over-act; the timer breaks that cycle.
   This is not optional — it's the first step of any code analysis or debugging session.

package/src/prompts/explore.md

@@ -1,3 +1,5 @@
+You are now running as a subagent. All user messages come from the parent agent — the parent CANNOT see your context, it only sees your final report. Treat the parent as your caller. Do not ask the end user questions — if something is ambiguous, note it in your report.
+
 You are a codebase exploration specialist — an explore subagent. Your role is to search, read, and analyze. You do NOT have file editing tools.
 
 Guidelines:

package/src/prompts/plan.md

@@ -1,3 +1,5 @@
+You are now running as a subagent. All user messages come from the parent agent — the parent CANNOT see your context, it only sees your final report. Treat the parent as your caller. Do not ask the end user questions — if something is ambiguous, note it in your plan.
+
 You are a planning subagent. The parent agent dispatched you to design an implementation plan for a coding task. You are READ-ONLY: you can read and search files and consult the web, but you have no file-editing or mutation tools—do not attempt to modify anything. Your deliverable IS the plan itself, returned as your final message.
 
 Guidelines:

package/src/prompts/system.md

@@ -30,6 +30,7 @@ Act, don't guess.
 Prefer tool calls over speculation — read files before modifying them, search more when in doubt.
 When you need multiple independent pieces of information, make all tool calls in the SAME response so they run in parallel.
 The system can handle many simultaneous operations; serializing them wastes time and tokens.
+Before a non-trivial tool call, say what you're about to do in one short sentence (~8-10 words). Keep these progress notes sparse — one per phase, not one per call.
 
 **When choices conflict:**
 - Correctness first — you will always be faster than the human, so speed is never the bottleneck. Never skip steps to save time.
@@ -49,8 +50,11 @@ The system can handle many simultaneous operations; serializing them wastes time
 - Never modify files outside the working directory. read/write/edit tools enforce this.
 - Do NOT use bash or other tools to bypass the working-directory boundary.
 - If a task needs an external file changed, say so and let the user do it.
+- **Reversibility tiers — decide before acting:**
+  - Reversible local work (read, search, edit files, run tests, local lint/build): proceed freely, no confirmation needed.
+  - Destructive or hard-to-reverse actions (rm -rf, force-push, dropping tables, killing processes, deleting branches): confirm first — even in auto mode.
+  - Outward-facing actions (git commit/push, publishing, sending messages, uploading artifacts, posting to external services): confirm each time; one-time approval is not a standing license.
 - Never run git commit/push unless the user explicitly asks.
-- For destructive actions (rm -rf, force-push, dropping tables), confirm first — even in auto mode.
 - Before risky bulk operations (mass edits, generated-code overwrites, destructive scripts), use `git action="checkpoint" checkpointAction="create"` so the work can be restored.
 - If your own edits break something and you can't easily undo: `git action="checkpoint" checkpointAction="list"` to see snapshots, then `checkpointAction="rewind"` to go back. A checkpoint is auto-created before every user task, so there's always a fallback.
 - When context compacts mid-session you will see a summary of earlier work:

package/src/provider/anthropic.mjs

@@ -42,10 +42,10 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
   if (tools?.length) body.tools = tools
   if (provider.temperature != null) {
     let t = provider.temperature
-    if (spec.tempRange) {
-      t = Math.min(spec.tempRange[1], Math.max(spec.tempRange[0], t))
-      t = Math.round(t * 100) / 100
-    }
+    // Anthropic API hard limit is 0-1; models without a declared tempRange still get clamped
+    const [tMin, tMax] = spec.tempRange ?? [0, 1]
+    t = Math.min(tMax, Math.max(tMin, t))
+    t = Math.round(t * 100) / 100
     body.temperature = t
   }
 

package/src/provider/core.mjs

@@ -1,10 +1,13 @@
 /**
  * provider/core.mjs — LLM call core
- * chat / listModels / createProvider / requestWithRetry / readSSE
+ * chat / listModels / createProvider / requestWithRetry
+ * SSE parsing → provider/sse.mjs
  */
 
 import { specForModel } from "../config.mjs"
 import { proxyFetch } from "../proxy.mjs"
+import { readSSE } from "./sse.mjs"
+export { readSSE } from "./sse.mjs"
 import {
   RETRYABLE_STATUS, MAX_RETRIES, MAX_CONTINUATIONS,
   RATE_LIMIT_BACKOFF_MS, _rateHooks,
@@ -36,7 +39,7 @@ export function createProvider(config) {
 }
 
 /** Send a streaming chat completion request with automatic continuation on truncation */
-export async function chat(provider, { messages, tools, onToken, onReasoning, onWait, signal, streamRules }) {
+export async function chat(provider, { messages, tools, onToken, onReasoning, onWait, signal, streamRules, firedPatterns }) {
   // Format dispatch: delegate to non-OpenAI transports
   if (provider.format === "anthropic") {
     const { chat: anthropicChat } = await import("./anthropic.mjs")
@@ -95,7 +98,7 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
   await rateGate(provider, estimated, onWait, signal)
 
   const response = await requestWithRetry(provider, body, signal, onWait)
-  const result = await readSSE(response, { onToken, onReasoning, rules, signal })
+  const result = await readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns })
   recordRate(provider, estimated, result.usage)
 
   // Stream rule triggered or user interrupted mid-generation — return partial result
@@ -303,129 +306,6 @@ function isNonRetryableError(status, text) {
   return false
 }
 
-export async function readSSE(response, { onToken, onReasoning, rules, signal }) {
-  const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
-  const decoder = new TextDecoder()
-  let buffer = ""
-  let hasChoices = false
-  // Track patterns already fired this turn for repeat: "once" gating
-  const firedPatterns = new Set()
-
-  const processLines = (lines) => {
-    for (const line of lines) {
-      if (!line.startsWith("data:")) continue
-      const data = line.slice(5).trim()
-      if (!data || data === "[DONE]") continue
-
-      let json
-      try { json = JSON.parse(data) } catch { continue }
-
-      if (json.usage) result.usage = json.usage
-      const choice = json.choices?.[0]
-      if (!choice) continue
-      hasChoices = true
-      if (choice.finish_reason) result.finishReason = choice.finish_reason
-
-      const delta = choice.delta ?? {}
-      if (delta.reasoning_content) {
-        result.reasoning += delta.reasoning_content
-        onReasoning?.(delta.reasoning_content)
-      }
-      if (delta.content) {
-        result.content += delta.content
-        onToken?.(delta.content)
-      }
-      for (const tc of delta.tool_calls ?? []) {
-        const slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
-        if (tc.id) slot.id = tc.id
-        if (tc.function?.name && !slot.name) slot.name = tc.function.name
-        if (tc.function?.arguments) slot.arguments += tc.function.arguments
-      }
-    }
-  }
-
-  if (!response.body) throw new Error("No stream response body")
-  try {
-    for await (const chunk of response.body) {
-      // Active signal check: Ctrl+I abort should halt stream immediately, not wait for
-      // the underlying fetch stream to propagate the abort (delayed on Windows).
-      if (signal?.aborted) {
-        const e = new DOMException("The operation was aborted", "AbortError")
-        e.reason = signal.reason
-        throw e
-      }
-      buffer += decoder.decode(chunk, { stream: true })
-      const lines = buffer.split("\n")
-      buffer = lines.pop()
-      processLines(lines)
-
-      // Time-traveling stream rules: check accumulated content against patterns.
-      // Only triggers on text content (not during tool_call generation) to avoid
-      // interrupting structured tool use.
-      // action "abort": halt the stream immediately and retry with the rule injected.
-      // action "warn":  let the stream finish, then inject the warning after the turn (non-interrupting).
-      // repeat "once":  skip if this rule's pattern has already fired in the current turn.
-      if (rules?.length && result.content && !result.toolCalls.length) {
-        for (const rule of rules) {
-          if (rule.repeat === "once" && firedPatterns.has(rule.pattern)) continue
-          if (rule._regex.test(result.content)) {
-            if (rule.repeat === "once") firedPatterns.add(rule.pattern)
-            if (rule.action === "abort") {
-              result.ruleTriggered = true
-              result.ruleMessage = rule.message
-              result.ruleName = rule.name
-              return result
-            }
-            // warn: accumulate deduplicated by pattern, let the stream complete
-            const existing = result._warnings ??= []
-            if (!existing.some(w => w.pattern === rule.pattern)) {
-              existing.push({ name: rule.name, pattern: rule.pattern, message: rule.message })
-            }
-          }
-        }
-      }
-    }
-    buffer += decoder.decode()
-    processLines(buffer.split("\n"))
-  } catch (e) {
-    // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
-    // The interrupted signal.reason carries the user's message; return partial content
-    // so the agent loop can inject it as a user message and retry.
-    if (e.name === "AbortError" && signal?.reason?.interrupt) {
-      result.interrupted = true
-      result.interruptMessage = signal.reason.message
-      return result
-    }
-    throw e
-  }
-
-  // If no SSE choices were found, the response is likely a JSON error
-  if (!hasChoices) {
-    const contentType = response.headers.get("content-type") || ""
-    let errorMsg = ""
-    try {
-      const raw = buffer.trim() || ""
-      if (raw) {
-        const parsed = JSON.parse(raw)
-        errorMsg = parsed?.error?.message
-          || parsed?.base_resp?.status_msg
-          || parsed?.detail
-          || parsed?.message
-          || parsed?.msg
-          || (typeof parsed.error === "string" ? parsed.error : "")
-      }
-    } catch { /* not JSON */ }
-    if (!errorMsg && !contentType.includes("event-stream")) {
-      errorMsg = `Response is not SSE (Content-Type: ${contentType || "unknown"})`
-    }
-    if (errorMsg) {
-      throw new Error(`API error: ${errorMsg}`)
-    }
-  }
-
-  return result
-}
-
 function betaBaseURL(baseURL) {
   // DeepSeek prefix continuation uses /beta endpoint; only handle /v1 suffix, append /beta when /v1 is missing
   if (/\/v1$/.test(baseURL)) return baseURL.replace(/\/v1$/, "/beta")

package/src/provider/google.mjs

@@ -23,11 +23,13 @@ export function normalizeTools(tools) {
  * Gemini: [{ role: "user"|"model", parts: [{ text }] }]
  * system → systemInstruction (top-level in request body)
  */
-function convertMessages(messages) {
+export function convertMessages(messages) {
   const contents = []
   for (const m of messages) {
+    // system messages are hoisted to systemInstruction by the caller — check the
+    // ORIGINAL role (the remapped role below can never be "system")
+    if (m.role === "system") continue
     const role = m.role === "assistant" ? "model" : "user"
-    if (role === "system") continue
 
     const parts = []
     if (typeof m.content === "string") {