@pentoshi/clai 2.0.52 → 2.0.54

package/README.md

@@ -106,7 +106,7 @@ classic REPL automatically.
 
 - **`/ask` mode** — Read-only. AI explains, gives commands & step-by-step guidance, but does NOT execute anything.
 - **`/agent` mode** — Agentic. AI plans, waits for approval, then executes shell commands, edits files, installs missing tools, parses output, and continues until the goal is met. Tasks run on an approve/refine/discard plan workflow (`/implement`, free-text to refine, `/discard` to cancel).
-- **11 LLM providers** — Groq, Google Gemini, OpenRouter, OpenAI, Anthropic, NVIDIA NIM, AgentRouter, Kimchi, AWS Mantle, Ollama (local), and Bynara. All with streaming.
+- **12 LLM providers** — Groq, Google Gemini, OpenRouter, OpenAI, Anthropic, NVIDIA NIM, AgentRouter, Kimchi, AWS Mantle, Ollama (local), Bynara, and Qwen Cloud. All with streaming.
 - **10 built-in tools** — `shell.exec`, `fs.read`, `fs.write`, `fs.list`, `fs.search`, `pkg.install`, `net.scan`, `http.fetch`, `sysinfo`, `pentest.recon`.
 - **Smart safety gate** — Read-only commands auto-execute; mutating commands require confirmation; destructive patterns are blocked.
 - **OS-aware & tool-frugal** — Picks the best approach for your OS, prefers tools already installed (installs only when nothing suitable exists), broadens its approach and escalates privileges as needed to finish the task.
@@ -122,7 +122,7 @@ classic REPL automatically.
 
 ## Provider Setup
 
-clai supports 11 LLM providers (9 with free tiers):
+clai supports 12 LLM providers (9 with free tiers):
 
 | Provider    | Default Model                                | Free? | API Key Prefix |
 |-------------|----------------------------------------------|-------|----------------|
@@ -137,6 +137,7 @@ clai supports 11 LLM providers (9 with free tiers):
 | AWS Mantle  | `anthropic.claude-haiku-4-5`                 | —     | `sk-ant-`      |
 | Ollama      | `llama3.1:8b`                                | ✓     | (local URL)    |
 | Bynara      | `mimo-v2.5-free`                             | ✓     | `sk_nry_`      |
+| Qwen Cloud  | `qwen3.7-plus`                               | —     | `sk-`          |
 
 ```sh
 # Store an API key
@@ -178,6 +179,7 @@ export NVIDIA_API_KEY=nvapi-...
 export CASTAI_API_KEY=...
 export ANTHROPIC_WORKSPACE_ID=default  # optional, for AWS Mantle
 export OLLAMA_HOST=http://localhost:11434
+export DASHSCOPE_API_KEY=sk-...
 ```
 
 ## REPL Commands
@@ -434,7 +436,8 @@ clai/
 │  │   ├─ openai.ts         # OpenAI provider (streaming)
 │  │   ├─ anthropic.ts      # Anthropic provider (streaming)
 │  │   ├─ nvidia.ts         # NVIDIA NIM provider (streaming)
-│  │   └─ openrouter.ts     # OpenRouter provider (streaming)
+│  │   ├─ openrouter.ts     # OpenRouter provider (streaming)
+│  │   └─ qwen-cloud.ts     # Qwen Cloud provider (streaming + live models)
 │  ├─ tools/
 │  │   ├─ registry.ts       # Tool dispatch table
 │  │   ├─ shell.ts          # shell.exec via execa

package/dist/agent/runner.js

@@ -4,13 +4,14 @@ import { join, relative, resolve } from "node:path";
 import { streamWithProvider, completeWithProvider } from "../llm/router.js";
 import { randomUUID } from "node:crypto";
 import { jobManager } from "../tools/jobs.js";
-import { renderAgentSystemPrompt, scratchDirFor, } from "../prompts/index.js";
+import { renderAgentSystemPrompt, renderCompactAgentSystemPrompt, scratchDirFor, } from "../prompts/index.js";
 import { getConfig } from "../store/config.js";
+import { groqInputTokenBudget } from "../llm/groq.js";
 import { classifyToolCall, isPentestToolCall, scopeHint, scopeTargetForToolCall, } from "../safety/classifier.js";
 import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, } from "../tools/registry.js";
 import { looksInteractiveStdin } from "../tools/shell.js";
 import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
-import { compactMessagesWithSummary, estimateMessagesTokens, COMPACTION_MEMORY_PREFIX, } from "./context-manager.js";
+import { compactMessagesWithSummary, estimateTokens, estimateMessagesTokens, COMPACTION_MEMORY_PREFIX, } from "./context-manager.js";
 import { auditLog } from "../store/logs.js";
 import { loadProjectContext } from "../store/project.js";
 import { loadScope, isScopeActive, targetInScope } from "../store/scope.js";
@@ -248,16 +249,26 @@ export async function runAgentLoop(prompt, options = {}) {
             !pentestLikeTurn &&
             toolNames.includes("web.search") &&
             requiresFreshWebSearch(prompt);
-        const systemSections = [renderAgentSystemPrompt(toolNames.join(", "))];
+        let provider = options.provider ?? config.defaultProvider;
+        await ensureProviderConfigured(provider);
+        let model = options.model ?? config.defaultModel;
+        // Some Groq free-tier models have a per-request/per-minute input budget
+        // below the normal agent prompt alone. Select a purpose-built compact
+        // instruction set before the request is made, rather than treating the
+        // provider's 413 as a context-window failure after the fact.
+        const inputTokenBudget = provider === "groq" ? groqInputTokenBudget(model) : undefined;
+        const useCompactSystemPrompt = inputTokenBudget !== undefined;
+        const systemSections = [
+            (useCompactSystemPrompt
+                ? renderCompactAgentSystemPrompt
+                : renderAgentSystemPrompt)(toolNames.join(", ")),
+        ];
         if (projectContext) {
             systemSections.push(`Project context from .clai/context.md:\n${projectContext}`);
         }
         if (freshWebSearchRequired) {
             systemSections.push(freshnessGuardMessage());
         }
-        let provider = options.provider ?? config.defaultProvider;
-        await ensureProviderConfigured(provider);
-        let model = options.model ?? config.defaultModel;
         let lastAnswer = "";
         const session = options.session ?? createSessionPolicy();
         // Active plan context
@@ -296,7 +307,19 @@ export async function runAgentLoop(prompt, options = {}) {
         if (pentestLikeTurn && !activePlan && !informationalQuery) {
             systemSections.push(pentestWorkflowDirective());
         }
-        const fullSystemPrompt = systemSections.join("\n\n");
+        const renderedSystemPrompt = systemSections.join("\n\n");
+        // Reserve most of a constrained model's input budget for the user message,
+        // recent conversation, tool results, and provider framing. Dynamic project
+        // context or a saved plan must not silently grow the compact base prompt
+        // back above the model's TPM ceiling.
+        const maxSystemTokens = inputTokenBudget
+            ? Math.min(2_000, Math.floor(inputTokenBudget * 0.4))
+            : undefined;
+        const systemTruncationNote = "\n\n[Additional system context omitted to fit the provider input budget.]";
+        const fullSystemPrompt = maxSystemTokens !== undefined &&
+            estimateTokens(renderedSystemPrompt) > maxSystemTokens
+            ? renderedSystemPrompt.slice(0, Math.max(0, Math.floor(maxSystemTokens * 3.3) - systemTruncationNote.length)) + systemTruncationNote
+            : renderedSystemPrompt;
         const userMessage = { role: "user", content: prompt };
         if (options.images && options.images.length > 0) {
             userMessage.images = options.images;
@@ -317,6 +340,20 @@ export async function runAgentLoop(prompt, options = {}) {
             }
             return message;
         };
+        // Every provider must receive a syntactically valid assistant turn between
+        // the original user prompt and a recovery nudge. In particular, Gemini
+        // serializes an empty assistant message as an empty `model` text part,
+        // which can cause every retry to return empty as well. Keep hidden thinking
+        // out of history, but record a compact non-empty sentinel when there was no
+        // visible output.
+        const pushAssistantHistory = (content) => {
+            messages.push({
+                role: "assistant",
+                content: content.trim()
+                    ? content
+                    : "[No visible assistant response was produced.]",
+            });
+        };
         // Track recent tool calls to detect models stuck in a loop calling the
         // same tool with the same arguments over and over (e.g. pentest.recon
         // called 3× on the same target without summarizing).
@@ -324,6 +361,10 @@ export async function runAgentLoop(prompt, options = {}) {
         // Track consecutive thinking-only responses so we can nudge the model
         // to actually act instead of silently returning an empty answer.
         let emptyVisibleRetries = 0;
+        // A model that spent an entire completion in hidden reasoning gets one
+        // visible-output retry with provider thinking disabled. This is per-turn
+        // only: a subsequent successful response restores the configured setting.
+        let retryWithoutThinking = false;
         // Track tool calls truncated by the token limit so we can ask the model
         // to retry in smaller pieces instead of leaking broken JSON as an answer.
         let truncatedToolRetries = 0;
@@ -689,12 +730,22 @@ export async function runAgentLoop(prompt, options = {}) {
                 artifactPath: "",
             };
             jobManager.registerJob(jobId, backgroundJob, toolAc);
-            const TOOL_STALL_WARNING_MS = 60_000; // 1 minute
-            const stallTimer = setTimeout(() => {
-                if (!toolAc.signal.aborted) {
-                    writeNotice("info", `${call.name} has been running for >60s — still waiting (ESC to abort)`, chalk.yellow(`  ⏳ ${call.name} still running — ESC to abort\n`));
-                }
-            }, TOOL_STALL_WARNING_MS);
+            // Long-lived commands should use shell.start/background jobs. Reset this
+            // watchdog whenever a blocking tool emits output so only a genuinely
+            // stalled operation is cancelled.
+            const TOOL_STALL_ABORT_MS = 60_000; // 1 minute
+            let stallTimer;
+            const resetStallTimer = () => {
+                if (stallTimer)
+                    clearTimeout(stallTimer);
+                stallTimer = setTimeout(() => {
+                    if (!toolAc.signal.aborted) {
+                        writeNotice("warn", `${call.name} has been running for >60s — cancelling stalled tool`, chalk.yellow(`  ⏳ ${call.name} stalled for >60s — cancelling\n`));
+                        toolAc.abort();
+                    }
+                }, TOOL_STALL_ABORT_MS);
+            };
+            resetStallTimer();
             try {
                 result = await runToolCall(call, {
                     signal: toolAc.signal,
@@ -702,6 +753,7 @@ export async function runAgentLoop(prompt, options = {}) {
                     onOutput: (chunk) => {
                         if (toolAc.signal.aborted)
                             return;
+                        resetStallTimer();
                         printLive(chunk);
                     },
                     confirmed: true,
@@ -728,7 +780,8 @@ export async function runAgentLoop(prompt, options = {}) {
                 result = { ok: false, output: `Tool error: ${errMsg}`, exitCode: 1 };
             }
             finally {
-                clearTimeout(stallTimer);
+                if (stallTimer)
+                    clearTimeout(stallTimer);
                 parentSignal.removeEventListener("abort", onParentAbort);
             }
             const output = result.output.trim();
@@ -1000,8 +1053,15 @@ export async function runAgentLoop(prompt, options = {}) {
                     completion = await streamWithProvider({
                         provider,
                         model,
+                        // The selected model is the first choice, but an agent must not
+                        // end a turn with no answer if it only emits reasoning. Honor
+                        // the user's providerFallback setting for that recovery path.
+                        allowModelFallback: true,
                         messages,
-                        temperature: 0.2,
+                        // MiniMax M3 degenerates at the generic agent temperature. The
+                        // HTTP layer also applies its `top_p` override for both the
+                        // NVIDIA long ID and Kimchi's short `minimax-m3` ID.
+                        temperature: /minimax-m3/i.test(model) ? 1.0 : 0.2,
                         // Reasoning models can spend a lot on hidden thinking; give
                         // them headroom so the visible answer / tool call isn't
                         // truncated to silence. The non-thinking budget must be large
@@ -1015,7 +1075,9 @@ export async function runAgentLoop(prompt, options = {}) {
                         // substantial source file; providers with a lower limit clamp it.
                         maxTokens: 32_768,
                         signal: options.signal,
-                        thinking: config.thinking,
+                        thinking: retryWithoutThinking
+                            ? { ...config.thinking, enabled: false }
+                            : config.thinking,
                     }, (token) => {
                         deltaParser?.push(token);
                         generatedTokens += 1;
@@ -1148,16 +1210,17 @@ export async function runAgentLoop(prompt, options = {}) {
                         else {
                             writeNotice("warn", "model returned an empty response — nudging it to answer", chalk.yellow("  ⚠ model returned an empty response — nudging it to answer\n"));
                         }
-                        messages.push({
-                            role: "assistant",
-                            content: stripThinking(collapseRepeatedText(completion.text)).visible,
-                        });
+                        if (assistantText.hasThinking)
+                            retryWithoutThinking = true;
+                        pushAssistantHistory(stripThinking(collapseRepeatedText(completion.text)).visible);
                         // Keep nudges SHORT — cheap models lose the key instruction in long text.
-                        const buildNudge = buildLikeTurn && !activePlan
-                            ? "No visible output. Emit a ```tool block to call plan.create now. " +
-                                "Do NOT hide tool calls in <think> tags — put them in the visible response."
-                            : "No visible output. Emit a ```tool block or give your final answer. " +
-                                "Do NOT hide tool calls in <think> tags — put them in the visible response.";
+                        const buildNudge = freshWebSearchRequired && !sawFreshWebSearch
+                            ? "No visible output. This is current or scheduled information: emit exactly one valid ```tool block for web.search now. Do NOT answer from memory or hide the tool call in <think> tags."
+                            : buildLikeTurn && !activePlan
+                                ? "No visible output. Emit a ```tool block to call plan.create now. " +
+                                    "Do NOT hide tool calls in <think> tags — put them in the visible response."
+                                : "No visible output. Emit a ```tool block or give your final answer. " +
+                                    "Do NOT hide tool calls in <think> tags — put them in the visible response.";
                         messages.push(recoveryUserMessage(buildNudge));
                         continue;
                     }
@@ -1169,6 +1232,7 @@ export async function runAgentLoop(prompt, options = {}) {
                 else {
                     // Reset the counter on any successful visible output or recovered call.
                     emptyVisibleRetries = 0;
+                    retryWithoutThinking = false;
                 }
                 // `call` was already extracted above (from visible text or thinking content).
                 // Recovery: the model meant to call a tool but emitted a bare JSON object
@@ -1206,10 +1270,7 @@ export async function runAgentLoop(prompt, options = {}) {
                         bareToolJsonRetries += 1;
                         if (bareToolJsonRetries <= 3) {
                             writeNotice("warn", "tool call missing its name/fence — asking the model to re-emit a proper ```tool block", chalk.yellow("  ⚠ tool call missing its name/fence — asking the model to re-emit a proper ```tool block\n"));
-                            messages.push({
-                                role: "assistant",
-                                content: assistantText.visible,
-                            });
+                            pushAssistantHistory(assistantText.visible);
                             messages.push(recoveryUserMessage(buildLikeTurn && !activePlan
                                 ? "Your previous message was a bare JSON args object with no tool name and no ```tool fence, so NOTHING ran. " +
                                     "This is a BUILD/SCAFFOLD task with NO plan yet. " +
@@ -1231,10 +1292,7 @@ export async function runAgentLoop(prompt, options = {}) {
                     // model to retry the tool call in a clean JSON format.
                     if (/<\|tool_call(?:s_section)?_begin\|>|<\|tool_call_argument_begin\|>/i.test(assistantText.visible)) {
                         writeNotice("warn", "tool call was malformed or cut off — asking the model to retry in JSON form", chalk.yellow("  ⚠ tool call was malformed or cut off — asking the model to retry in JSON form\n"));
-                        messages.push({
-                            role: "assistant",
-                            content: assistantText.visible,
-                        });
+                        pushAssistantHistory(assistantText.visible);
                         messages.push(recoveryUserMessage("Your previous tool call was malformed or truncated. " +
                             "Reply with ONLY a fenced ```tool block containing valid JSON " +
                             'of the form `{"name": "<tool>", "args": { ... }}`. ' +
@@ -1262,10 +1320,7 @@ export async function runAgentLoop(prompt, options = {}) {
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
                                     writeNotice("info", `tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
-                                    messages.push({
-                                        role: "assistant",
-                                        content: stripThinking(assistantText.visible).visible,
-                                    });
+                                    pushAssistantHistory(stripThinking(assistantText.visible).visible);
                                     messages.push({
                                         role: "user",
                                         content: `Your fs.write tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines to ${salvaged.path}. ` +
@@ -1285,10 +1340,7 @@ export async function runAgentLoop(prompt, options = {}) {
                         }
                         if (truncatedToolRetries <= 3) {
                             writeNotice("warn", "tool call was cut off (output too long) — asking the model to retry safely", chalk.yellow("  ⚠ tool call was cut off (output too long) — asking the model to retry safely\n"));
-                            messages.push({
-                                role: "assistant",
-                                content: stripThinking(assistantText.visible).visible,
-                            });
+                            pushAssistantHistory(stripThinking(assistantText.visible).visible);
                             messages.push({
                                 role: "user",
                                 content: "Your previous tool call was cut off before it finished — the JSON was incomplete, so NOTHING ran. " +
@@ -1326,10 +1378,7 @@ export async function runAgentLoop(prompt, options = {}) {
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
                                     writeNotice("info", `malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}`, chalk.cyan(`  ℹ malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}\n`));
-                                    messages.push({
-                                        role: "assistant",
-                                        content: stripThinking(assistantText.visible).visible,
-                                    });
+                                    pushAssistantHistory(stripThinking(assistantText.visible).visible);
                                     messages.push({
                                         role: "user",
                                         content: `The system extracted and wrote ${lineCount} lines to ${salvaged.path} from your malformed tool call. ` +
@@ -1347,10 +1396,7 @@ export async function runAgentLoop(prompt, options = {}) {
                         malformedFenceRetries += 1;
                         if (malformedFenceRetries <= 3) {
                             writeNotice("warn", "tool block present but its JSON didn't parse — asking the model to re-emit valid JSON", chalk.yellow("  ⚠ tool block present but its JSON didn't parse — asking the model to re-emit valid JSON\n"));
-                            messages.push({
-                                role: "assistant",
-                                content: stripThinking(assistantText.visible).visible,
-                            });
+                            pushAssistantHistory(stripThinking(assistantText.visible).visible);
                             messages.push({
                                 role: "user",
                                 content: "Your previous message contained a ```tool block, but its JSON was INVALID, so NOTHING ran. " +
@@ -1441,10 +1487,7 @@ export async function runAgentLoop(prompt, options = {}) {
                             }
                             writeNotice("warn", "described an action but emitted no tool call — nudging it to run one", chalk.yellow("  ⚠ described an action but emitted no tool call — nudging it to run one\n"));
                         }
-                        messages.push({
-                            role: "assistant",
-                            content: assistantText.visible,
-                        });
+                        pushAssistantHistory(assistantText.visible);
                         messages.push(recoveryUserMessage(nudge));
                         continue;
                     }
@@ -1453,10 +1496,7 @@ export async function runAgentLoop(prompt, options = {}) {
                         !freshnessRetryUsed) {
                         freshnessRetryUsed = true;
                         writeNotice("info", "current-info question detected — searching the web before answering", chalk.dim("  ℹ current-info question detected — searching the web before answering\n"));
-                        messages.push({
-                            role: "assistant",
-                            content: assistantText.visible,
-                        });
+                        pushAssistantHistory(assistantText.visible);
                         messages.push({
                             role: "user",
                             content: freshnessGuardMessage() +
@@ -1477,10 +1517,7 @@ export async function runAgentLoop(prompt, options = {}) {
                             runtimePlan.tasks.every((task) => task.state === "done" || task.state === "skipped"));
                         if (tasksFinished) {
                             runtimeVerificationRetries += 1;
-                            messages.push({
-                                role: "assistant",
-                                content: assistantText.visible,
-                            });
+                            pushAssistantHistory(assistantText.visible);
                             const missing = [
                                 !sawServerStart ? "shell.start" : "",
                                 !sawServerTail ? "shell.tail" : "",
@@ -1508,10 +1545,7 @@ export async function runAgentLoop(prompt, options = {}) {
                             prematureCompletionRetries += 1;
                             const next = unfinished[0];
                             writeNotice("warn", `${unfinished.length} plan task(s) still unfinished — not accepting a "done" claim; resuming execution`, chalk.yellow(`  ⚠ ${unfinished.length} plan task(s) still unfinished — not accepting a "done" claim; resuming execution\n`));
-                            messages.push({
-                                role: "assistant",
-                                content: assistantText.visible,
-                            });
+                            pushAssistantHistory(assistantText.visible);
                             let instruction = `Resume now with the NEXT task ${next.id} ("${next.title}"): `;
                             if (next.state === "pending") {
                                 instruction += `call task.update {taskId:"${next.id}", state:"in_progress"}, then do the real work with a tool call (fs.writeMany / shell.exec / shell.start), VERIFY it, and mark it done. `;
@@ -1583,10 +1617,7 @@ export async function runAgentLoop(prompt, options = {}) {
                     allCalls
                         .map((c) => `\`\`\`tool\n${JSON.stringify(c)}\n\`\`\``)
                         .join("\n\n");
-                messages.push({
-                    role: "assistant",
-                    content: standardizedContent,
-                });
+                pushAssistantHistory(standardizedContent);
                 if (allCalls.length > 1) {
                     writeNotice("info", `${allCalls.length} tool calls in this message — running scoped (independent read-only lookups in parallel, everything else in order)`, chalk.dim(`  ℹ ${allCalls.length} tool calls — read-only lookups in parallel, the rest in order\n`));
                 }