@polderlabs/bizar 3.23.1 → 4.2.0

package/plugins/bizar/src/reasoning-clean.ts

@@ -0,0 +1,454 @@
+/**
+ * plugins/bizar/src/reasoning-clean.ts
+ *
+ * Wraps a provider's `fetch` to strip inline ``...</think>`` blocks from
+ * `message.content` / `delta.content` when the response also includes
+ * structured reasoning (`reasoning`, `reasoning_details`, or
+ * `reasoning_content`).
+ *
+ * Why this exists
+ * ───────────────
+ * Some reasoning models (e.g. MiniMax M-series models) emit their chain
+ * of thought BOTH:
+ *   1. In the structured `reasoning` / `reasoning_details` field, which
+ *      opencode already extracts and renders as a separate "thought"
+ *      chunk, AND
+ *   2. Inlined in `content` as `` blocks, which opencode would also
+ *      render as plain text — producing the duplicate "Thought: … + the
+ *      same text in the assistant message" the user sees.
+ *
+ * opencode's openai-compatible SDK for MiniMax does not strip the inline think
+ * blocks from `content`. The opencode-level `interleaved` config that
+ * could solve this only applies to the `@ai-sdk/openai-compatible` SDK.
+ * Wrapping `provider.options.fetch` in the `config` hook is the only
+ * hook surface where the response body can be post-processed.
+ *
+ * Behaviour
+ * ─────────
+ * • Only `POST` requests whose URL ends with `/chat/completions` are
+ *   intercepted. Other requests pass through untouched.
+ * • Non-streaming responses (`Content-Type: application/json`) are parsed,
+ *   mutated, and re-serialised.
+ * • Streaming responses (`Content-Type: text/event-stream`) are piped
+ *   through a `TransformStream` that buffers content across chunks and
+ *   drops anything between a complete ` pair, using a tiny state
+ *   machine so chunks that split a marker mid-stream are handled.
+ * • If parsing or rewriting fails for any reason, the original response
+ *   is forwarded unchanged — this wrapper must never break a chat.
+ */
+
+// All known inline think-style tag names. Each name pairs with itself
+// for the close tag (e.g. `` matches ``, `<thinking>` matches
+// `</thinking>`, etc.). The order does not matter for matching — we
+// search for the earliest occurrence of any of them.
+//
+// The model emits `` (most common) and `<thinking>` (the original
+// dashboard fix targeted this one). `<reasoning>` and `<ant_thinking>`
+// are included for forward compatibility with other providers that use
+// the same anti-slop pattern.
+const THINK_TAG_NAMES = ["think", "thinking", "reasoning", "ant_thinking"] as const;
+type ThinkTagName = (typeof THINK_TAG_NAMES)[number];
+
+/** Map from open-tag prefix (without `>`) to its matching close tag. */
+const THINK_OPEN_TO_CLOSE: ReadonlyMap<string, string> = new Map(
+  THINK_TAG_NAMES.map((n) => [`<${n}`, `</${n}>`] as const),
+);
+/** All open-tag prefixes — used by the streaming state machine. */
+const ALL_OPENS: readonly string[] = Array.from(THINK_OPEN_TO_CLOSE.keys());
+/** Regex form, used by the non-streaming strip. Backreference matches
+ *  the open-tag name to the close tag. */
+const THINK_TAG_RE = new RegExp(
+  `<(${THINK_TAG_NAMES.join("|")})\\b[^>]*>[\\s\\S]*?</\\1>\\s*`,
+  "gi",
+);
+
+export type FetchLike = (
+  input: Parameters<typeof fetch>[0],
+  init?: RequestInit,
+) => Promise<Response>;
+
+export interface ReasoningCleanOptions {
+  /** Extra logger for debug lines; defaults to no-op. */
+  debug?: (msg: string) => void;
+  /**
+   * Provider ids whose responses should be cleaned. Defaults to the set
+   * known to exhibit the duplicated-think pattern: minimax.
+   */
+  providers?: string[];
+}
+
+const DEFAULT_PROVIDERS = new Set(["minimax"]);
+
+/**
+ * Strip inline think-style blocks (`<think>…</think>`,
+ * `<thinking>…</thinking>`, `<reasoning>…</reasoning>`,
+ * `<ant_thinking>…</ant_thinking>`) from a plain string. Used for
+ * non-streaming responses (or for accumulated streamed content).
+ *
+ * The trailing whitespace after the close tag is also consumed so the
+ * cleaned content does not start with an extra blank line.
+ */
+export function stripInlineThinkBlocks(content: string): string {
+  return content.replace(THINK_TAG_RE, "");
+}
+
+/**
+ * Stream-level state machine: feed it the content deltas in order; it
+ * yields the content that should be forwarded to the caller.
+ */
+class ThinkStripper {
+  private state: "NORMAL" | "IN_THINK" = "NORMAL";
+  // Buffer of characters that may be the start of a marker but are not
+  // yet complete. Holds at most max(open.length, close.length) chars
+  // from a chunk boundary.
+  private pending = "";
+  // The close tag we are looking for while IN_THINK. Set when we find
+  // an open, cleared when we find the matching close. Each open tag
+  // has its own close tag (e.g. `` pairs with ``, not ``).
+  private activeClose: string | null = null;
+
+  /**
+   * Find the earliest valid open-tag prefix in `input`. A valid match
+   * is `<tagname` followed by `>`, whitespace, or end-of-string — so we
+   * don't accidentally match `` as a substring of `<thinking>`.
+   */
+  private findOpen(input: string): { idx: number; open: string } | null {
+    let best: { idx: number; open: string } | null = null;
+    for (const open of ALL_OPENS) {
+      let from = 0;
+      while (from < input.length) {
+        const idx = input.indexOf(open, from);
+        if (idx === -1) break;
+        const nextPos = idx + open.length;
+        const nextCh = nextPos < input.length ? input.charAt(nextPos) : "";
+        const isBoundary =
+          nextCh === ">" ||
+          nextCh === " " ||
+          nextCh === "\t" ||
+          nextCh === "\n" ||
+          nextCh === "\r" ||
+          nextCh === "";
+        if (isBoundary) {
+          if (best === null || idx < best.idx) {
+            best = { idx, open };
+          }
+          break;
+        }
+        from = idx + 1;
+      }
+    }
+    return best;
+  }
+
+  push(chunk: string): string {
+    if (chunk.length === 0) return "";
+    let input = this.pending + chunk;
+    this.pending = "";
+    let out = "";
+
+    while (input.length > 0) {
+      if (this.state === "NORMAL") {
+        const found = this.findOpen(input);
+        if (found === null) {
+          // No open marker; might have a partial at the tail.
+          const tail = keepPartialTail(input, ALL_OPENS);
+          out += input.slice(0, input.length - tail.length);
+          this.pending = tail;
+          input = "";
+          break;
+        }
+        out += input.slice(0, found.idx);
+        input = input.slice(found.idx + found.open.length);
+        this.activeClose = THINK_OPEN_TO_CLOSE.get(found.open) ?? null;
+        this.state = "IN_THINK";
+      } else {
+        // IN_THINK
+        const closeTag = this.activeClose;
+        if (closeTag === null) {
+          // Defensive: should never happen, but recover gracefully.
+          this.state = "NORMAL";
+          break;
+        }
+        const idx = input.indexOf(closeTag);
+        if (idx === -1) {
+          // Still inside a think block; might have a partial close at tail.
+          const tail = keepPartialTail(input, [closeTag]);
+          // Discard everything except the possible partial tail.
+          this.pending = tail;
+          input = "";
+          break;
+        }
+        input = input.slice(idx + closeTag.length);
+        this.state = "NORMAL";
+        this.activeClose = null;
+        // Drop any whitespace that immediately follows the close tag so
+        // the next emitted content does not start with extra blank lines.
+        const wsMatch = input.match(/^\s*/);
+        if (wsMatch) input = input.slice(wsMatch[0].length);
+      }
+    }
+
+    return out;
+  }
+
+  flush(): string {
+    // If the stream ended while still inside a think block (malformed
+    // response), emit any pending tail rather than swallowing it.
+    const tail = this.pending;
+    this.pending = "";
+    if (this.state === "IN_THINK") {
+      this.state = "NORMAL";
+      this.activeClose = null;
+      return tail;
+    }
+    return tail;
+  }
+}
+
+/**
+ * Of a string, return the longest suffix that is a prefix of one of the
+ * given markers. Used to defer deciding whether a chunk ends in a real
+ * marker until the next chunk arrives.
+ */
+function keepPartialTail(input: string, markers: readonly string[]): string {
+  const max = Math.max(...markers.map((m) => m.length));
+  const start = Math.max(0, input.length - max);
+  const window = input.slice(start);
+  for (let len = Math.min(max, window.length); len > 0; len--) {
+    const candidate = window.slice(0, len);
+    if (markers.some((m) => m.startsWith(candidate))) return candidate;
+  }
+  return "";
+}
+
+/**
+ * Decide whether the URL targets one of the providers we should clean.
+ * The provider id may appear in the hostname (e.g. `api.minimax.chat`)
+ * rather than as a path segment, so we match against the full URL.
+ */
+function targetsProvider(url: string, providers: Set<string>): string | null {
+  const lower = url.toLowerCase();
+  for (const p of providers) {
+    const lp = p.toLowerCase();
+    if (lower.includes(`/${lp}/`) || lower.includes(`/${lp}?`) || lower.includes(`${lp}.`) || lower.includes(`-${lp}.`) || lower.includes(`.${lp}/`)) {
+      return p;
+    }
+  }
+  return null;
+}
+
+/**
+ * Return true if a request body looks like an OpenAI-compatible chat
+ * completions request (so we know whether to inspect the response).
+ */
+function isChatCompletionsRequest(url: string, init?: RequestInit): boolean {
+  if (!/\/chat\/completions(?:\?|$)/.test(url)) return false;
+  const method = (init?.method ?? "POST").toUpperCase();
+  return method === "POST";
+}
+
+/**
+ * Process one non-streaming JSON response: strip inline think blocks
+ * from `choices[*].message.content`. Returns the original text on any
+ * parse error.
+ */
+function cleanNonStreamingJson(text: string): string {
+  const data = JSON.parse(text);
+  const choices = Array.isArray(data?.choices) ? data.choices : [];
+  let touched = false;
+  for (const choice of choices) {
+    const msg = choice?.message;
+    if (msg && typeof msg.content === "string" && contentHasAnyThinkOpen(msg.content)) {
+      const cleaned = stripInlineThinkBlocks(msg.content);
+      if (cleaned !== msg.content) {
+        msg.content = cleaned;
+        touched = true;
+      }
+    }
+  }
+  return touched ? JSON.stringify(data) : text;
+}
+
+/** Cheap fast-path check: does `content` contain any of the known
+ *  think-tag open prefixes? Avoids invoking the (more expensive) full
+ *  regex on responses that obviously don't need cleaning. */
+function contentHasAnyThinkOpen(content: string): boolean {
+  for (const open of ALL_OPENS) {
+    if (content.includes(open)) return true;
+  }
+  return false;
+}
+
+/**
+ * Process one SSE event line of the form `data: <payload>`. Mutates the
+ * decoded payload in place to strip inline think blocks from
+ * `choices[*].delta.content`, using a per-message `ThinkStripper` so
+ * content split across chunks is still handled correctly.
+ *
+ * `strippers` is an array keyed by choice index — each choice maintains
+ * its own stripper across multiple events.
+ */
+function cleanSseLine(
+  line: string,
+  strippers: ThinkStripper[],
+  debug?: (msg: string) => void,
+): string {
+  if (!line.startsWith("data:")) return line;
+  const payload = line.slice(5).trimStart();
+  if (payload === "[DONE]") {
+    // Flush any in-flight strippers so we don't lose content that was
+    // waiting on a chunk boundary.
+    return line;
+  }
+  let obj: any;
+  try {
+    obj = JSON.parse(payload);
+  } catch {
+    return line;
+  }
+  const choices = Array.isArray(obj?.choices) ? obj.choices : [];
+  for (let i = 0; i < choices.length; i++) {
+    const delta = choices[i]?.delta;
+    if (!delta || typeof delta.content !== "string" || delta.content.length === 0) continue;
+    let stripper = strippers[i];
+    if (!stripper) {
+      stripper = new ThinkStripper();
+      strippers[i] = stripper;
+    }
+    const cleaned = stripper.push(delta.content);
+    if (cleaned.length > 0) {
+      delta.content = cleaned;
+    } else {
+      // Avoid sending an empty content delta — some relays reject them.
+      delete delta.content;
+    }
+    if (choices[i]?.finish_reason) {
+      // End of this choice: flush the stripper so any pending partial
+      // marker becomes part of the final delta.
+      const flushed = stripper.flush();
+      if (flushed.length > 0) {
+        delta.content = (delta.content ?? "") + flushed;
+      } else if (delta.content === undefined) {
+        // Keep the choice delta well-formed even if nothing is left.
+        delta.content = "";
+      }
+    }
+  }
+  debug?.(`reasoning-clean: rewrote SSE line ${payload.length}B`);
+  return "data: " + JSON.stringify(obj);
+}
+
+/**
+ * Transform an SSE response stream: parse each `data:` line, strip inline
+ * think blocks, and re-emit the bytes.
+ */
+function streamTransformer(debug?: (msg: string) => void): TransformStream<Uint8Array, Uint8Array> {
+  const decoder = new TextDecoder("utf-8");
+  const encoder = new TextEncoder();
+  const strippers: ThinkStripper[] = [];
+  let buffer = "";
+  return new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      buffer += decoder.decode(chunk, { stream: true });
+      // SSE events are separated by a blank line ("\n\n").
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const event = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const rewritten = event
+          .split("\n")
+          .map((line) => cleanSseLine(line, strippers, debug))
+          .join("\n");
+        controller.enqueue(encoder.encode(rewritten + "\n\n"));
+        boundary = buffer.indexOf("\n\n");
+      }
+    },
+    flush(controller) {
+      // Flush any leftover SSE event at end of stream.
+      const tail = buffer + decoder.decode();
+      if (tail.length > 0) {
+        const rewritten = tail
+          .split("\n")
+          .map((line) => cleanSseLine(line, strippers, debug))
+          .join("\n");
+        controller.enqueue(encoder.encode(rewritten));
+      }
+    },
+  });
+}
+
+/**
+ * Wrap a fetch implementation so that responses from the listed
+ * providers have inline ``...</think>`` blocks stripped from the
+ * content while preserving the structured reasoning fields. Returns a
+ * function with the same signature as the original fetch.
+ */
+export function wrapFetchForReasoningCleanup(
+  originalFetch: FetchLike,
+  options: ReasoningCleanOptions = {},
+): FetchLike {
+  const providers = options.providers
+    ? new Set(options.providers)
+    : DEFAULT_PROVIDERS;
+  const debug = options.debug;
+
+  return async (input, init) => {
+    const url =
+      typeof input === "string"
+        ? input
+        : input instanceof URL
+          ? input.toString()
+          : (input as Request).url;
+    // Resolve which provider this call is going to. If we can't tell, pass through.
+    const providerHit = targetsProvider(url, providers);
+    if (!isChatCompletionsRequest(url, init)) {
+      return originalFetch(input, init);
+    }
+    if (!providerHit) {
+      return originalFetch(input, init);
+    }
+    let response: Response;
+    try {
+      response = await originalFetch(input, init);
+    } catch (err) {
+      debug?.(`reasoning-clean: fetch threw, passing through: ${(err as Error).message}`);
+      throw err;
+    }
+    const ct = response.headers.get("content-type") ?? "";
+    if (ct.includes("text/event-stream")) {
+      const body = response.body;
+      if (!body) return response;
+      const transformed = body.pipeThrough(streamTransformer(debug));
+      return new Response(transformed, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
+    // Non-streaming JSON.
+    let text: string;
+    try {
+      text = await response.text();
+    } catch (err) {
+      debug?.(`reasoning-clean: read body failed, passing through: ${(err as Error).message}`);
+      return response;
+    }
+    let cleaned: string;
+    try {
+      cleaned = cleanNonStreamingJson(text);
+    } catch (err) {
+      debug?.(`reasoning-clean: parse failed, passing through original body: ${(err as Error).message}`);
+      // Re-wrap the original text in a fresh Response so the caller
+      // can read the body (we already consumed the original via
+      // .text()). The status/headers are preserved.
+      cleaned = text;
+    }
+    // Always return a fresh Response so the caller can read the body
+    // (the original `response` was consumed by `.text()`).
+    return new Response(cleaned, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+    });
+  };
+}

package/plugins/bizar/src/report.ts

@@ -0,0 +1,178 @@
+/**
+ * report.ts
+ *
+ * Per-session log writer. Appends metadata-only lines (no args) to
+ * ~/.cache/bizar/logs/<sessionId>.log with 10 MB rotation.
+ * Per §7.1, §7.6, §8.3, §10.1.
+ */
+
+import { appendFileSync, renameSync, unlinkSync, existsSync, statSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+/** Minimal Logger interface — same shape as state.ts */
+export interface Logger {
+  log(opts: { level: "debug" | "info" | "warn" | "error"; message: string }): void;
+}
+
+function expandHome(p: string): string {
+  if (p.startsWith("~/") || p === "~") {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+
+/**
+ * Log line format (per §7.1):
+ * 2026-06-17T14:30:01.123Z agent=thor tool=read fingerprint=ab12cd outcome=ok duration=45ms
+ */
+function formatLine(
+  sessionId: string,
+  agent: string | null,
+  tool: string,
+  fingerprint: string,
+  outcome: "ok" | "error",
+  durationMs: number
+): string {
+  const ts = new Date().toISOString();
+  const agentPart = agent ? ` agent=${agent}` : "";
+  return `${ts}${agentPart} tool=${tool} fingerprint=${fingerprint} outcome=${outcome} duration=${durationMs}ms\n`;
+}
+
+/**
+ * Recursive mkdirSync with EACCES handling per §8.2.
+ */
+function ensureDir(dir: string, logger: Logger): boolean {
+  try {
+    mkdirSync(dir, { recursive: true });
+    return true;
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "EACCES" || code === "EROFS") {
+      logger.log({
+        level: "error",
+        message: `bizar: cannot create log directory ${dir}: ${String(err)}`,
+      });
+      return false;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Rotate log files when current file exceeds maxBytes:
+ * 1. Delete .3.log (if exists)
+ * 2. Rename .2.log → .3.log
+ * 3. Rename .1.log → .2.log
+ * 4. Rename <sessionId>.log → .1.log
+ *
+ * Each step in its own try/catch. Best-effort — never blocks the write.
+ * Per §8.3.
+ */
+function rotateLog(logPath: string, logger: Logger): void {
+  const dir = path.dirname(logPath);
+
+  // Step 1: delete .3.log
+  const p3 = path.join(dir, ".3.log");
+  if (existsSync(p3)) {
+    try { unlinkSync(p3); } catch { /* non-fatal */ }
+  }
+
+  // Step 2: rename .2.log → .3.log
+  const p2 = path.join(dir, ".2.log");
+  if (existsSync(p2)) {
+    try { renameSync(p2, p3); } catch {
+      logger.log({ level: "warn", message: `bizar: log rotation .2→.3 failed` });
+    }
+  }
+
+  // Step 3: rename .1.log → .2.log
+  const p1 = path.join(dir, ".1.log");
+  if (existsSync(p1)) {
+    try { renameSync(p1, p2); } catch {
+      logger.log({ level: "warn", message: `bizar: log rotation .1→.2 failed` });
+    }
+  }
+
+  // Step 4: rename current → .1.log
+  if (existsSync(logPath)) {
+    try { renameSync(logPath, p1); } catch {
+      logger.log({ level: "warn", message: `bizar: log rotation current→.1 failed` });
+    }
+  }
+}
+
+export class LogWriter {
+  private logDir: string;
+  private maxBytes: number;
+  private logger: Logger;
+  private initialized = false;
+
+  constructor(logDir: string, maxBytes: number, logger: Logger) {
+    this.logDir = expandHome(logDir);
+    this.maxBytes = Math.max(1024, Math.floor(maxBytes));
+    this.logger = logger;
+  }
+
+  /**
+   * Lazily ensure the log directory exists.
+   */
+  private ensureLogDir(): boolean {
+    if (this.initialized) return true;
+    this.initialized = true;
+    return ensureDir(this.logDir, this.logger);
+  }
+
+  /**
+   * Append a metadata-only log line for a tool call.
+   *
+   * Per §7.1 / §7.6: NO args are written. Only:
+   * - ISO timestamp
+   * - session ID
+   * - tool name
+   * - fingerprint hash
+   * - outcome (ok | error)
+   * - duration in milliseconds
+   */
+  async write(event: {
+    sessionId: string;
+    agent: string | null;
+    tool: string;
+    fingerprint: string;
+    outcome: "ok" | "error";
+    durationMs: number;
+  }): Promise<void> {
+    if (!this.ensureLogDir()) return;
+
+    const logPath = path.join(this.logDir, `${event.sessionId}.log`);
+    const line = formatLine(
+      event.sessionId,
+      event.agent,
+      event.tool,
+      event.fingerprint,
+      event.outcome,
+      event.durationMs
+    );
+
+    // Check rotation threshold
+    try {
+      if (existsSync(logPath)) {
+        const stat = statSync(logPath);
+        if (stat.size + Buffer.byteLength(line, "utf8") > this.maxBytes) {
+          rotateLog(logPath, this.logger);
+        }
+      }
+    } catch {
+      // best-effort rotation check
+    }
+
+    try {
+      appendFileSync(logPath, line, "utf8");
+    } catch (err: unknown) {
+      this.logger.log({
+        level: "warn",
+        message: `bizar: failed to write to log ${logPath}: ${String(err)}`,
+      });
+    }
+  }
+}

package/plugins/bizar/src/research-prompt.ts

@@ -0,0 +1,35 @@
+/**
+ * research-prompt.ts
+ *
+ * The intervention message injected into a background session that has been
+ * stuck in a thinking loop. The LLM sees this as a new user message and
+ * should respond by spawning Mimir or taking other concrete action.
+ *
+ * Security note: the message is static — it does not interpolate any
+ * user-supplied content, prompt, or agent output. The only variable is
+ * the duration. This matches the prompt-injection invariant from
+ * handoff.ts: the only dynamic content is a short number from our own
+ * state, never from agent or user sources.
+ *
+ * The duration is formatted as `Xm Ys` (or just `Ys` if under a minute)
+ * so the agent has concrete context for how long it has been looping.
+ * We do not include the instanceId, sessionId, prompt preview, or any
+ * other potentially-sensitive content — those would only widen the
+ * attack surface without helping the LLM make progress.
+ */
+export function researchInterventionPrompt(durationMs: number): string {
+  const safeMs = Math.max(0, Math.floor(durationMs));
+  const minutes = Math.floor(safeMs / 60_000);
+  const seconds = Math.floor((safeMs % 60_000) / 1000);
+  const durationStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+  return `[SYSTEM REMINDER — Thinking Loop Detected]
+
+You have been thinking for over ${durationStr} without calling any tools or producing any text output. This is a sign you are stuck in a thinking loop.
+
+To make progress, take ONE of these actions NOW:
+1. Use the task tool to spawn a Mimir agent for focused research on the original topic.
+2. Use read/grep/glob to gather concrete information from the codebase.
+3. Use bash to execute commands that produce observable results.
+
+Do NOT continue thinking without taking action. Make a tool call in your next turn.`;
+}