tinker-agent 2.8.0 → 2.10.0

package/src/tools/task-output-tool.ts

@@ -1,6 +1,6 @@
-import type { ShellTaskManager } from "./bash-task";
+import type { ShellTaskInspection, ShellTaskManager } from "./bash-task";
 import { throwIfTurnCancelled } from "../agent/turn-cancellation";
-import { parseTaskIdArgs } from "./task-tool-args";
+import { parseTaskOutputArgs } from "./task-tool-args";
 import { defineToolExecutor } from "./types";
 import type { TaskOutputRawResult, ToolExecutionContext, ToolExecutor } from "./types";
 
@@ -10,7 +10,8 @@ export function createTaskOutputToolExecutor(options: {
   return defineToolExecutor("task_output", {
     definition: {
       name: "TaskOutput",
-      description: "Get the current status and latest output of a shell task.",
+      description:
+        "Get a shell task's status and output. Defaults to a head/tail log preview or current PTY screen. For non-PTY tasks, offset/limit selects consecutive numbered log lines instead; PTY tasks ignore these parameters. truncated means content within the requested range was shortened by byte limits, not that other log lines exist. When polling a running log, reread its last line because it may still be growing.",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -19,6 +20,20 @@ export function createTaskOutputToolExecutor(options: {
             type: "string",
             description: "The task ID returned by Bash or TaskList.",
           },
+          offset: {
+            type: "integer",
+            minimum: 1,
+            maximum: Number.MAX_SAFE_INTEGER,
+            description:
+              "1-based starting log line. Supplying offset or limit selects consecutive lines; default offset is 1. Ignored for PTY tasks.",
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: Number.MAX_SAFE_INTEGER,
+            description:
+              "Maximum number of consecutive log lines to read (default 200 in range mode), subject to byte limits. Ignored for PTY tasks.",
+          },
         },
         required: ["task_id"],
       },
@@ -29,12 +44,26 @@ export function createTaskOutputToolExecutor(options: {
       context: ToolExecutionContext,
     ): Promise<TaskOutputRawResult> {
       throwIfTurnCancelled(context.signal);
-      const parsed = parseTaskIdArgs(args, "TaskOutput");
+      const parsed = parseTaskOutputArgs(args);
       if (!parsed.ok) {
         return { ok: false, taskId: "", error: parsed.error };
       }
 
-      const inspection = await options.taskManager.inspectTaskOutput(parsed.taskId);
+      let inspection: ShellTaskInspection | undefined;
+      try {
+        inspection = await options.taskManager.inspectTaskOutput(
+          parsed.taskId,
+          parsed.range,
+          context.signal,
+        );
+      } catch (error) {
+        throwIfTurnCancelled(context.signal);
+        return {
+          ok: false,
+          taskId: parsed.taskId,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
       throwIfTurnCancelled(context.signal);
       if (inspection === undefined) {
         return {
@@ -55,6 +84,7 @@ export function createTaskOutputToolExecutor(options: {
         preview: inspection.output.preview,
         truncated: inspection.output.truncated,
         omittedLines: inspection.output.omittedLines,
+        range: inspection.output.range,
         outputFilePath: inspection.task.outputFilePath,
         screenRows: inspection.screenRows,
         screenColumns: inspection.screenColumns,

package/src/tools/task-output.ts

@@ -9,7 +9,14 @@ import {
   type OutputPreviewSource,
 } from "./bounded-output-preview";
 
+import {
+  readTaskOutputRange,
+  type TaskOutputRange,
+  type TaskOutputRangeRequest,
+} from "./task-output-range";
+
 export type TaskOutputSnapshot = {
+  range?: TaskOutputRange;
   outputBytes: number;
   outputLines: number;
   preview: string;
@@ -48,6 +55,34 @@ export class TaskOutput {
     return this.endPromise;
   }
 
+  async readRange(
+    range: TaskOutputRangeRequest,
+    signal?: AbortSignal,
+  ): Promise<TaskOutputSnapshot> {
+    const ended = this.endPromise !== undefined;
+    if (ended) {
+      await this.endPromise;
+    }
+    const snapshot = this.snapshot();
+    if (!ended) {
+      // A write callback is a barrier for all bytes captured above; later writes
+      // may proceed, but the reader remains bounded to snapshot.outputBytes.
+      await new Promise<void>((resolve, reject) => {
+        this.stream.write(Buffer.alloc(0), (error) => {
+          if (error) reject(error);
+          else resolve();
+        });
+      });
+    }
+    return readTaskOutputRange({
+      filePath: this.filePath,
+      snapshot,
+      range,
+      ended,
+      signal,
+    });
+  }
+
   private async finish(): Promise<TaskOutputSnapshot> {
     this.appendText(this.decoder.end());
     if (this.pendingLine !== "") {

package/src/tools/task-stop.ts

@@ -37,12 +37,13 @@ export function createTaskStopToolExecutor(options: {
       try {
         const result = await options.taskManager.stopTask(parsed.taskId, "tool");
         return {
-          ok: true,
+          ok: result.task.error === undefined,
           taskId: parsed.taskId,
           task: result.task,
           status: result.task.status,
           requestedSignal: result.requestedSignal,
           escalated: result.escalated,
+          ...(result.task.error === undefined ? {} : { error: result.task.error }),
         };
       } catch (error) {
         const inspection = options.taskManager.inspectTask(parsed.taskId);

package/src/tools/task-tool-args.ts

@@ -24,6 +24,40 @@ export function parseTaskIdArgs(
   return { ok: true, taskId: args.task_id };
 }
 
+export function parseTaskOutputArgs(args: unknown):
+  | {
+      ok: true;
+      taskId: string;
+      range?: { offset: number; limit: number };
+    }
+  | { ok: false; error: string } {
+  if (!isRecord(args)) {
+    return { ok: false, error: "TaskOutput arguments must be an object." };
+  }
+  const { offset, limit, ...rest } = args;
+  const parsed = parseTaskIdArgs(rest, "TaskOutput");
+  if (!parsed.ok) return parsed;
+  for (const [name, value] of Object.entries({ offset, limit })) {
+    if (
+      value !== undefined &&
+      (!Number.isSafeInteger(value) || (value as number) < 1)
+    ) {
+      return {
+        ok: false,
+        error: `TaskOutput.${name} must be a positive safe integer.`,
+      };
+    }
+  }
+  if (offset === undefined && limit === undefined) return parsed;
+  return {
+    ...parsed,
+    range: {
+      offset: (offset as number | undefined) ?? 1,
+      limit: (limit as number | undefined) ?? 200,
+    },
+  };
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/tools/terminal-screen.ts

@@ -3,16 +3,25 @@ import { Terminal } from "@xterm/headless";
 
 export const TERMINAL_SCREEN_ROWS = 24;
 export const TERMINAL_SCREEN_COLUMNS = 80;
+export const MIN_TERMINAL_COLUMNS = 2;
+export const MAX_TERMINAL_DIMENSION = 1_000;
 
 export type TerminalScreen = {
+  readonly rows: number;
+  readonly columns: number;
   write(bytes: Uint8Array): Promise<void>;
   flush(): Promise<void>;
   text(): string;
   dispose(): void;
 };
 
-export function createTerminalScreen(): TerminalScreen {
-  return new HeadlessTerminalScreen(TERMINAL_SCREEN_ROWS, TERMINAL_SCREEN_COLUMNS);
+export function createTerminalScreen(
+  options: { cols?: number; rows?: number } = {},
+): TerminalScreen {
+  return new HeadlessTerminalScreen(
+    options.rows ?? TERMINAL_SCREEN_ROWS,
+    options.cols ?? TERMINAL_SCREEN_COLUMNS,
+  );
 }
 
 export class HeadlessTerminalScreen implements TerminalScreen {

package/src/tools/types.ts

@@ -9,6 +9,7 @@ import type {
 } from "../session/session-history-reader";
 import type { ShellTaskSnapshot, ShellTaskStatus } from "./bash-task";
 import type { SkillScope } from "../skills/skill-loader";
+import type { TaskOutputRange } from "./task-output-range";
 
 export type JsonSchema = Record<string, unknown>;
 
@@ -91,16 +92,27 @@ export type DeleteFileRawResult = {
 
 export type GlobRawResult = {
   ok: boolean;
-  pattern: string;
+  pattern?: string;
   searchPath: string;
   absoluteSearchPath?: string;
   matches?: string[];
+  /** Number of paths returned, including in legacy unpaginated results. */
   matchCount?: number;
+  /** Exact total before pagination; absent in legacy results. */
+  totalMatches?: number;
+  returnedCount?: number;
+  appliedOffset?: number;
+  hasMore?: boolean;
+  nextOffset?: number;
   ignored?: string[];
   error?: string;
 };
 
-export type GrepOutputMode = "content" | "files_with_matches" | "count";
+export type GrepOutputMode =
+  | "content"
+  | "files_with_matches"
+  | "count"
+  | "count-matches";
 
 export type GrepRawResult = {
   ok: boolean;
@@ -112,10 +124,27 @@ export type GrepRawResult = {
   numFiles: number;
   content?: string;
   numLines?: number;
+  /** Structured count records; paths are unescaped and never parsed from display text. */
+  counts?: { filePath: string; count: number }[];
+  /** Sum on this page: matching lines for count, individual matches for count-matches. */
   numMatches?: number;
+  /** Collected pagination units; legacy content results counted all output lines. Not a global total if searchIncomplete. */
+  totalResults?: number;
+  /** Selected pagination units, excluding context and nearby matches shown as context. */
+  returnedResults?: number;
+  paginationUnit?: "matching_lines" | "match_events" | "files";
+  /** More collected pagination units are available, independently of search completeness. */
+  hasMore?: boolean;
+  nextOffset?: number;
   appliedLimit?: number;
   appliedOffset?: number;
+  /** True for interrupted searches (e.g. timeout or output buffer limit), not pagination. */
+  searchIncomplete?: boolean;
+  /** The search stopped early, so requested context cannot be guaranteed complete. */
+  contextMayBeIncomplete?: boolean;
+  /** Legacy default exclusions, not observed skips. New Grep results omit this field. */
   ignored?: string[];
+  /** Compatibility flag combining pagination and interrupted search; prefer explicit fields above. */
   truncated?: boolean;
   error?: string;
 };
@@ -173,6 +202,7 @@ export type UpdatePlanRawResult =
     };
 
 export type TaskOutputRawResult = {
+  range?: TaskOutputRange;
   ok: boolean;
   taskId: string;
   task?: ShellTaskSnapshot;
@@ -273,6 +303,7 @@ export type GenericToolRawResult = {
 };
 
 export type RecallToolErrorCode =
+  | import("../session/session-history-access").RecallSessionErrorCode
   | "RECALL_ARGS_INVALID"
   | "RECALL_SOURCE_INVALID"
   | "RECALL_SOURCE_NOT_FOUND"
@@ -284,6 +315,9 @@ export type RecallSearchRawResult =
       ok: true;
       mode: "search";
       historical: true;
+      /** Optional only for persisted results produced before session selection. */
+      sessionId?: SessionId;
+      workspaceRoot?: string;
       query: string;
       filters: RecallSearchFilters;
       page: RecallSearchPage;
@@ -300,6 +334,9 @@ export type RecallGetRawResult =
       ok: true;
       mode: "get";
       historical: true;
+      /** Optional only for persisted results produced before session selection. */
+      sessionId?: SessionId;
+      workspaceRoot?: string;
       page: RecallGetPage;
     }
   | {

package/src/tui/event-store.ts

@@ -873,6 +873,9 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         ? base
         : `${base} -> ${raw.asset.mimeType}, ${raw.asset.width}x${raw.asset.height}, ${raw.asset.byteLength} bytes`;
     case "glob":
+      if (raw.ok && raw.totalMatches !== undefined) {
+        return `${base} -> ${raw.returnedCount ?? raw.matches?.length ?? 0} of ${raw.totalMatches} matches`;
+      }
       return raw.ok && raw.matchCount !== undefined
         ? `${base} -> ${raw.matchCount} match${raw.matchCount === 1 ? "" : "es"}`
         : base;
@@ -881,11 +884,21 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         return `${base} -> ${raw.numLines} line${raw.numLines === 1 ? "" : "s"}`;
       }
       if (
-        raw.mode === "count" &&
+        (raw.mode === "count" || raw.mode === "count-matches") &&
         raw.numMatches !== undefined &&
         raw.numFiles !== undefined
       ) {
-        return `${base} -> ${raw.numMatches} match${raw.numMatches === 1 ? "" : "es"} across ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}`;
+        const unit =
+          raw.mode === "count"
+            ? `matching line${raw.numMatches === 1 ? "" : "s"}`
+            : `match${raw.numMatches === 1 ? "" : "es"}`;
+        const scope =
+          raw.appliedLimit !== undefined || (raw.appliedOffset ?? 0) > 0
+            ? " (this page)"
+            : raw.truncated
+              ? " (partial results)"
+              : "";
+        return `${base} -> ${raw.numMatches} ${unit} across ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}${scope}`;
       }
       return `${base} -> ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}`;
     case "read":
@@ -922,13 +935,18 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
       return raw.route === undefined
         ? base
         : `${base} -> ok (${raw.route}${raw.refined === true ? ", refined" : ""})`;
-    case "recall":
+    case "recall": {
       if (!raw.ok) {
         return base;
       }
+      const provenance =
+        raw.sessionId === undefined
+          ? ""
+          : ` [session=${raw.sessionId}, workspace=${raw.workspaceRoot ?? "unknown"}]`;
       return raw.mode === "search"
-        ? `${base} -> ${raw.page.hits.length} historical match${raw.page.hits.length === 1 ? "" : "es"}`
-        : `${base} -> ${raw.page.returnedBytes} historical bytes`;
+        ? `${base} -> ${raw.page.hits.length} historical match${raw.page.hits.length === 1 ? "" : "es"}${provenance}`
+        : `${base} -> ${raw.page.returnedBytes} historical bytes${provenance}`;
+    }
     case "context_maintenance":
       if (!raw.ok) {
         return raw.operation === "swap"

package/src/tui/remote-app.tsx

@@ -0,0 +1,210 @@
+import { Box, Text, useApp, useInput } from "ink";
+import { TextInput } from "@inkjs/ui";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { RemoteClient } from "../remote/client";
+import type { RemoteSessionInfo } from "../remote/protocol";
+
+/** An explicit network client mode; the normal App/controller path is untouched. */
+export function RemoteApp({ client }: { client: RemoteClient }) {
+  const state = useSyncExternalStore(client.subscribe, client.getSnapshot);
+  const { exit } = useApp();
+  const [workspaces, setWorkspaces] = useState<{ id: string; name: string }[]>([]);
+  const [sessions, setSessions] = useState<RemoteSessionInfo[]>([]);
+  const [workspace, setWorkspace] = useState<string | undefined>(client.workspaceId);
+  const [notice, setNotice] = useState(
+    "Select a workspace number. /workspaces returns here; /quit detaches.",
+  );
+  const [inputKey, setInputKey] = useState(0);
+  const [visibleCount, setVisibleCount] = useState(30);
+  const [browsing, setBrowsing] = useState(!client.sessionId);
+  const report = (error: unknown) =>
+    setNotice(error instanceof Error ? error.message : String(error));
+  useEffect(() => {
+    void client
+      .workspaces()
+      .then((result) => setWorkspaces(result.workspaces))
+      .catch(report);
+  }, [client]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") exit();
+  });
+  const submit = async (text: string) => {
+    setInputKey((value) => value + 1);
+    if (!text.trim()) return;
+    if (text === "/quit") {
+      exit();
+      return;
+    }
+    if (text === "/workspaces") {
+      setWorkspace(undefined);
+      setBrowsing(true);
+      setSessions([]);
+      setWorkspaces((await client.workspaces()).workspaces);
+      return;
+    }
+    if (browsing) {
+      if (!workspace) {
+        const chosen = workspaces[Number(text) - 1];
+        if (!chosen) throw new Error("Enter a workspace number.");
+        setWorkspace(chosen.id);
+        setSessions((await client.sessions(chosen.id)).sessions);
+        setNotice(
+          "Enter a session number, or /new. A local session is explicitly attached when selected.",
+        );
+      } else if (text === "/new") {
+        await client.submit({ kind: "create", workspaceId: workspace });
+        setBrowsing(false);
+      } else {
+        const chosen = sessions[Number(text) - 1];
+        if (!chosen) throw new Error("Enter a session number or /new.");
+        if (chosen.owner === "local")
+          await client.submit({
+            kind: "adopt",
+            workspaceId: workspace,
+            sessionId: chosen.id,
+          });
+        else await client.select(chosen.id, workspace);
+        setBrowsing(false);
+      }
+      return;
+    }
+    const sessionId = client.sessionId;
+    if (!sessionId) throw new Error("Waiting for the service to accept the session.");
+    const pending = state.view?.interaction;
+    if (text === "/stop") {
+      if (!state.view?.activeRequestId) throw new Error("No active task is shown.");
+      await client.submit({
+        kind: "stop",
+        sessionId,
+        targetRequestId: state.view.activeRequestId,
+      });
+    } else if (text === "/allow" || text === "/deny") {
+      if (pending?.kind !== "confirmation")
+        throw new Error("No confirmation is pending.");
+      await client.submit({
+        kind: "confirm",
+        sessionId,
+        interactionId: pending.id,
+        decision: text === "/allow" ? "allow" : "deny",
+      });
+    } else if (text.startsWith("/answer ") || text === "/dismiss") {
+      if (pending?.kind !== "question") throw new Error("No question is pending.");
+      await client.submit({
+        kind: "answer",
+        sessionId,
+        interactionId: pending.id,
+        selectedIndex: text === "/dismiss" ? null : Number(text.slice(8)) - 1,
+      });
+    } else if (text === "/history") {
+      await client.loadOlderHistory();
+      setVisibleCount((count) => count + 80);
+      setNotice(
+        "Older history loaded; use your terminal scrollback to read previous renders.",
+      );
+    } else if (text.startsWith("/")) {
+      throw new Error(
+        "Commands: /stop /allow /deny /answer N /dismiss /history /workspaces /quit",
+      );
+    } else {
+      await client.submit({ kind: "prompt", sessionId, prompt: text });
+    }
+  };
+  const view = state.view;
+  return (
+    <Box flexDirection="column">
+      <Text bold color="cyan">
+        Tinker · Service connection
+      </Text>
+      <Text>
+        {state.connection} · {view?.status ?? "select session"} · {state.pending}{" "}
+        unsubmitted
+      </Text>
+      <Text dimColor>{notice}</Text>
+      {state.error && <Text color="red">{safe(state.error)}</Text>}
+      {browsing ? (
+        <Box flexDirection="column">
+          {!workspace
+            ? workspaces.map((w, i) => (
+                <Text key={w.id}>
+                  {i + 1}. {safe(w.name)}
+                </Text>
+              ))
+            : sessions.map((s, i) => (
+                <Text key={s.id}>
+                  {i + 1}. {safe(s.title)} · {s.status} · {s.owner}
+                </Text>
+              ))}
+        </Box>
+      ) : (
+        <Box flexDirection="column">
+          <Text bold>{safe(view?.session.title ?? "Connecting…")}</Text>
+          {view?.history.messages.slice(-visibleCount).map((message) => (
+            <Box key={message.id} flexDirection="column" marginTop={1}>
+              <Text bold color={message.role === "user" ? "green" : "cyan"}>
+                {message.name ?? message.role}
+              </Text>
+              <Text>{safe(message.text)}</Text>
+              {message.toolCalls?.map((call) => (
+                <Text key={call.id} dimColor>
+                  {call.name} {safe(call.arguments)}
+                </Text>
+              ))}
+            </Box>
+          ))}
+          {view?.streaming && (
+            <Box flexDirection="column">
+              <Text dimColor>Generating…</Text>
+              <Text>{safe(view.streaming.text)}</Text>
+            </Box>
+          )}
+          {view?.tools
+            .filter((tool) => tool.status === "running")
+            .map((tool) => (
+              <Text key={tool.id} color="yellow">
+                {tool.name}: {safe(tool.arguments)}
+              </Text>
+            ))}
+          {view?.interaction?.kind === "question" && (
+            <Box flexDirection="column">
+              <Text color="yellow">{safe(view.interaction.question)}</Text>
+              {view.interaction.options.map((option, i) => (
+                <Text key={i}>
+                  {i + 1}. {safe(option.description)}
+                </Text>
+              ))}
+              <Text>/answer N or /dismiss</Text>
+            </Box>
+          )}
+          {view?.interaction?.kind === "confirmation" && (
+            <Box flexDirection="column">
+              <Text color="yellow">{safe(view.interaction.command)}</Text>
+              <Text>{safe(view.interaction.reason)} · /allow or /deny</Text>
+            </Box>
+          )}
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Text color="cyan">› </Text>
+        <TextInput
+          key={inputKey}
+          placeholder={
+            browsing
+              ? "Choose a workspace/session"
+              : "Send task; /stop cancels; /quit detaches"
+          }
+          onSubmit={(value) => {
+            void submit(value).catch(report);
+          }}
+        />
+      </Box>
+    </Box>
+  );
+}
+function safe(value: string): string {
+  return [...value]
+    .filter((character) => {
+      const code = character.codePointAt(0)!;
+      return code === 10 || code === 9 || (code >= 32 && (code < 127 || code > 159));
+    })
+    .join("");
+}