clixad 0.0.1-beta.24 → 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

@@ -94,14 +94,62 @@ var init_estimate = __esm({
 });
 
 // src/sponsor/formats.ts
-var EXTRA_AD_FORMATS;
+function isAdFormat(value) {
+  return typeof value === "string" && AD_FORMATS.includes(value);
+}
+var AD_FORMATS, EXTRA_AD_FORMATS;
 var init_formats = __esm({
   "src/sponsor/formats.ts"() {
     "use strict";
+    AD_FORMATS = ["top_bar", "sidebar_card", "status_bar"];
     EXTRA_AD_FORMATS = ["sidebar_card", "status_bar"];
   }
 });
 
+// src/sponsor/direct.ts
+function sanitizeAdText(raw) {
+  return raw.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/[‪-‮⁦-⁩‎‏؜]/g, "").replace(/[​-‍⁠­]/g, "").replace(/\s+/g, " ").trim();
+}
+function parseDirectLines(body) {
+  const raw = body?.lines;
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const e = item;
+    if (!isAdFormat(e.format) || seen.has(e.format)) continue;
+    if (e.hold === true) {
+      out.push({ format: e.format, hold: true });
+      seen.add(e.format);
+      continue;
+    }
+    if (typeof e.text !== "string" || typeof e.serve_token !== "string" || typeof e.click_url !== "string") continue;
+    const text = sanitizeAdText(e.text).slice(0, MAX_TEXT);
+    if (!text || !e.serve_token || e.serve_token.length > 2e3) continue;
+    let clickUrl;
+    try {
+      const url = new URL(e.click_url);
+      if (url.protocol !== "https:" && url.protocol !== "http:") continue;
+      clickUrl = url.toString();
+    } catch {
+      continue;
+    }
+    out.push({ format: e.format, text, serveToken: e.serve_token, clickUrl });
+    seen.add(e.format);
+  }
+  return out;
+}
+var DIRECT_ASK_TIMEOUT_MS, MAX_TEXT;
+var init_direct = __esm({
+  "src/sponsor/direct.ts"() {
+    "use strict";
+    init_formats();
+    DIRECT_ASK_TIMEOUT_MS = 1500;
+    MAX_TEXT = 200;
+  }
+});
+
 // src/edge.ts
 function detectEdgeBlock(status, headers, body) {
   if (status !== 403) return void 0;
@@ -498,6 +546,7 @@ var init_client = __esm({
     "use strict";
     init_estimate();
     init_formats();
+    init_direct();
     init_edge();
     CHAT_ENCODED_CONTENT_TYPE = "application/vnd.clixad.chat+gzip";
     LEDGER_REASONS = {
@@ -645,6 +694,7 @@ var init_client = __esm({
           return { status: "closed", message: closed.message, waitlistUrl: closed.waitlist_url };
         }
         if (!res.ok && !("status" in data && data.status)) {
+          if (res.status >= 500 || res.status === 429) return { status: "unavailable", error: `http ${res.status}` };
           return { status: "error", error: `http ${res.status}` };
         }
         return data;
@@ -981,6 +1031,51 @@ var init_client = __esm({
           return 0;
         }
       }
+      /**
+       * Ask for booked lines (step 2): one ask per model call, naming the slots
+       * that fit the terminal now. See `sponsor/direct.ts` for the contract.
+       *
+       * Never throws, for `sponsorConfig`'s reason. A 404 means a gateway that
+       * does not know the route, so `supported: false` tells the caller to stop
+       * asking for the rest of the session; every other failure (a timeout, a 429,
+       * a 5xx, a malformed body) is simply "nothing booked" this time.
+       */
+      async directSponsor(formats, cols, signal) {
+        try {
+          const res = await gatewayFetch(`${this.config.gatewayUrl}/v1/sponsor/direct`, {
+            method: "POST",
+            headers: this.headers(),
+            ...signal ? { signal } : {},
+            body: JSON.stringify({ formats, cols })
+          });
+          if (res.status === 404) return { supported: false, lines: [] };
+          if (!res.ok) return { supported: true, lines: [] };
+          return { supported: true, lines: parseDirectLines(await res.json()) };
+        } catch {
+          return { supported: true, lines: [] };
+        }
+      }
+      /**
+       * Report the booked lines a turn drew, in one call, after the turn is over.
+       * Never to `/v1/sponsor/impression`, which would credit them as ADtention's.
+       * Never throws; answers what was credited, for the tally and for tests.
+       */
+      async reportDirectImpressions(impressions, signal) {
+        if (impressions.length === 0) return 0;
+        try {
+          const res = await gatewayFetch(`${this.config.gatewayUrl}/v1/sponsor/direct/impression`, {
+            method: "POST",
+            headers: this.headers(),
+            ...signal ? { signal } : {},
+            body: JSON.stringify({ impressions: impressions.map((i) => ({ format: i.format, serve_token: i.serveToken })) })
+          });
+          if (!res.ok) return 0;
+          const body = await res.json();
+          return typeof body.credited === "number" ? body.credited : 0;
+        } catch {
+          return 0;
+        }
+      }
       /**
        * Search the web, through the gateway.
        *
@@ -1133,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");
@@ -1162,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");
@@ -1365,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;
 }
@@ -1443,11 +1556,24 @@ async function githubLogin(client, config, start, invite, report, signal) {
   openBrowser(start.verification_uri);
   const deadline = Date.now() + start.expires_in * 1e3;
   let interval = Math.max(start.interval, 1);
+  let unavailableSince;
   while (Date.now() < deadline) {
     await sleep2(interval * 1e3, signal);
     if (signal?.aborted) return { status: "aborted" };
     report.tick?.();
-    const poll = await client.devicePoll(start.session, invite);
+    let poll;
+    try {
+      poll = await client.devicePoll(start.session, invite);
+    } catch (err) {
+      if (!(err instanceof GatewayUnreachableError)) throw err;
+      poll = { status: "unavailable", error: err.message };
+    }
+    if (poll.status === "unavailable") {
+      unavailableSince ??= Date.now();
+      if (Date.now() - unavailableSince > UNAVAILABLE_GIVE_UP_MS) return { status: "failed", error: poll.error };
+      continue;
+    }
+    unavailableSince = void 0;
     if (poll.status === "pending") {
       if (poll.interval) interval = poll.interval;
       continue;
@@ -1475,10 +1601,19 @@ async function githubLogin(client, config, start, invite, report, signal) {
         }
       };
     }
-    return { status: "failed", error: poll.error ?? poll.status };
+    return { status: "failed", error: describePollError(poll.error ?? poll.status) };
   }
   return { status: "timeout" };
 }
+function describePollError(error) {
+  if (error === "unknown_session") {
+    return "the server restarted while you were signing in, so this code no longer works. Sign in again.";
+  }
+  if (error === "login_unavailable") {
+    return "GitHub approved the sign-in, but the server could not finish it. Try again in a minute.";
+  }
+  return error;
+}
 async function devLogin(client, config, email, invite) {
   let res;
   try {
@@ -1517,7 +1652,7 @@ function sleep2(ms, signal) {
     signal.addEventListener("abort", done, { once: true });
   });
 }
-var TERMS_URL, PRIVACY_URL, TERMS_NOTICE;
+var TERMS_URL, PRIVACY_URL, TERMS_NOTICE, UNAVAILABLE_GIVE_UP_MS;
 var init_login = __esm({
   "src/login.ts"() {
     "use strict";
@@ -1529,6 +1664,7 @@ var init_login = __esm({
     TERMS_NOTICE = `By creating an account you confirm that you are at least 18 and that you agree to
 the Terms \u2014 ${TERMS_URL}
 and the Privacy Policy \u2014 ${PRIVACY_URL}`;
+    UNAVAILABLE_GIVE_UP_MS = 18e4;
   }
 });
 
@@ -4055,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.
@@ -4108,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 })
@@ -4979,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 = [];
@@ -5069,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 = [
@@ -5342,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
@@ -5865,6 +6055,7 @@ function App({
   notices: notices2,
   sponsorServe,
   sponsorFormats,
+  sponsorDirect,
   initHint
 }) {
   const { exit } = useApp();
@@ -5905,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) => {
@@ -5973,6 +6165,8 @@ function App({
   const sponsorPrevRef = useRef(void 0);
   const sponsorCallRef = useRef(0);
   const pendingImpressionRef = useRef(/* @__PURE__ */ new Map());
+  const pendingDirectRef = useRef(/* @__PURE__ */ new Map());
+  const directSupportedRef = useRef(true);
   const drawnRef = useRef(/* @__PURE__ */ new Set());
   const sponsorSlotRef = useRef(
     /* @__PURE__ */ new Map()
@@ -6184,8 +6378,7 @@ function App({
       } else {
         setSponsor(null);
       }
-      for (const format of ["top_bar", ...EXTRA_AD_FORMATS]) {
-        if (!adFitsFormat(format, colsRef.current)) continue;
+      const fetchNetwork = (format) => {
         void remoteSponsorRef.current[format].fetch().then((line2) => {
           if (!line2 || call !== sponsorCallRef.current) return;
           if (!adFitsFormat(format, colsRef.current)) return;
@@ -6203,15 +6396,55 @@ function App({
           recordImpression(tallyRef.current, line2.id);
           pendingImpressionRef.current.set(format, { call, impression: line2.impression });
         });
-      }
+      };
+      const paintDirect = (line2) => {
+        const { format } = line2;
+        if (call !== sponsorCallRef.current) return;
+        if (!adFitsFormat(format, colsRef.current)) return;
+        if (format !== "top_bar" && modalOpenRef.current) return;
+        const drawnId = `direct:${call}:${format}`;
+        if (format === "top_bar") {
+          if (!sponsorRow(line2.text, colsRef.current, "network")) return;
+          setSponsor({ text: line2.text, origin: "network", impressionId: drawnId });
+        } else {
+          setAdSlots((slots) => ({ ...slots, [format]: { text: line2.text, impressionId: drawnId } }));
+        }
+        pendingDirectRef.current.set(format, { call, serveToken: line2.serveToken, drawnId });
+      };
+      const fitting = AD_FORMATS.filter((format) => adFitsFormat(format, colsRef.current));
+      void (async () => {
+        let direct = [];
+        if (directSupportedRef.current && fitting.length > 0) {
+          const ask3 = sponsorDirect ?? ((formats, cols2, signal) => client.directSponsor(formats, cols2, signal));
+          let answer = { supported: true, lines: [] };
+          try {
+            answer = await ask3(fitting, colsRef.current, AbortSignal.timeout(DIRECT_ASK_TIMEOUT_MS));
+          } catch {
+          }
+          if (!answer.supported) directSupportedRef.current = false;
+          direct = answer.lines;
+        }
+        if (call !== sponsorCallRef.current) return;
+        for (const format of ["top_bar", ...EXTRA_AD_FORMATS]) {
+          if (!adFitsFormat(format, colsRef.current)) continue;
+          const booked = direct.find((line2) => line2.format === format);
+          if (booked && "hold" in booked) continue;
+          if (booked) paintDirect(booked);
+          else fetchNetwork(format);
+        }
+      })();
     },
-    [config.sponsor, stdout, wallet]
+    [config.sponsor, stdout, wallet, client, sponsorDirect]
   );
   const reportSponsor = useCallback(() => {
     const pending = [...pendingImpressionRef.current.values()];
+    const pendingDirect = [...pendingDirectRef.current.entries()];
     const drawn = drawnRef.current;
     pendingImpressionRef.current = /* @__PURE__ */ new Map();
+    pendingDirectRef.current = /* @__PURE__ */ new Map();
     drawnRef.current = /* @__PURE__ */ new Set();
+    const directReports = pendingDirect.filter(([, p]) => p.call === sponsorCallRef.current && drawn.has(p.drawnId)).map(([format, p]) => ({ format, serveToken: p.serveToken }));
+    if (directReports.length > 0) void client.reportDirectImpressions(directReports);
     const reports = pending.filter((p) => p.call === sponsorCallRef.current).filter((p) => drawn.has(p.impression.impressionId)).map((p) => p.impression);
     if (reports.length === 0) return;
     void (async () => {
@@ -6353,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);
@@ -6367,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,
@@ -6836,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));
@@ -6888,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);
@@ -7562,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 } : {} });
@@ -7574,6 +7870,7 @@ ${dropped.map((l) => `  \xB7 ${l}`).join("\n")}`
     `  ${statusLine(
       {
         model,
+        ...effortNow ? { effort: effortNow } : {},
         balance,
         spent,
         contextPct,
@@ -7772,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.
@@ -7857,6 +8156,7 @@ var init_app = __esm({
     init_todos();
     init_shells();
     init_config();
+    init_effort();
     init_login();
     init_banner();
     init_agent();
@@ -7876,6 +8176,7 @@ var init_app = __esm({
     init_provider();
     init_network();
     init_formats();
+    init_direct();
     init_render();
     init_commands();
     init_editor();
@@ -8004,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();
@@ -8300,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 ? "" : `
 
@@ -8445,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.24",
+  "version": "0.0.1-beta.26",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "UNLICENSED",
   "type": "module",