tinker-agent 1.8.0 → 1.10.1

package/src/tools/types.ts

@@ -144,6 +144,24 @@ export type TaskListRawResult = {
   error?: string;
 };
 
+export type PlanStepStatus = "pending" | "in_progress" | "completed";
+
+export type PlanStep = {
+  step: string;
+  status: PlanStepStatus;
+};
+
+export type UpdatePlanRawResult =
+  | {
+      ok: true;
+      explanation?: string;
+      plan: PlanStep[];
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
 export type TaskOutputRawResult = {
   ok: boolean;
   taskId: string;
@@ -355,6 +373,7 @@ export type ToolRawResultByKind = {
   glob: GlobRawResult;
   grep: GrepRawResult;
   bash: BashRawResult;
+  update_plan: UpdatePlanRawResult;
   task_list: TaskListRawResult;
   task_output: TaskOutputRawResult;
   task_input: TaskInputRawResult;

package/src/tools/update-plan.ts

@@ -0,0 +1,166 @@
+import { throwIfTurnCancelled } from "../agent/turn-cancellation";
+import {
+  defineToolExecutor,
+  type PlanStep,
+  type ToolExecutionContext,
+  type ToolExecutor,
+  type UpdatePlanRawResult,
+} from "./types";
+
+const MAX_PLAN_ITEMS = 12;
+const MAX_STEP_LENGTH = 200;
+const MAX_EXPLANATION_LENGTH = 500;
+const STATUSES = new Set(["pending", "in_progress", "completed"]);
+
+export function createUpdatePlanToolExecutor(): ToolExecutor {
+  return defineToolExecutor("update_plan", {
+    definition: {
+      name: "UpdatePlan",
+      description:
+        "Replace the current task plan with a complete ordered list of steps and their progress. Use an optional explanation when revising the approach. At most one step may be in_progress.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          explanation: {
+            type: "string",
+            maxLength: MAX_EXPLANATION_LENGTH,
+            description: "Optional explanation for this plan update.",
+          },
+          plan: {
+            type: "array",
+            maxItems: MAX_PLAN_ITEMS,
+            description: "The complete ordered task plan.",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                step: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: MAX_STEP_LENGTH,
+                  description: "Task step text.",
+                },
+                status: {
+                  type: "string",
+                  enum: ["pending", "in_progress", "completed"],
+                  description: "Step status.",
+                },
+              },
+              required: ["step", "status"],
+            },
+          },
+        },
+        required: ["plan"],
+      },
+    },
+    async execute(
+      args,
+      _call,
+      context: ToolExecutionContext,
+    ): Promise<UpdatePlanRawResult> {
+      throwIfTurnCancelled(context.signal);
+      const parsed = parseUpdatePlanArgs(args);
+      if (!parsed.ok) {
+        return parsed;
+      }
+      throwIfTurnCancelled(context.signal);
+      return {
+        ok: true,
+        ...(parsed.explanation === undefined
+          ? {}
+          : { explanation: parsed.explanation }),
+        plan: parsed.plan,
+      };
+    },
+  });
+}
+
+type ParsedUpdatePlanArgs =
+  | { ok: true; explanation?: string; plan: PlanStep[] }
+  | { ok: false; error: string };
+
+function parseUpdatePlanArgs(args: unknown): ParsedUpdatePlanArgs {
+  if (!isRecord(args)) {
+    return failure("UpdatePlan arguments must be an object.");
+  }
+  const unexpected = Object.keys(args).find(
+    (key) => key !== "explanation" && key !== "plan",
+  );
+  if (unexpected !== undefined) {
+    return failure(`UpdatePlan received unexpected argument: ${unexpected}.`);
+  }
+  if (!Array.isArray(args.plan)) {
+    return failure("UpdatePlan plan must be an array.");
+  }
+  if (args.plan.length > MAX_PLAN_ITEMS) {
+    return failure(`UpdatePlan accepts at most ${MAX_PLAN_ITEMS} steps.`);
+  }
+
+  let explanation: string | undefined;
+  if (args.explanation !== undefined) {
+    if (typeof args.explanation !== "string") {
+      return failure("UpdatePlan explanation must be a string.");
+    }
+    explanation = args.explanation.trim();
+    if (explanation.length > MAX_EXPLANATION_LENGTH) {
+      return failure(
+        `UpdatePlan explanation must be at most ${MAX_EXPLANATION_LENGTH} characters.`,
+      );
+    }
+    if (explanation === "") {
+      explanation = undefined;
+    }
+  }
+
+  const plan: PlanStep[] = [];
+  let inProgressCount = 0;
+  for (const [index, item] of args.plan.entries()) {
+    if (!isRecord(item)) {
+      return failure(`UpdatePlan plan[${index}] must be an object.`);
+    }
+    const unexpectedItemKey = Object.keys(item).find(
+      (key) => key !== "step" && key !== "status",
+    );
+    if (unexpectedItemKey !== undefined) {
+      return failure(
+        `UpdatePlan plan[${index}] received unexpected field: ${unexpectedItemKey}.`,
+      );
+    }
+    if (typeof item.step !== "string" || item.step.trim() === "") {
+      return failure(`UpdatePlan plan[${index}].step must be a non-empty string.`);
+    }
+    const step = item.step.trim();
+    if (step.length > MAX_STEP_LENGTH) {
+      return failure(
+        `UpdatePlan plan[${index}].step must be at most ${MAX_STEP_LENGTH} characters.`,
+      );
+    }
+    if (typeof item.status !== "string" || !STATUSES.has(item.status)) {
+      return failure(
+        `UpdatePlan plan[${index}].status must be pending, in_progress, or completed.`,
+      );
+    }
+    if (item.status === "in_progress") {
+      inProgressCount += 1;
+    }
+    plan.push({ step, status: item.status as PlanStep["status"] });
+  }
+  if (inProgressCount > 1) {
+    return failure("UpdatePlan allows at most one in_progress step.");
+  }
+
+  return {
+    ok: true,
+    ...(explanation === undefined ? {} : { explanation }),
+    plan,
+  };
+}
+
+function failure(error: string): ParsedUpdatePlanArgs {
+  return { ok: false, error };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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/plan-view.tsx

@@ -0,0 +1,43 @@
+import { Box, Text } from "ink";
+import type { TimelineItem } from "../event-store";
+
+export function PlanView(props: { plan: NonNullable<TimelineItem["plan"]> }) {
+  return (
+    <Box flexDirection="column" marginLeft={2}>
+      {props.plan.explanation === undefined ? null : (
+        <Text dimColor italic>
+          {props.plan.explanation}
+        </Text>
+      )}
+      {props.plan.steps.length === 0 ? (
+        <Text dimColor italic>
+          (no steps)
+        </Text>
+      ) : (
+        props.plan.steps.map((step, index) => (
+          <PlanStepRow key={`${index}:${step.step}`} step={step} />
+        ))
+      )}
+    </Box>
+  );
+}
+
+function PlanStepRow(props: {
+  step: NonNullable<TimelineItem["plan"]>["steps"][number];
+}) {
+  if (props.step.status === "completed") {
+    return (
+      <Text dimColor strikethrough>
+        ✓ {props.step.step}
+      </Text>
+    );
+  }
+  if (props.step.status === "in_progress") {
+    return (
+      <Text color="cyan" bold>
+        → {props.step.step}
+      </Text>
+    );
+  }
+  return <Text dimColor>• {props.step.step}</Text>;
+}

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/components/timeline.tsx

@@ -5,6 +5,7 @@ import type { AssistantStreamSectionItem } from "../tui-projection-store";
 import { AssistantMarkdown } from "./assistant-markdown";
 import { BashResultView } from "./bash-result-view";
 import { DiffView } from "./diff-view";
+import { PlanView } from "./plan-view";
 
 export type TimelineProps = {
   items: readonly TimelineItem[];
@@ -42,6 +43,7 @@ export function TimelineRow(props: { item: TimelineItem }) {
         )}
         {renderItemBash(item)}
         {renderItemDiff(item)}
+        {renderItemPlan(item)}
       </Fragment>
     );
   }
@@ -51,6 +53,7 @@ export function TimelineRow(props: { item: TimelineItem }) {
       <Text color={colorForStatus(item.status)}>{formatTimelineItem(item)}</Text>
       {renderItemBash(item)}
       {renderItemDiff(item)}
+      {renderItemPlan(item)}
     </Fragment>
   );
 }
@@ -105,6 +108,10 @@ function renderItemBash(item: TimelineItem) {
   return <BashResultView detail={item.bash} />;
 }
 
+function renderItemPlan(item: TimelineItem) {
+  return item.plan === undefined ? null : <PlanView plan={item.plan} />;
+}
+
 function formatTimelineItem(item: TimelineItem): string {
   if (item.status === "text") {
     return item.text;

package/src/tui/event-store.ts

@@ -11,7 +11,7 @@ import type {
 } from "../model/model-context-profile";
 import type { ShellTaskSnapshot, ShellTaskStatus } from "../tools/bash-task";
 import { countPatchChanges } from "../tools/file-diff";
-import type { DiffHunk, ToolRawResult } from "../tools/types";
+import type { DiffHunk, PlanStep, ToolRawResult } from "../tools/types";
 import {
   defaultTuiProjectionPolicy,
   type TuiProjectionPolicy,
@@ -33,6 +33,10 @@ export type TimelineItem = {
   diffTruncated?: boolean;
   bash?: BashDisplayDetail;
   userPrompt?: UserPromptProjection;
+  plan?: {
+    explanation?: string;
+    steps: readonly PlanStep[];
+  };
 };
 
 export type TuiTurnProjection = {
@@ -747,11 +751,12 @@ export function toolCallStartedProjection(input: {
 export function toolRawResultProjection(
   input: { name: string; args: unknown },
   raw: ToolRawResult,
-): Pick<TimelineItem, "text" | "bash" | "diff" | "diffTruncated"> {
+): Pick<TimelineItem, "text" | "bash" | "diff" | "diffTruncated" | "plan"> {
   return {
     text: toolRawResultSummary(input.name, input.args, raw),
     ...toolRawResultDiff(raw),
     ...toolRawResultBashDetail(raw),
+    ...toolRawResultPlanDetail(raw),
   };
 }
 
@@ -888,6 +893,13 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
           : `${base} -> running ${raw.outputFilePath}`;
       }
       return raw.exitCode === undefined ? base : `${base} -> exit ${raw.exitCode}`;
+    case "update_plan": {
+      if (!raw.ok) {
+        return base;
+      }
+      const completed = raw.plan.filter((step) => step.status === "completed").length;
+      return `${base} -> ${completed}/${raw.plan.length} completed`;
+    }
     case "mcp":
     case "generic":
       return base;
@@ -929,6 +941,7 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
     case "delete":
     case "glob":
     case "grep":
+    case "update_plan":
     case "task_list":
     case "task_stop":
     case "web_search":
@@ -964,6 +977,7 @@ function toolRawResultDiff(
     case "glob":
     case "grep":
     case "bash":
+    case "update_plan":
     case "task_list":
     case "task_output":
     case "task_input":
@@ -981,6 +995,18 @@ function toolRawResultDiff(
   }
 }
 
+function toolRawResultPlanDetail(raw: ToolRawResult): Pick<TimelineItem, "plan"> {
+  if (raw.kind !== "update_plan" || !raw.ok) {
+    return {};
+  }
+  return {
+    plan: {
+      ...(raw.explanation === undefined ? {} : { explanation: raw.explanation }),
+      steps: raw.plan.map((step) => ({ ...step })),
+    },
+  };
+}
+
 function upsertBackgroundTask(
   tasks: ShellTaskSnapshot[],
   task: ShellTaskSnapshot,

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(