@polderlabs/bizar 6.2.4 → 6.3.0

package/plugins/bizar/src/cline-runner.ts

@@ -1,203 +0,0 @@
-/**
- * plugins/bizar/src/cline-runner.ts
- *
- * v5.5.1 — DEAD CODE stub.
- *
- * Background agents no longer run as `cline run` subprocesses. They
- * run as long-lived cline serve SDK sessions, managed by the
- * Bizar dashboard (`bizar-dash/src/server/bg-spawner.mjs`). The plugin
- * delegates to the dashboard via HTTP (`bg-spawn.ts`,
- * `bg-send-message.ts`, …) instead of spawning anything directly.
- *
- * This module is kept as a stub for two reasons:
- *
- *   1. `buildClineRunArgs` and the `SpawnAgentOptions` type are
- *      still imported by `plugins/bizar/tests/tools/cline-runner.test.ts`
- *      and serve as a regression pin for the argv layout that USED to
- *      be passed to `Bun.spawn`. The test suite stays green because
- *      the pure helpers are unchanged.
- *
- *   2. A handful of function names (`isAlive`, `killAgent`, …) are
- *      imported elsewhere (`background.ts`) as a future-proofing hook.
- *      We replace the implementations with no-op / error stubs so any
- *      leftover call gets a clear, deliberate response instead of
- *      silently succeeding.
- *
- * If something imports `spawnAgent`, it now gets back `{ ok: false,
- * error: "spawnAgent removed in v5.5.1" }`. This forces callers to the
- * dashboard path; nothing in the plugin should be calling this anymore.
- */
-import type { Subprocess } from "bun";
-
-export type AgentState =
-  | "starting"
-  | "running"
-  | "paused"
-  | "done"
-  | "failed"
-  | "killed";
-
-export interface AgentStatus {
-  state: AgentState;
-  sessionId?: string;
-  processId: number;
-  startedAt: number;
-  endedAt?: number;
-  exitCode?: number;
-  error?: string;
-}
-
-export interface SpawnAgentOptions {
-  /** The prompt to send. */
-  prompt: string;
-  /** Agent name (mimir, thor, …) — used as the session title prefix. */
-  agent: string;
-  /** Optional model override in "providerID/modelID" format. */
-  model?: { providerID: string; modelID: string };
-  /** Working directory for the cline run. */
-  worktree: string;
-  /** Absolute path to the log file (the LogWriter's output path). */
-  logPath: string;
-  /** Optional session title (defaults to `bgr:<agent>`). */
-  title?: string;
-  /** Extra env vars to pass through. */
-  env?: Record<string, string>;
-  /** How long to wait for the sessionId to appear in stderr (ms). */
-  sessionIdTimeoutMs?: number;
-}
-
-export interface SpawnAgentResult {
-  ok: boolean;
-  sessionId?: string;
-  processId?: number;
-  error?: string;
-}
-
-type ExitCallback = (status: AgentStatus) => void;
-
-/**
- * v5.5.1 — Pure helper, UNCHANGED. Kept around so the regression test
- * that pins the argv layout still passes. (The argv used to be passed
- * to `Bun.spawn`; v5.5.1 no longer spawns anything, but the wire format
- * is a useful reference and may be reused if we ever revive subprocess
- * mode.)
- *
- * @param opts
- * @returns argv that USED to be passed to `Bun.spawn(["cline", "run", …])`
- */
-export function buildClineRunArgs(opts: SpawnAgentOptions): string[] {
-  if (!opts.agent) {
-    throw new Error("bizar_spawn_background: agent is required");
-  }
-  const args: string[] = [
-    "cline",
-    "run",
-    "--dir", opts.worktree,
-    "--print-logs",
-    "--log-level", "INFO",
-    "--title", opts.title || `bgr:${opts.agent}:${Date.now()}`,
-    "--agent", opts.agent,
-  ];
-  if (opts.model) {
-    args.push("--model", `${opts.model.providerID}/${opts.model.modelID}`);
-  }
-  args.push("--", opts.prompt);
-  return args;
-}
-
-/**
- * v5.5.1 — STUB. Background agents run on the cline serve SDK,
- * not as `cline run` subprocesses. Returns an error directing the
- * caller to the dashboard HTTP API.
- *
- * The plugin's `bg-spawn.ts` no longer calls this; it's kept for any
- * late caller we missed.
- */
-export async function spawnAgent(_opts: SpawnAgentOptions): Promise<SpawnAgentResult> {
-  return {
-    ok: false,
-    error:
-      "spawnAgent removed in v5.5.1 — bg agents now run as cline serve sessions " +
-      "managed by the Bizar dashboard. POST /api/background instead. " +
-      "See plugins/bizar/src/tools/bg-spawn.ts.",
-  };
-}
-
-/**
- * v5.5.1 — STUB. Returns null because there is no in-process subprocess
- * registry to look up.
- */
-export function getStatus(_processId: number): AgentStatus | null {
-  return null;
-}
-
-/**
- * v5.5.1 — STUB. The real exit subscription lives on the dashboard side.
- * Returns a no-op unsubscribe.
- */
-export function onExit(_processId: number, _cb: ExitCallback): () => void {
-  return () => undefined;
-}
-
-/**
- * v5.5.1 — STUB. Kill is now a dashboard-side operation
- * (`sdk.sessions.abort`). The plugin's `bg-kill.ts` posts to the
- * dashboard HTTP API; this function is here only as a fallback that
- * always reports "no such process tracked" so the dashboard's view of
- * the world is the source of truth.
- */
-export function killAgent(
-  _processId: number,
-  _signal: "SIGTERM" | "SIGKILL" = "SIGTERM",
-): { ok: boolean; error?: string } {
-  return { ok: true, error: "no_such_process_tracked_v5_5_1_use_dashboard_delete" };
-}
-
-/**
- * v5.5.1 — STUB. Pause is an output-pause at the dashboard side now.
- * The plugin's `bg-pause.ts` posts to the dashboard; this stub returns
- * `unsupported` so a leftover caller gets a clear signal.
- */
-export function pauseAgent(_processId: number): { ok: boolean; error?: string } {
-  return { ok: false, error: "pause_via_dashboard_v5_5_1" };
-}
-
-/**
- * v5.5.1 — STUB. Same as `pauseAgent` — dashboard-side only.
- */
-export function resumeAgent(_processId: number): { ok: boolean; error?: string } {
-  return { ok: false, error: "resume_via_dashboard_v5_5_1" };
-}
-
-/**
- * v5.5.1 — STUB. Returns false because there is no in-process PID
- * registry. Liveness is owned by the dashboard; the plugin's state
- * reconciliation code already uses this as a probe and falls back to
- * "fail closed" when the answer is false.
- */
-export function isAlive(processId: number): boolean {
-  if (!Number.isFinite(processId) || processId <= 0) return false;
-  return false;
-}
-
-/**
- * v5.5.1 — STUB. Returns an empty list — the runner registry is gone.
- */
-export function list(): AgentStatus[] {
-  return [];
-}
-
-/**
- * v5.5.1 — STUB. Clears nothing (the registry is empty). Kept for the
- * test suite that imports it.
- */
-export function _resetForTests(): void {
-  // no-op — the in-memory registry was removed.
-}
-
-/**
- * v5.5.1 — STUB. Returns an empty record because no agent is tracked
- * here. Provided so the module typechecks in callers that still reach
- * for a status record shape.
- */
-export type { Subprocess };

package/plugins/bizar/src/clineruntime.ts

@@ -1,227 +0,0 @@
-/**
- * clineruntime.ts
- *
- * v6.0.0 — In-process ClineCore wrapper. Replaces the old ServeLifecycle
- * (subprocess spawn), HttpClient (HTTP), and EventStream (SSE) with a
- * single object that talks to ClineCore via direct function calls.
- *
- * Cline runs in-process now: there is no `cline serve` child, no port,
- * no password, no serve-info file. The plugin embeds ClineCore and uses
- * it directly.
- *
- * v6.0.1 — `startSession` accepts `execution` (passed straight into
- * Cline's `AgentExecutionConfig`) and an
- * `onConsecutiveMistakeLimitReached` recovery callback. The harness
- * also defaults `execution.maxConsecutiveMistakes` so the bundled CLI's
- * tight 3-strike abort does not kill sessions on the first malformed
- * tool call.
- *
- * Public surface:
- *   - start()              — boot ClineCore (idempotent)
- *   - startSession(opts)   — create a session; returns sessionId
- *   - send(opts)           — mid-flight prompt
- *   - abort(opts)          — abort a session
- *   - subscribe(opts, cb)  — events for a session; returns unsubscribe
- *   - stop()               — teardown
- */
-
-import type { ClineCore, CoreSessionEvent } from "@cline/core";
-import type {
-  ConsecutiveMistakeLimitContext,
-  ConsecutiveMistakeLimitDecision,
-} from "@cline/shared";
-import type { Logger } from "./logger.js";
-
-type ClineCoreLike = Pick<ClineCore, "start" | "send" | "abort" | "stop" | "subscribe" | "dispose">;
-
-export interface ClineRuntimeOptions {
-  logger: Logger;
-  clientName?: string;
-  backendMode?: "auto" | "local" | "hub" | "remote";
-  /**
-   * Default `execution.maxConsecutiveMistakes` applied to every session
-   * started by this runtime. Picked up from the plugin's normalized
-   * options (see `options.ts`). Per-session overrides via
-   * `StartSessionOpts.execution.maxConsecutiveMistakes` win.
-   */
-  defaultMaxConsecutiveMistakes?: number;
-  /**
-   * Recovery callback used for every session started by this runtime.
-   * Built once at construction time (it is stateless) and applied
-   * unless the caller overrides via
-   * `StartSessionOpts.onConsecutiveMistakeLimitReached`. The harness
-   * passes `buildMistakeRecovery({ onRecovery })` from
-   * `mistake-recovery.ts` here so a single malformed tool call does
-   * not abort the session.
-   */
-  defaultOnConsecutiveMistakeLimitReached?: (
-    ctx: ConsecutiveMistakeLimitContext,
-  ) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
-}
-
-export interface StartSessionOpts {
-  sessionId?: string;
-  providerId: string;
-  modelId: string;
-  apiKey?: string;
-  baseUrl?: string;
-  workspaceRoot: string;
-  systemPrompt?: string;
-  prompt: string;
-  sessionMetadata?: Record<string, unknown>;
-  source?: string;
-  /**
-   * Forwarded to ClineCore as `config.execution`. If supplied, the
-   * runtime overrides `execution.maxConsecutiveMistakes` with
-   * `runtime.defaultMaxConsecutiveMistakes` *only* when the caller
-   * didn't set it explicitly. Other fields (`reminderAfterIterations`,
-   * `reminderText`, `loopDetection`) pass through as-is.
-   */
-  execution?: {
-    maxConsecutiveMistakes?: number;
-    reminderAfterIterations?: number;
-    reminderText?: string;
-    loopDetection?:
-      | false
-      | { softThreshold?: number; hardThreshold?: number };
-  };
-  /**
-   * Forwarded to ClineCore as `config.onConsecutiveMistakeLimitReached`.
-   * Used by `mistake-recovery.ts` to keep the session alive on
-   * recoverable mistakes (`invalid_tool_call`, `tool_execution_failed`)
-   * and stop on infra failures (`api_error`).
-   */
-  onConsecutiveMistakeLimitReached?: (
-    ctx: ConsecutiveMistakeLimitContext,
-  ) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
-}
-
-export interface SendOpts { sessionId: string; prompt: string; }
-export interface AbortOpts { sessionId: string; reason?: string; }
-export interface SubscribeOpts { sessionId: string; }
-
-export type SessionEventHandler = (event: CoreSessionEvent) => void;
-export type UnsubscribeFn = () => void;
-
-export class ClineRuntime {
-  private readonly logger: Logger;
-  private readonly clientName: string;
-  private readonly backendMode: "auto" | "local" | "hub" | "remote";
-  private readonly defaultMaxConsecutiveMistakes?: number;
-  private readonly defaultOnConsecutiveMistakeLimitReached?: (
-    ctx: ConsecutiveMistakeLimitContext,
-  ) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
-  private core: ClineCoreLike | null = null;
-  private startingPromise: Promise<ClineCoreLike> | null = null;
-
-  constructor(opts: ClineRuntimeOptions) {
-    this.logger = opts.logger;
-    this.clientName = opts.clientName ?? "bizar-plugin";
-    this.backendMode = opts.backendMode ?? "local";
-    if (typeof opts.defaultMaxConsecutiveMistakes === "number" && Number.isFinite(opts.defaultMaxConsecutiveMistakes)) {
-      this.defaultMaxConsecutiveMistakes = Math.max(3, Math.floor(opts.defaultMaxConsecutiveMistakes));
-    }
-    if (typeof opts.defaultOnConsecutiveMistakeLimitReached === "function") {
-      this.defaultOnConsecutiveMistakeLimitReached = opts.defaultOnConsecutiveMistakeLimitReached;
-    }
-  }
-
-  async start(): Promise<void> {
-    if (this.core) return;
-    if (this.startingPromise) { await this.startingPromise; return; }
-    this.startingPromise = (async () => {
-      const cline = await import("@cline/core");
-      const core = await cline.ClineCore.create({ clientName: this.clientName, backendMode: this.backendMode });
-      this.core = core;
-      this.logger.info(`bizar: ClineCore ready (clientName=${this.clientName}, backend=${this.backendMode})`);
-      return core;
-    })();
-    try { await this.startingPromise; } finally { this.startingPromise = null; }
-  }
-
-  private async ensure(): Promise<ClineCoreLike> {
-    if (this.core) return this.core;
-    await this.start();
-    if (!this.core) throw new Error("clineruntime: ClineCore failed to start");
-    return this.core;
-  }
-
-  async startSession(opts: StartSessionOpts): Promise<string> {
-    const core = await this.ensure();
-    const execution = this.buildExecution(opts.execution);
-    const recovery = opts.onConsecutiveMistakeLimitReached
-      ?? this.defaultOnConsecutiveMistakeLimitReached;
-    const config: Parameters<ClineCore["start"]>[0]["config"] = {
-      providerId: opts.providerId,
-      modelId: opts.modelId,
-      apiKey: opts.apiKey,
-      baseUrl: opts.baseUrl,
-      systemPrompt: opts.systemPrompt ?? "",
-      workspaceRoot: opts.workspaceRoot,
-      cwd: opts.workspaceRoot,
-      enableTools: true,
-      enableSpawnAgent: true,
-      enableAgentTeams: true,
-      ...(execution ? { execution } : {}),
-      ...(recovery ? { onConsecutiveMistakeLimitReached: recovery } : {}),
-    };
-    const started = await core.start({
-      config: config as Parameters<ClineCore["start"]>[0]["config"],
-      prompt: opts.prompt,
-      source: opts.source,
-      sessionMetadata: opts.sessionMetadata,
-      ...(opts.sessionId ? { sessionId: opts.sessionId } : {}),
-    });
-    return started.sessionId;
-  }
-
-  /**
-   * Merge caller's `execution` block with the runtime default
-   * (`defaultMaxConsecutiveMistakes`).
-   *
-   * v6.2.4 — Plugin's defaultMaxConsecutiveMistakes is now a FLOOR,
-   * not a default. The Cline CLI's `--retries` flag defaults to 3
-   * and previously silently overrode our 6 (or higher) — leading
-   * to premature session aborts after just 3 tool errors. Now we
-   * use Math.max(plugin_default, caller_value) so the user can
-   * still raise the limit with `--retries 15`, but the plugin's
-   * higher default is honored on plain `cline` invocations.
-   *
-   * Returns `undefined` when neither is set, so the optional field
-   * stays out of the config payload.
-   */
-  private buildExecution(
-    callerExecution: StartSessionOpts["execution"],
-  ): StartSessionOpts["execution"] | undefined {
-    if (!callerExecution && this.defaultMaxConsecutiveMistakes === undefined) return undefined;
-    const callerMax = callerExecution?.maxConsecutiveMistakes;
-    const pluginMax = this.defaultMaxConsecutiveMistakes;
-    const max =
-      callerMax !== undefined && pluginMax !== undefined
-        ? Math.max(callerMax, pluginMax)
-        : callerMax ?? pluginMax;
-    return { ...callerExecution, ...(max !== undefined ? { maxConsecutiveMistakes: max } : {}) };
-  }
-
-  async send(opts: SendOpts): Promise<void> {
-    const core = await this.ensure();
-    await (core.send as unknown as (input: { sessionId: string; prompt: string }) => Promise<unknown>)({ sessionId: opts.sessionId, prompt: opts.prompt });
-  }
-
-  async abort(opts: AbortOpts): Promise<void> {
-    const core = await this.ensure();
-    await core.abort(opts.sessionId, opts.reason);
-  }
-
-  subscribe(opts: SubscribeOpts, handler: SessionEventHandler): UnsubscribeFn {
-    if (!this.core) throw new Error("clineruntime: subscribe() called before start()");
-    return (this.core.subscribe as (l: SessionEventHandler, o?: SubscribeOpts) => UnsubscribeFn)(handler, opts);
-  }
-
-  async stop(): Promise<void> {
-    if (!this.core) return;
-    try { await this.core.dispose(); }
-    catch (err) { this.logger.warn(`bizar: ClineCore.dispose failed: ${err instanceof Error ? err.message : String(err)}`); }
-    this.core = null;
-  }
-}

package/plugins/bizar/src/commands-impl.ts

@@ -1,151 +0,0 @@
-/**
- * commands-impl.ts
- *
- * v0.5.0 — Side-effect executor for slash commands.
- *
- * Phase 2 (Cline SDK port) — replaces OpenCode's ToolContext and
- * ToolDefinition with Cline's AgentToolContext and AgentTool.
- *
- * The `commands.ts` module is a pure parser: given a user message, it
- * returns a `SlashCommandResult` describing what the chat hook should
- * do. This module implements the "do" half:
- *
- *   - `executeSideEffect`      — dispatches `create_plan`,
- *     `list_plans`, `open_plan_url`, and `tool_invocation` to the
- *     right handler.
- *   - `executeToolInvocation`  — builds a synthetic `AgentToolContext`,
- *     pre-validates args against the tool's Zod schema, and invokes
- *     the tool's `execute()` directly.
- *   - `buildSyntheticToolContext` — constructs the `AgentToolContext`
- *     shape Cline's tool framework requires.
- *   - `validateToolArgs`       — wraps the tool's inputSchema into
- *     a `z.object(...)` and runs `safeParse`.
- */
-
-import { z } from "zod";
-import type { AgentTool, AgentToolContext } from "@cline/sdk";
-
-import type { Logger } from "./logger.js";
-import type { DefaultTemplate } from "./settings.js";
-import type { SideEffect } from "./commands.js";
-import { createPlan as fsCreatePlan, listPlans as fsListPlans } from "./plan-fs.js";
-
-export interface ExecutorContext {
-  worktree: string;
-  directory: string;
-  logger: Logger;
-}
-
-export interface ExecuteOptions {
-  tools: Record<string, AgentTool>;
-  defaultTemplate: DefaultTemplate;
-  defaultPort: number;
-}
-
-export interface ExecuteResult {
-  responseOverride?: string;
-  responseSuffix?: string;
-}
-
-export async function executeSideEffect(sideEffect: SideEffect, ctx: ExecutorContext, opts: ExecuteOptions): Promise<ExecuteResult> {
-  try {
-    switch (sideEffect.kind) {
-      case "create_plan": return await executeCreatePlan(sideEffect, ctx, opts);
-      case "list_plans": return await executeListPlans(sideEffect, ctx, opts);
-      case "open_plan_url": return await executeOpenPlanUrl(sideEffect, ctx, opts);
-      case "launch_dashboard": return await executeLaunchDashboard(sideEffect, ctx, opts);
-      case "tool_invocation": return await executeToolInvocation(sideEffect, ctx, opts);
-      default: {
-        const _exhaustive: never = sideEffect;
-        return { responseOverride: `Unknown side-effect: ${String(_exhaustive)}` };
-      }
-    }
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    ctx.logger.warn(`bizar: executeSideEffect crashed: ${msg}`);
-    return { responseOverride: `Command failed: ${msg}` };
-  }
-}
-
-async function executeCreatePlan(sideEffect: Extract<SideEffect, { kind: "create_plan" }>, ctx: ExecutorContext, opts: ExecuteOptions): Promise<ExecuteResult> {
-  const template = sideEffect.template ?? opts.defaultTemplate;
-  try {
-    const result = await fsCreatePlan(ctx.worktree, sideEffect.slug, { template, logger: ctx.logger });
-    if (!result.ok) return { responseOverride: `Failed to create plan: ${result.error}` };
-    return { responseOverride: `Created plan "${sideEffect.slug}" using the "${template}" template.` };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { responseOverride: `Failed to create plan: ${msg}` };
-  }
-}
-
-async function executeListPlans(_sideEffect: Extract<SideEffect, { kind: "list_plans" }>, ctx: ExecutorContext, _opts: ExecuteOptions): Promise<ExecuteResult> {
-  try {
-    const plans = await fsListPlans(ctx.worktree, ctx.logger);
-    if (plans.length === 0) return { responseOverride: "No plans found. Use /plan create <slug> to start one." };
-    const lines = plans.map((p) => `- ${p.slug} [${p.status ?? "draft"}] — ${p.slug}`);
-    return { responseOverride: `Plans (${plans.length}):\n${lines.join("\n")}` };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { responseOverride: `Failed to list plans: ${msg}` };
-  }
-}
-
-async function executeLaunchDashboard(sideEffect: Extract<SideEffect, { kind: "launch_dashboard" }>, _ctx: ExecutorContext, _opts: ExecuteOptions): Promise<ExecuteResult> {
-  return { responseOverride: `Launch dashboard at http://127.0.0.1:${sideEffect.defaultPort}/` };
-}
-
-async function executeOpenPlanUrl(sideEffect: Extract<SideEffect, { kind: "open_plan_url" }>, _ctx: ExecutorContext, opts: ExecuteOptions): Promise<ExecuteResult> {
-  return { responseOverride: `Open plan: http://127.0.0.1:${opts.defaultPort}/plans/${sideEffect.slug}` };
-}
-
-export async function executeToolInvocation(sideEffect: Extract<SideEffect, { kind: "tool_invocation" }>, ctx: ExecutorContext, opts: ExecuteOptions): Promise<ExecuteResult> {
-  const { toolName, args } = sideEffect;
-  const tool = opts.tools[toolName];
-  if (tool === undefined) {
-    const known = Object.keys(opts.tools).sort().join(", ");
-    return { responseOverride: `Tool "${toolName}" is not registered in this plugin. Available tools: ${known || "(none)"}.` };
-  }
-  const validation = validateToolArgs(tool, args);
-  if (!validation.ok) return { responseOverride: `Invalid arguments for ${toolName}: ${validation.error}` };
-  const syntheticCtx = buildSyntheticToolContext(ctx);
-  try {
-    const result = await tool.execute(validation.args, syntheticCtx);
-    return { responseOverride: stringifyToolResult(result) };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    ctx.logger.warn(`bizar: tool ${toolName} crashed: ${msg}`);
-    return { responseOverride: `Tool ${toolName} failed: ${msg}` };
-  }
-}
-
-export function buildSyntheticToolContext(ctx: ExecutorContext): AgentToolContext {
-  return { agentId: "slash-command", sessionId: "slash-command", runId: `slash-command-${Date.now()}`, iteration: 0, signal: new AbortController().signal, metadata: { worktree: ctx.worktree, directory: ctx.directory, parentAgent: "" } } as unknown as AgentToolContext;
-}
-
-export function validateToolArgs(tool: AgentTool, args: unknown): { ok: true; args: Record<string, unknown> } | { ok: false; error: string } {
-  try {
-    const rawShape = (tool.inputSchema ?? {}) as z.ZodRawShape;
-    const schema = z.object(rawShape);
-    const result = schema.safeParse(args);
-    if (result.success) return { ok: true, args: result.data as Record<string, unknown> };
-    const first = result.error.issues[0];
-    const where = first?.path && first.path.length > 0 ? first.path.join(".") : "(root)";
-    return { ok: false, error: `${where}: ${first?.message ?? "validation failed"}` };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: `schema error: ${msg}` };
-  }
-}
-
-function stringifyToolResult(result: unknown): string {
-  if (typeof result === "string") return result;
-  if (result === null || result === undefined) return "";
-  const r = result as { output?: unknown };
-  if (r && typeof r === "object" && "output" in r) {
-    if (typeof r.output === "string") return r.output;
-    try { return JSON.stringify(r.output, null, 2); } catch { return String(r.output); }
-  }
-  if (typeof result === "object") { try { return JSON.stringify(result, null, 2); } catch { return String(result); } }
-  return String(result);
-}