muonroi-cli 1.7.1 → 1.8.0

package/dist/src/orchestrator/compaction.js

@@ -2,8 +2,50 @@ import { generateText } from "ai";
 import { isMetaAnalysisPrompt } from "../pil/layer6-output.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { requireRuntimeProvider, resolveModelRuntime } from "../providers/runtime.js";
+import { COMPACT_PROPOSER_SYSTEM_PROMPT } from "./compaction-proposer-prompt.js";
 import { containsEncryptedReasoning } from "./reasoning.js";
 import { countTokens } from "./token-counter.js";
+/**
+ * Call the model to propose what to compact/keep/drop.
+ * The model sees the current messages and decides whether compaction is needed at all.
+ * Returns null if the proposer call fails (caller should fall back gracefully).
+ */
+export async function proposeCompaction(provider, modelId, messages, signal) {
+    try {
+        const runtime = resolveModelRuntime(provider, modelId);
+        const compactCaps = getProviderCapabilities(requireRuntimeProvider(runtime));
+        const serialized = serializeConversation(messages);
+        const result = await generateText({
+            model: runtime.model,
+            system: COMPACT_PROPOSER_SYSTEM_PROMPT,
+            prompt: `Current conversation messages:\n\n${serialized}\n\nDecide if compaction is needed and what to keep/drop/summarize. Return strict JSON.`,
+            abortSignal: signal,
+            maxRetries: 1,
+            temperature: 0.1,
+            ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo) ? {} : { maxOutputTokens: 2048 }),
+            ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
+        });
+        const text = result.text.trim();
+        // Attempt to parse top-level JSON object. The model might wrap in markdown fences — strip those.
+        const jsonStr = text.replace(/^```(?:json)?\s*|\s*```$/gi, "").trim();
+        const parsed = JSON.parse(jsonStr);
+        // Validate shape
+        if (typeof parsed.shouldCompact !== "boolean" || !Array.isArray(parsed.actions)) {
+            return null;
+        }
+        // Validate each action
+        for (const action of parsed.actions) {
+            if (typeof action.messageIndex !== "number" || !["keep", "drop", "summarize"].includes(action.action)) {
+                return null;
+            }
+        }
+        return parsed;
+    }
+    catch {
+        // Proposer failure is non-fatal — caller falls back to heuristic or no-compact
+        return null;
+    }
+}
 const TOOL_RESULT_MAX_CHARS = 8000;
 const MIN_KEPT_TOKENS_ON_RETRY = 4000;
 export const DEFAULT_RESERVE_TOKENS = 16_384;

package/dist/src/orchestrator/delegations.d.ts

@@ -40,6 +40,7 @@ export declare class DelegationManager {
     start(request: TaskRequest, options: StartDelegationOptions): Promise<ToolResult>;
     list(): Promise<DelegationRun[]>;
     read(id: string): Promise<string>;
+    kill(id: string): Promise<ToolResult>;
     consumeNotifications(): Promise<DelegationNotification[]>;
     private getById;
 }

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;