tinker-agent 1.9.0 → 1.10.1

package/src/tui/app.tsx

@@ -17,6 +17,7 @@ import {
 } from "../context/context-manager";
 import { ContextBudgetExceededError } from "../model/model-request-preflight";
 import { ModelRequestMediaAggregateError } from "../model/model-client";
+import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import type { SessionId } from "../ids/runtime-id";
 import { readLastAssistantResponse } from "../session/session-last-response-reader";
 import type { PromptHistory } from "./prompt-history";
@@ -180,15 +181,43 @@ export function App(props: AppProps) {
     state.activeTurn === undefined &&
     props.profiles !== undefined &&
     props.profiles.profiles.size > 1;
+  const reasoningEffort = binding.reasoningEffort?.();
+  const hasReasoningEffort = reasoningEffort !== undefined;
   const activeResumePicker =
     resumePicker?.ownerSessionId === binding.sessionId ? resumePicker : undefined;
 
-  const builtInCommands = canSwitchModel
-    ? SLASH_COMMANDS
-    : SLASH_COMMANDS.filter((command) => command.name !== "model");
+  const builtInCommands = SLASH_COMMANDS.filter(
+    (command) =>
+      (command.name !== "model" || canSwitchModel) &&
+      (command.name !== "reasoning" || hasReasoningEffort),
+  );
   const availableCommands = [...builtInCommands, ...(props.projectSlashCommands ?? [])];
 
   const profileList = props.profiles ? [...props.profiles.profiles.values()] : [];
+  const cycleReasoningEffort = () => {
+    const current = binding.reasoningEffort?.();
+    if (current === undefined) {
+      return;
+    }
+    const currentIndex = current.supportedEfforts.indexOf(current.effort);
+    const nextIndex =
+      currentIndex < 0 ? 0 : (currentIndex + 1) % current.supportedEfforts.length;
+    const nextEffort = current.supportedEfforts[nextIndex];
+    if (nextEffort === undefined) {
+      return;
+    }
+    try {
+      const updated = binding.setReasoningEffort?.(nextEffort);
+      if (updated === undefined) {
+        throw new Error("Reasoning effort control is unavailable.");
+      }
+      setNotice(
+        `Reasoning effort cycled from ${JSON.stringify(current.effort)} to ${JSON.stringify(updated.effort)} (Ctrl+R).`,
+      );
+    } catch (error) {
+      setNotice(errorMessage(error));
+    }
+  };
 
   useEffect(() => {
     if (readGitBranch === undefined) {
@@ -660,6 +689,42 @@ export function App(props: AppProps) {
           exit();
           return true;
         }
+        if (
+          command.type === "reasoning_status" ||
+          command.type === "reasoning_reset" ||
+          command.type === "reasoning_set"
+        ) {
+          const current = binding.reasoningEffort?.();
+          if (current === undefined) {
+            setNotice("Current model profile does not configure reasoning effort.");
+            return false;
+          }
+          try {
+            if (command.type === "reasoning_status") {
+              setNotice(formatReasoningEffortStatus(current));
+            } else if (command.type === "reasoning_reset") {
+              const reset = binding.resetReasoningEffort?.();
+              if (reset === undefined) {
+                throw new Error("Reasoning effort control is unavailable.");
+              }
+              setNotice(
+                `Reasoning effort reset to profile default ${JSON.stringify(reset.defaultEffort)}.`,
+              );
+            } else {
+              const updated = binding.setReasoningEffort?.(command.effort);
+              if (updated === undefined) {
+                throw new Error("Reasoning effort control is unavailable.");
+              }
+              setNotice(
+                `Reasoning effort set to ${JSON.stringify(updated.effort)} for this session runtime (profile default: ${JSON.stringify(updated.defaultEffort)}).`,
+              );
+            }
+          } catch (error) {
+            setNotice(errorMessage(error));
+            return false;
+          }
+          return true;
+        }
         if (command.type === "model" || command.type === "model_switch") {
           if (!canSwitchModel) {
             setNotice(
@@ -821,6 +886,7 @@ export function App(props: AppProps) {
               ) : (
                 <PromptInput
                   modelName={binding.modelName}
+                  reasoningEffort={reasoningEffort?.effort}
                   workspaceRoot={binding.workspaceRoot}
                   gitBranch={gitBranch}
                   contextUsage={state.contextUsage}
@@ -835,6 +901,9 @@ export function App(props: AppProps) {
                   fileLister={props.fileLister}
                   importImage={binding.importImage}
                   verifyImageAssets={binding.verifyImageAssets}
+                  onCycleReasoningEffort={
+                    hasReasoningEffort ? cycleReasoningEffort : undefined
+                  }
                   onSubmit={onSubmit}
                   onMaintenance={onMaintenance}
                   placeholder='Enter a coding request, or "/" for commands'
@@ -850,6 +919,14 @@ export function App(props: AppProps) {
   );
 }
 
+function formatReasoningEffortStatus(snapshot: ReasoningEffortSnapshot): string {
+  const source =
+    snapshot.source === "profile_default"
+      ? "profile default"
+      : `session override; profile default: ${snapshot.defaultEffort}`;
+  return `Reasoning effort: ${snapshot.effort} (${source}). Available: ${snapshot.supportedEfforts.join(", ")}.`;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
@@ -947,7 +1024,7 @@ export function formatContextRetirementNotice(result: ContextRetirementResult):
   const before = result.guardedTokensBefore.toLocaleString("en-US");
   const after = result.guardedTokensAfter.toLocaleString("en-US");
   if (result.outcome === "retirement_floor") {
-    return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens; target ${result.targetTokens.toLocaleString("en-US")} was not reached. Run /compact first when retained tool output is still eligible. Older history remains available through Recall.`;
+    return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens; target ${result.targetTokens.toLocaleString("en-US")} was not reached. Run /compact first when retained tool output is still eligible. Older history remains available through RecallSearch and RecallGet.`;
   }
   const reduction =
     result.guardedTokensBefore === 0
@@ -957,7 +1034,7 @@ export function formatContextRetirementNotice(result: ContextRetirementResult):
             result.guardedTokensBefore) *
           100
         ).toFixed(1);
-  return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens (-${reduction}%). Older history remains available through Recall.`;
+  return `Context prefix retired: revision ${result.previousRevisionNumber} -> ${result.revisionNumber}, ${result.retiredTurnCount} turns removed from the active request, ${before} -> ${after} estimated tokens (-${reduction}%). Older history remains available through RecallSearch and RecallGet.`;
 }
 
 export function formatContextRetirementFailureNotice(error: unknown): string {

package/src/tui/components/prompt-input.tsx

@@ -60,6 +60,7 @@ export type PromptSubmissionOutcome =
 
 export type PromptInputProps = {
   modelName: string;
+  reasoningEffort?: string;
   workspaceRoot: string;
   gitBranch?: string;
   contextUsage?: ContextUsageSnapshot;
@@ -81,6 +82,7 @@ export type PromptInputProps = {
     assets: readonly ImageAssetRef[],
     signal: AbortSignal,
   ) => Promise<void>;
+  onCycleReasoningEffort?: () => void;
   onSubmit: (
     submission: PromptSubmission,
     signal: AbortSignal,
@@ -605,6 +607,10 @@ export function PromptInput(props: PromptInputProps) {
         }
         return;
       }
+      if (key.ctrl && input === "r") {
+        props.onCycleReasoningEffort?.();
+        return;
+      }
       const selectedFile = fileMatches[selectedIndex];
       const selectedCommand = suggestions[selectedIndex];
       if (key.return) {
@@ -736,7 +742,9 @@ export function PromptInput(props: PromptInputProps) {
       {showSuggestions ? null : (
         <Box>
           <Text dimColor>
-            {props.modelName} · {formatWorkspacePath(props.workspaceRoot)}
+            {props.modelName}
+            {props.reasoningEffort === undefined ? null : ` ${props.reasoningEffort}`} ·{" "}
+            {formatWorkspacePath(props.workspaceRoot)}
             {props.gitBranch === undefined ? null : ` · ${props.gitBranch}`}
             {state.phase.kind === "idle" ? null : ` · ${phaseLabel(state.phase)}`}
           </Text>

package/src/tui/slash-commands.ts

@@ -65,6 +65,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/model [profile-name]",
     description: "Switch model profile (new session)",
   },
+  {
+    name: "reasoning",
+    usage: "/reasoning [effort|reset]",
+    description: "Show or change reasoning effort for this session runtime",
+  },
   {
     name: "resume",
     usage: "/resume [session-id]",
@@ -95,6 +100,9 @@ export type ParsedSlashCommand =
   | { type: "quit" }
   | { type: "model" }
   | { type: "model_switch"; profileName: string }
+  | { type: "reasoning_status" }
+  | { type: "reasoning_reset" }
+  | { type: "reasoning_set"; effort: string }
   | { type: "resume_list" }
   | { type: "resume"; sessionId: SessionId }
   | { type: "session_delete"; sessionId: SessionId };
@@ -193,6 +201,18 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
     }
     throw slashCommandUsageError("model");
   }
+  if (command === "/reasoning") {
+    if (tokens.length === 1) {
+      return { type: "reasoning_status" };
+    }
+    if (tokens.length === 2 && tokens[1] === "reset") {
+      return { type: "reasoning_reset" };
+    }
+    if (tokens.length === 2) {
+      return { type: "reasoning_set", effort: tokens[1] };
+    }
+    throw slashCommandUsageError("reasoning");
+  }
   if (command === "/resume") {
     if (tokens.length === 1) {
       return { type: "resume_list" };

package/src/tui/tui-session-controller.ts

@@ -18,6 +18,7 @@ import type { SessionId } from "../ids/runtime-id";
 import { createUuidV7 } from "../ids/uuid-v7";
 import type { ModelProfile } from "../cli/model-profiles";
 import type { McpInventorySnapshot } from "../mcp/mcp-manager";
+import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import { SessionCatalog, type SessionSummary } from "../session/session-catalog";
 import type { TuiProjectionStore } from "./tui-projection-store";
 
@@ -29,6 +30,9 @@ export type TuiSessionBinding = {
   projectionStore: TuiProjectionStore;
   skills(): RuntimeSkillsSnapshot;
   mcp(): McpInventorySnapshot;
+  reasoningEffort?: () => ReasoningEffortSnapshot | undefined;
+  setReasoningEffort?: (effort: string) => ReasoningEffortSnapshot;
+  resetReasoningEffort?: () => ReasoningEffortSnapshot;
   supportsImageInput?: () => boolean;
   importImage?: (
     sourcePath: string,
@@ -227,6 +231,9 @@ export function managedTuiBinding(input: {
     runtimeSession: input.runtimeSession,
     skills: () => input.runtimeSession.skills(),
     mcp: () => input.runtimeSession.mcp(),
+    reasoningEffort: () => input.runtimeSession.reasoningEffort(),
+    setReasoningEffort: (effort) => input.runtimeSession.setReasoningEffort(effort),
+    resetReasoningEffort: () => input.runtimeSession.resetReasoningEffort(),
     supportsImageInput: () => input.runtimeSession.supportsImageInput(),
     importImage: (sourcePath, signal, prospectiveMessageImageCount) =>
       input.runtimeSession.importImage(