muonroi-cli 1.7.2 → 1.8.0

package/dist/src/orchestrator/delegations.js

@@ -107,6 +107,47 @@ export class DelegationManager {
             return `Delegation "${id}" completed, but its saved output could not be read.`;
         }
     }
+    async kill(id) {
+        const record = await this.getById(id);
+        if (!record) {
+            return {
+                success: false,
+                output: `Delegation "${id}" not found.`,
+            };
+        }
+        if (record.status !== "running") {
+            return {
+                success: false,
+                output: `Delegation "${id}" is not running (status: ${record.status}).`,
+            };
+        }
+        const pid = record.pid;
+        if (!pid) {
+            const jobPath = path.join(await ensureDelegationsDir(this.getCwd()), `${id}.json`);
+            await failDelegation(jobPath, "Cancelled: Process PID was not recorded.");
+            return {
+                success: true,
+                output: `Delegation "${id}" marked as cancelled (no active process ID was found).`,
+            };
+        }
+        try {
+            if (process.platform === "win32") {
+                spawn("taskkill", ["/F", "/T", "/PID", pid.toString()]).unref();
+            }
+            else {
+                process.kill(pid, "SIGTERM");
+            }
+        }
+        catch (err) {
+            // ignore
+        }
+        const jobPath = path.join(await ensureDelegationsDir(this.getCwd()), `${id}.json`);
+        await failDelegation(jobPath, "Cancelled by user.");
+        return {
+            success: true,
+            output: `Delegation "${id}" (PID: ${pid}) has been terminated.`,
+        };
+    }
     async consumeNotifications() {
         const dir = await ensureDelegationsDir(this.getCwd());
         const files = await readDelegationFiles(dir);

package/dist/src/orchestrator/error-utils.js

@@ -67,10 +67,24 @@ function humanizeApiErrorBase(error) {
     }
     if (APICallError.isInstance(error)) {
         const detail = extractResponseDetail(error.responseBody);
+        const status = error.statusCode;
+        // 5xx response bodies are usually generic server-side noise that MASKS the
+        // actionable status. Verified live: SiliconFlow returns a 500 with body
+        // {code:60000,message:"Request failed: Unknown error."} — surfacing that
+        // string told the user nothing and hid the fact it was a retryable 500.
+        // For 5xx prefer the canned "retry later" message + the status code; keep a
+        // body detail only when it actually adds information.
+        if (status && status >= 500) {
+            const canned = STATUS_MESSAGES[status] ?? "The API server returned an error. Please try again later.";
+            if (!detail || isOpaqueDetail(detail))
+                return `${canned} (HTTP ${status})`;
+            return `${detail} (HTTP ${status})`;
+        }
+        // 4xx: the body almost always says WHAT was wrong — keep it verbatim.
         if (detail)
             return detail;
-        if (error.statusCode && STATUS_MESSAGES[error.statusCode]) {
-            return STATUS_MESSAGES[error.statusCode];
+        if (status && STATUS_MESSAGES[status]) {
+            return STATUS_MESSAGES[status];
         }
     }
     const raw = error instanceof Error ? error.message : String(error);
@@ -99,6 +113,17 @@ function extractResponseDetail(body) {
     }
     return null;
 }
+/**
+ * A provider "detail" string that carries no diagnostic value — generic
+ * server-error phrasing that masks the more useful HTTP status. Verified live:
+ * SiliconFlow 500s carry message "Request failed: Unknown error.". Used only on
+ * the 5xx path so an informative server message is still preferred when present.
+ */
+function isOpaqueDetail(detail) {
+    const s = detail.trim().toLowerCase();
+    return (s.length < 4 ||
+        /unknown error|request failed|internal server error|service (unavailable|temporarily)|bad gateway|gateway time-?out|^error\.?$|^failed\.?$/.test(s));
+}
 const RESPONSE_BODY_CAP = 1000;
 export function summarizeApiErrorForLog(error) {
     if (!APICallError.isInstance(error))

package/dist/src/orchestrator/message-processor.d.ts

@@ -1,16 +1,17 @@
 import { type ModelMessage } from "ai";
-import { type ResolvedModelRuntime } from "../providers/runtime.js";
+import type { getModelInfo } from "../models/registry.js";
+import { resolveModelRuntime } from "../providers/runtime.js";
 import type { ProviderId } from "../providers/types.js";
 import { type SessionStore } from "../storage/index.js";
 import type { SessionInfo, StreamChunk, SubagentStatus } from "../types/index.js";
 import { type PermissionMode } from "../utils/permission-mode.js";
-import { loadValidSubAgents } from "../utils/settings.js";
 import type { AbortContext } from "./abort.js";
 import type { LegacyProvider, ProcessMessageObserver } from "./agent-options.js";
 import type { CouncilManager } from "./council-manager.js";
 import type { CrossTurnDedup } from "./cross-turn-dedup.js";
 import type { PendingCallsLog } from "./pending-calls.js";
 import type { ReadPathBudget } from "./read-path-budget.js";
+import type { SafetyOverrideAskInfo, SafetyOverrideVerdict } from "./safety-askcard.js";
 import { type ToolLoopCapAsk } from "./tool-loop-cap.js";
 import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
 /**
@@ -108,7 +109,10 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     drainSteerMessages?: () => {
         text: string;
     }[];
+    appendMidTurnMessages?: (msgs: ModelMessage[]) => void;
     askToolLoopContinue?: ToolLoopCapAsk;
+    /** Safety override handler — invoked when a tool call is blocked by the safety filter. */
+    askSafetyOverride?: (info: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>;
     runCouncilV2(userMessage: string, opts: {
         skipClarification: boolean;
         observer?: ProcessMessageObserver;
@@ -121,15 +125,26 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     }>): AsyncGenerator<StreamChunk, void, unknown>;
     processMessageBatchTurn(args: {
         userModelMessage: ModelMessage;
+        userEnrichedMessage: ModelMessage;
         observer?: ProcessMessageObserver;
         provider: LegacyProvider;
-        subagents: ReturnType<typeof loadValidSubAgents>;
+        subagents: unknown[];
         system: string;
-        runtime: ResolvedModelRuntime;
-        modelInfo: ResolvedModelRuntime["modelInfo"];
+        runtime: ReturnType<typeof resolveModelRuntime>;
+        modelInfo: ReturnType<typeof getModelInfo>;
         signal: AbortSignal;
     }): AsyncGenerator<StreamChunk, void, unknown>;
 }
+/**
+ * Rewrites tool-result parts in the AI SDK's final response history if the
+ * user manually approved a safety-blocked command. This ensures the model sees
+ * its own retry context accurately (as a success) rather than a repeated block
+ * message, avoiding infinite retry loops or hallucinated failures.
+ */
+export declare function rewriteSafetyApprovedToolResults<T extends {
+    role: string;
+    content?: any;
+}>(messages: T[]): T[];
 export declare class MessageProcessor {
     private deps;
     constructor(deps: MessageProcessorDeps);
@@ -139,3 +154,4 @@ export declare class MessageProcessor {
         base64: string;
     }>): AsyncGenerator<StreamChunk, void, unknown>;
 }
+export declare function stripDsmlMarkup(text: string): string;