clixad 0.0.1-beta.25 → 0.0.1-beta.26

package/README.md

@@ -15,6 +15,12 @@ cover it, for example `task ≈ 560–3.1k · free` or `task ≈ 7.5k–47k · n
 estimate from the size of the conversation and how tasks usually run; what is charged is what the
 model actually used.
 
+`/effort` sets how long the model thinks before it answers, saved separately for each model.
+Thinking is billed as output tokens like the answer, so a higher setting costs more credits per turn
+and a lower one costs less. `auto` leaves the model at its own default, and a model with nothing to
+adjust says so. The cost preview is not shown while a setting above the model's default is active,
+because it is measured at the defaults.
+
 **Early beta.** Commands, interfaces and credit mechanics may change between beta versions. Run the
 most recent published build with:
 

package/dist/clixad.mjs

@@ -1228,9 +1228,9 @@ var init_client = __esm({
         return retry;
       }
       /** Non-streaming chat. Kept for scripted/one-shot paths; the REPL streams. */
-      async chat(messages, model, tools, signal) {
+      async chat(messages, model, tools, signal, effort) {
         const res = await this.postChat(
-          { model, messages, stream: false, ...tools ? { tools } : {} },
+          { model, messages, stream: false, ...tools ? { tools } : {}, ...effort ? { reasoning_effort: effort } : {} },
           signal
         );
         if (res.status === 401) throw await authFailure(res, "chat");
@@ -1257,7 +1257,13 @@ var init_client = __esm({
        */
       async chatStream(messages, model, opts = {}) {
         const res = await this.postChat(
-          { model, messages, stream: true, ...opts.tools ? { tools: opts.tools } : {} },
+          {
+            model,
+            messages,
+            stream: true,
+            ...opts.tools ? { tools: opts.tools } : {},
+            ...opts.effort ? { reasoning_effort: opts.effort } : {}
+          },
           opts.signal
         );
         if (res.status === 401) throw await authFailure(res, "chat");
@@ -1460,6 +1466,18 @@ function saveConfig(config) {
   } catch {
   }
 }
+function saveEffort(config, model, level) {
+  const current = readStored();
+  const onDisk = current.problem ? void 0 : current.stored.effort;
+  const next = {};
+  for (const [id, value] of Object.entries(onDisk && typeof onDisk === "object" ? onDisk : {})) {
+    if (typeof value === "string") next[id] = value;
+  }
+  if (level === void 0) delete next[model];
+  else next[model] = level;
+  config.effort = Object.keys(next).length ? next : void 0;
+  saveConfig(config);
+}
 function configPath() {
   return CONFIG_PATH;
 }
@@ -4173,6 +4191,9 @@ async function runAgent(client, task, opts) {
     onProgress?.(`${description}: starting`);
     const sub = await runAgent(client, prompt, {
       model: opts.model,
+      // The setting somebody chose for this model, the same as the parent's
+      // calls: a sub-agent's credits land on the same turn.
+      effort: opts.effort,
       root: opts.root,
       // A sub-agent that was told it can search the web, on a gateway that
       // cannot, spends its whole step budget discovering that.
@@ -4226,6 +4247,7 @@ ${NO_SEARCH_INSTRUCTION}`,
     let turn;
     try {
       turn = await client.chatStream(messages, opts.model, {
+        effort: opts.effort,
         tools: opts.tools ? opts.tools() : TOOL_SCHEMA,
         signal: opts.signal,
         onDelta: (text) => emit({ type: "delta", text })
@@ -5097,6 +5119,50 @@ var init_version = __esm({
   }
 });
 
+// src/effort.ts
+function isLevel(value) {
+  return typeof value === "string" && EFFORT_LEVELS.includes(value);
+}
+function effortsOf(info) {
+  return (info?.efforts ?? []).filter(isLevel);
+}
+function parseEffortArg(arg) {
+  const v = arg.trim().toLowerCase();
+  if (v === "auto" || v === "default") return "auto";
+  if (v === "none") return "off";
+  return isLevel(v) ? v : void 0;
+}
+function resolveEffort(info, requested) {
+  if (!isLevel(requested)) return void 0;
+  const efforts = effortsOf(info);
+  if (efforts.length === 0) return void 0;
+  if (!isLevel(info?.default_effort)) return requested === "off" && efforts.includes("off") ? "off" : void 0;
+  if (efforts.includes(requested)) return requested;
+  const below = efforts.filter((e) => rank(e) <= rank(requested));
+  return below.length ? below[below.length - 1] : efforts[0];
+}
+function savedEffort(config, model) {
+  const value = config.effort?.[model];
+  return typeof value === "string" ? value : void 0;
+}
+function effortRaised(info, level) {
+  if (!level || !isLevel(info?.default_effort)) return false;
+  return rank(level) > rank(info.default_effort);
+}
+function effortLabel(level) {
+  if (level === "off") return "thinking off";
+  if (level === "on") return "thinking on";
+  return `${level} effort`;
+}
+var EFFORT_LEVELS, rank;
+var init_effort = __esm({
+  "src/effort.ts"() {
+    "use strict";
+    EFFORT_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+    rank = (level) => EFFORT_LEVELS.indexOf(level);
+  }
+});
+
 // src/mentions.ts
 function findMentions(text) {
   const out = [];
@@ -5187,7 +5253,9 @@ async function compact(client, model, messages, opts = {}) {
   const turn = await client.chatStream(
     [...messages.slice(0, cut), { role: "user", content: SUMMARY_PROMPT }],
     model,
-    { signal: opts.signal }
+    // The `/effort` setting applies to every call on the model, a summary
+    // included: somebody who turned it down to save credits saves them here too.
+    { signal: opts.signal, effort: opts.effort }
   );
   const summary = messageText(turn.message).trim() || "(no summary returned)";
   const compacted = [
@@ -5460,6 +5528,10 @@ var init_commands = __esm({
       { name: "help", desc: "list the commands" },
       { name: "model", desc: "switch model" },
       { name: "models", desc: "list models + prices" },
+      // Deliberately *no* `args`, for `/model`'s reason: an arg hint makes enter
+      // complete the command instead of running it, and the picker is the point.
+      // `/effort low` still works when typed in full.
+      { name: "effort", desc: "how long the model thinks (more thinking, more credits)" },
       { name: "mode", args: "[name]", desc: "permission mode (or press shift+tab)" },
       { name: "wallet", desc: "balance & ads today" },
       // Not "watch an ad": nothing on the wall is a video. CPX serves sign-up
@@ -6024,6 +6096,7 @@ function App({
   const [spent, setSpent] = useState(0);
   const [freeTier, setFreeTier] = useState(wallet?.free_tier);
   const [model, setModel2] = useState(config.model);
+  const [effortBy, setEffortBy] = useState(() => config.effort ?? {});
   const modelRef = useRef(config.model);
   const [mode, setMode] = useState("normal");
   const switchModel = useCallback((id) => {
@@ -6513,7 +6586,7 @@ function App({
           const res = await compact(client, model2, [
             { role: "system", content: contextRef.current.systemPrompt },
             ...history
-          ], { signal: ac.signal });
+          ], { signal: ac.signal, effort: savedEffort(config, model2) });
           if (res) {
             history = res.messages.slice(1);
             setMessages(history);
@@ -6527,6 +6600,10 @@ function App({
         }
         const result = await runAgent(client, task, {
           model: model2,
+          // Read now rather than from the render, for `modelRef`'s reason: a
+          // setting chosen in the same tick as this turn starts is in `config`
+          // already and not yet in any state.
+          effort: savedEffort(config, model2),
           root,
           history,
           attachments: images,
@@ -6996,7 +7073,7 @@ ${NO_SEARCH_INSTRUCTION}`),
               client,
               model,
               [{ role: "system", content: contextRef.current.systemPrompt }, ...messagesRef.current],
-              { signal }
+              { signal, effort: savedEffort(config, model) }
             );
             if (!res) return void push({ kind: "notice", text: "  nothing to compact yet" });
             setMessages(res.messages.slice(1));
@@ -7048,6 +7125,64 @@ ${NO_SEARCH_INSTRUCTION}`),
             });
           });
           return;
+        // How long the model thinks, saved per model. The picker offers only
+        // what the current model takes, so a stored setting is always one it
+        // has; a typed level it does not have moves to the nearest one below,
+        // the gateway's rule, and says so. Every figure about cost stays in
+        // words: what a setting costs depends on the task, and the meta line
+        // under each turn already shows what it did cost.
+        case "effort":
+          await runBusy(LOADING, async (signal) => {
+            const models = catalogRef.current.length ? catalogRef.current : await client.models(signal);
+            catalogRef.current = models;
+            const info2 = models.find((m) => m.id === model);
+            const name = info2?.label ?? model;
+            const levels = effortsOf(info2);
+            const fallback = info2?.default_effort;
+            if (!info2 || levels.length === 0) {
+              const why = info2?.efforts === void 0 ? "this gateway does not offer effort settings" : fallback === "on" ? `${name} always thinks before it answers, and has no setting for how long` : `${name} has no effort setting`;
+              return void push({ kind: "notice", text: `  ${why}` });
+            }
+            const defaultWords = fallback ? effortLabel(fallback) : "its default";
+            const apply2 = (choice, note = "") => {
+              saveEffort(config, model, choice);
+              setEffortBy({ ...config.effort ?? {} });
+              const now = choice ? effortLabel(choice) : `auto (${defaultWords})`;
+              push({ kind: "notice", text: `  ${name}: ${now}${note}` });
+            };
+            if (arg) {
+              const wanted = parseEffortArg(arg);
+              if (!wanted) {
+                return void push({
+                  kind: "notice",
+                  tone: "warn",
+                  text: `  unknown effort: ${arg}. ${name} takes ${["auto", ...levels].join(", ")}`
+                });
+              }
+              if (wanted === "auto") return apply2(void 0);
+              const resolved = resolveEffort(info2, wanted);
+              if (!resolved) return apply2(void 0, `. ${name} can only switch its thinking off`);
+              return apply2(resolved, resolved === wanted ? "" : `. It has no ${wanted}, so this is the nearest below`);
+            }
+            const current = resolveEffort(info2, savedEffort(config, model));
+            const items = [
+              { value: "auto", label: "auto", hint: `the model's default (${defaultWords})`, current: !current },
+              ...levels.map((level) => ({
+                value: level,
+                label: level,
+                hint: level === fallback ? "same as auto" : effortRaised(info2, level) ? "more thinking, more credits" : "less thinking, fewer credits",
+                current: current === level
+              }))
+            ];
+            setPickerSel(Math.max(0, items.findIndex((i) => i.current)));
+            setPicker({
+              title: `Effort for ${name}`,
+              subtitle: "Saved for this model. Thinking is billed as output, like the answer.",
+              items,
+              onPick: (choice) => apply2(choice.value === "auto" ? void 0 : choice.value)
+            });
+          });
+          return;
         case "models":
           await runBusy(LOADING, async (signal) => {
             const ms = await client.models(signal);
@@ -7722,8 +7857,9 @@ ${dropped.map((l) => `  \xB7 ${l}`).join("\n")}`
   const typed = toText(editor);
   let estimate;
   const info = catalogRef.current.find((m) => m.id === model);
+  const effortNow = info ? resolveEffort(info, effortBy[model]) : effortBy[model];
   const shape = client.taskShape;
-  if (!busy && info && shape && balance !== void 0 && typed.trim() !== "" && !/^[/!]/.test(typed.trimStart())) {
+  if (!busy && info && shape && balance !== void 0 && !effortRaised(info, resolveEffort(info, effortBy[model])) && typed.trim() !== "" && !/^[/!]/.test(typed.trimStart())) {
     const range = estimateTask(info, conversationUsed + schemaTokens + estimateTokens(typed), shape);
     const onFree = Boolean(info.free && freeTier?.models.includes(model));
     const verdict = taskVerdict(range, { balance, ...onFree ? { freeLeft: freeTier.credits_left } : {} });
@@ -7734,6 +7870,7 @@ ${dropped.map((l) => `  \xB7 ${l}`).join("\n")}`
     `  ${statusLine(
       {
         model,
+        ...effortNow ? { effort: effortNow } : {},
         balance,
         spent,
         contextPct,
@@ -7932,6 +8069,8 @@ function statusRow(o, estimate, cols) {
   const burn = o.spent > 0 && o.minutes >= 1 ? `${Math.round(o.spent / o.minutes).toLocaleString("en-US")} cr/min` : void 0;
   const clauses = [
     { text: o.model, rank: KEEP_ALWAYS },
+    // Beside the model it qualifies, and given up with the free allowance.
+    { text: o.effort === void 0 ? void 0 : effortLabel(o.effort), rank: 4 },
     {
       // "? cr" rather than "0 cr": unknown is not empty, and an empty-looking
       // wallet is the one misreading on this row that frightens somebody.
@@ -8017,6 +8156,7 @@ var init_app = __esm({
     init_todos();
     init_shells();
     init_config();
+    init_effort();
     init_login();
     init_banner();
     init_agent();
@@ -8165,6 +8305,7 @@ function clearTerminalTitle(out = titleStream()) {
 
 // src/main.ts
 init_version();
+init_effort();
 var c = palette({ isTTY: process.stdout.isTTY, env: process.env });
 async function main() {
   setTerminalTitle();
@@ -8461,6 +8602,7 @@ async function printCmd(client, config, task) {
   try {
     const res = await runAgent(client, task, {
       model: config.model,
+      effort: savedEffort(config, config.model),
       root: process.cwd(),
       systemPrompt: collectContext(process.cwd()).systemPrompt + (capabilities?.web_search ? "" : `
 
@@ -8606,6 +8748,7 @@ async function runTurn(client, config, messages) {
   let started = false;
   try {
     const result = await client.chatStream(messages, config.model, {
+      effort: savedEffort(config, config.model),
       onDelta: (chunk) => {
         if (!started) process.stdout.write(c.green("assistant "));
         started = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clixad",
-  "version": "0.0.1-beta.25",
+  "version": "0.0.1-beta.26",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "UNLICENSED",
   "type": "module",