tinker-agent 1.5.1 → 1.7.0

package/src/model/openai-chat-stream.ts

@@ -14,62 +14,61 @@ type ToolCallAccumulator = {
  * chat.completion-shaped object so the result can be validated and mapped by
  * fromOpenAIChatCompletion exactly like a non-streaming response.
  */
-export function accumulateOpenAIChatCompletionChunks(
-  chunks: readonly unknown[],
-  options: ProviderContext,
-): Record<string, unknown> {
-  if (chunks.length === 0) {
-    throw providerStreamError(options, "chunks", "must not be empty");
-  }
+export class OpenAIChatCompletionStreamAccumulator {
+  private chunkCount = 0;
+  private role: "assistant" | undefined;
+  private content: string | undefined;
+  private reasoningContent: string | undefined;
+  private finishReason: string | undefined;
+  private resolvedModel: string | undefined;
+  private usage: Record<string, unknown> | undefined;
+  private readonly toolCalls: ToolCallAccumulator[] = [];
 
-  let role: "assistant" | undefined;
-  let content: string | undefined;
-  let reasoningContent: string | undefined;
-  let finishReason: string | undefined;
-  let resolvedModel: string | undefined;
-  let usage: Record<string, unknown> | undefined;
-  const toolCalls: ToolCallAccumulator[] = [];
+  constructor(private readonly options: ProviderContext) {}
 
-  chunks.forEach((chunk, chunkIndex) => {
+  push(chunk: unknown): string | undefined {
+    const chunkIndex = this.chunkCount;
+    this.chunkCount += 1;
     const path = `chunk[${chunkIndex}]`;
-    const record = requireRecord(chunk, path, options);
+    const record = requireRecord(chunk, path, this.options);
+    let chunkContent: string | undefined;
 
     if (record.model !== undefined && record.model !== null) {
       if (typeof record.model !== "string" || record.model.trim() === "") {
-        throw providerStreamError(options, `${path}.model`, "must be a string");
+        throw providerStreamError(this.options, `${path}.model`, "must be a string");
       }
-      if (resolvedModel !== undefined && resolvedModel !== record.model) {
+      if (this.resolvedModel !== undefined && this.resolvedModel !== record.model) {
         throw providerStreamError(
-          options,
+          this.options,
           `${path}.model`,
-          `conflicts with previously streamed model ${JSON.stringify(resolvedModel)}`,
+          `conflicts with previously streamed model ${JSON.stringify(this.resolvedModel)}`,
         );
       }
-      resolvedModel = record.model;
+      this.resolvedModel = record.model;
     }
 
     if (record.usage !== undefined && record.usage !== null) {
-      usage = requireRecord(record.usage, `${path}.usage`, options);
+      this.usage = requireRecord(record.usage, `${path}.usage`, this.options);
     }
 
     if (record.choices === undefined || record.choices === null) {
-      return;
+      return chunkContent;
     }
     if (!Array.isArray(record.choices)) {
-      throw providerStreamError(options, `${path}.choices`, "must be an array");
+      throw providerStreamError(this.options, `${path}.choices`, "must be an array");
     }
     // The usage-only final chunk from stream_options.include_usage has empty choices.
     for (const [choiceIndex, rawChoice] of record.choices.entries()) {
       const choicePath = `${path}.choices[${choiceIndex}]`;
-      const choice = requireRecord(rawChoice, choicePath, options);
+      const choice = requireRecord(rawChoice, choicePath, this.options);
       if (choice.index !== 0) {
-        throw providerStreamError(options, `${choicePath}.index`, "must be 0");
+        throw providerStreamError(this.options, `${choicePath}.index`, "must be 0");
       }
       if (typeof choice.finish_reason === "string") {
-        finishReason = choice.finish_reason;
+        this.finishReason = choice.finish_reason;
       } else if (choice.finish_reason !== undefined && choice.finish_reason !== null) {
         throw providerStreamError(
-          options,
+          this.options,
           `${choicePath}.finish_reason`,
           "must be a string or null",
         );
@@ -79,82 +78,106 @@ export function accumulateOpenAIChatCompletionChunks(
         continue;
       }
       const deltaPath = `${choicePath}.delta`;
-      const delta = asRecord(choice.delta, deltaPath, options);
+      const delta = asRecord(choice.delta, deltaPath, this.options);
       if (delta.role !== undefined && delta.role !== null) {
         if (delta.role !== "assistant") {
           throw providerStreamError(
-            options,
+            this.options,
             `${deltaPath}.role`,
             'must be "assistant"',
           );
         }
-        role = delta.role;
+        this.role = delta.role;
       }
-      content = appendOptionalText(
-        content,
+      const contentDelta = appendOptionalText(
+        undefined,
         delta.content,
         `${deltaPath}.content`,
-        options,
+        this.options,
       );
-      reasoningContent = appendOptionalText(
-        reasoningContent,
+      if (contentDelta !== undefined) {
+        this.content = (this.content ?? "") + contentDelta;
+        chunkContent = (chunkContent ?? "") + contentDelta;
+      }
+      this.reasoningContent = appendOptionalText(
+        this.reasoningContent,
         delta.reasoning_content,
         `${deltaPath}.reasoning_content`,
-        options,
+        this.options,
       );
       if (delta.tool_calls === undefined || delta.tool_calls === null) {
         continue;
       }
       if (!Array.isArray(delta.tool_calls)) {
         throw providerStreamError(
-          options,
+          this.options,
           `${deltaPath}.tool_calls`,
           "must be an array",
         );
       }
       for (const [fragmentIndex, rawFragment] of delta.tool_calls.entries()) {
         mergeToolCallFragment(
-          toolCalls,
+          this.toolCalls,
           rawFragment,
           `${deltaPath}.tool_calls[${fragmentIndex}]`,
-          options,
+          this.options,
         );
       }
     }
-  });
+    return chunkContent;
+  }
 
-  // Only fields the provider actually streamed are emitted; the strict
-  // non-streaming mapper rejects a missing role, id, type, or name.
-  const message: Record<string, unknown> = {
-    ...(role === undefined ? {} : { role }),
-    content: content ?? null,
-    ...(reasoningContent === undefined ? {} : { reasoning_content: reasoningContent }),
-    ...(toolCalls.length === 0
-      ? {}
-      : {
-          tool_calls: toolCalls.map((call) => ({
-            ...(call.id === undefined ? {} : { id: call.id }),
-            ...(call.type === undefined ? {} : { type: call.type }),
-            function: {
-              ...(call.name === undefined ? {} : { name: call.name }),
-              arguments: call.arguments,
-            },
-          })),
-        }),
-  };
+  finish(): Record<string, unknown> {
+    if (this.chunkCount === 0) {
+      throw providerStreamError(this.options, "chunks", "must not be empty");
+    }
 
-  return {
-    object: "chat.completion",
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: finishReason ?? null,
-      },
-    ],
-    ...(usage === undefined ? {} : { usage }),
-    ...(resolvedModel === undefined ? {} : { model: resolvedModel }),
-  };
+    // Only fields the provider actually streamed are emitted; the strict
+    // non-streaming mapper rejects a missing role, id, type, or name.
+    const message: Record<string, unknown> = {
+      ...(this.role === undefined ? {} : { role: this.role }),
+      content: this.content ?? null,
+      ...(this.reasoningContent === undefined
+        ? {}
+        : { reasoning_content: this.reasoningContent }),
+      ...(this.toolCalls.length === 0
+        ? {}
+        : {
+            tool_calls: this.toolCalls.map((call) => ({
+              ...(call.id === undefined ? {} : { id: call.id }),
+              ...(call.type === undefined ? {} : { type: call.type }),
+              function: {
+                ...(call.name === undefined ? {} : { name: call.name }),
+                arguments: call.arguments,
+              },
+            })),
+          }),
+    };
+
+    return {
+      object: "chat.completion",
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason: this.finishReason ?? null,
+        },
+      ],
+      ...(this.usage === undefined ? {} : { usage: this.usage }),
+      ...(this.resolvedModel === undefined ? {} : { model: this.resolvedModel }),
+    };
+  }
+}
+
+export function accumulateOpenAIChatCompletionChunks(
+  chunks: readonly unknown[],
+  options: ProviderContext,
+): Record<string, unknown> {
+  const accumulator = new OpenAIChatCompletionStreamAccumulator(options);
+  for (const chunk of chunks) {
+    accumulator.push(chunk);
+  }
+  return accumulator.finish();
 }
 
 function mergeToolCallFragment(

package/src/observation/observation-builder.ts

@@ -1,6 +1,7 @@
 import type { ToolCall } from "../agent/types";
 import type {
   BashRawResult,
+  DeleteFileRawResult,
   EditFileRawResult,
   GenericToolRawResult,
   GlobRawResult,
@@ -10,6 +11,7 @@ import type {
   ReadFileRawResult,
   RecallRawResult,
   SkillRawResult,
+  TaskInputRawResult,
   TaskListRawResult,
   TaskOutputRawResult,
   TaskStopRawResult,
@@ -42,12 +44,16 @@ export class ObservationBuilder {
         return { content: renderWriteObservation(input.raw) };
       case "edit":
         return { content: renderEditObservation(input.raw) };
+      case "delete":
+        return { content: renderDeleteObservation(input.raw) };
       case "bash":
         return { content: renderBashObservation(input.raw) };
       case "task_list":
         return { content: renderTaskListObservation(input.raw) };
       case "task_output":
         return { content: renderTaskOutputObservation(input.raw) };
+      case "task_input":
+        return { content: renderTaskInputObservation(input.raw) };
       case "task_stop":
         return { content: renderTaskStopObservation(input.raw) };
       case "web_search":
@@ -308,6 +314,14 @@ function renderEditObservation(raw: EditFileRawResult): string {
   ].join("\n");
 }
 
+function renderDeleteObservation(raw: DeleteFileRawResult): string {
+  if (!raw.ok) {
+    return `Delete failed for ${raw.filePath || "(unknown path)"}: ${raw.error ?? "Unknown error."}`;
+  }
+
+  return `Delete succeeded for ${raw.filePath}.`;
+}
+
 function renderBashObservation(raw: BashRawResult): string {
   if (raw.taskId === "" && !raw.ok) {
     return `Bash failed: ${raw.error ?? "Unknown error."}`;
@@ -320,8 +334,11 @@ function renderBashObservation(raw: BashRawResult): string {
       `timeoutMs=${raw.timeoutMs ?? 0}`,
       `command=${raw.command}`,
       `cwd=${raw.cwd}`,
+      `tty=${raw.tty}`,
       `outputFilePath=${raw.outputFilePath}`,
-      "Use Read on outputFilePath to inspect current output.",
+      raw.tty
+        ? "Use TaskOutput to inspect the current terminal screen and TaskInput to interact."
+        : "Use TaskOutput to inspect current output.",
     ].join("\n");
   }
 
@@ -331,8 +348,11 @@ function renderBashObservation(raw: BashRawResult): string {
       `taskId=${raw.taskId}`,
       `command=${raw.command}`,
       `cwd=${raw.cwd}`,
+      `tty=${raw.tty}`,
       `outputFilePath=${raw.outputFilePath}`,
-      "Use Read on outputFilePath to inspect current output.",
+      raw.tty
+        ? "Use TaskOutput to inspect the current terminal screen and TaskInput to interact."
+        : "Use TaskOutput to inspect current output.",
     ].join("\n");
   }
 
@@ -342,6 +362,7 @@ function renderBashObservation(raw: BashRawResult): string {
     `exitCode=${raw.exitCode ?? "null"}`,
     `status=${raw.status}`,
     `cwd=${raw.cwd}`,
+    `tty=${raw.tty}`,
     `outputFilePath=${raw.outputFilePath}`,
     `outputBytes=${raw.outputBytes}`,
     `outputLines=${raw.outputLines}`,
@@ -351,8 +372,9 @@ function renderBashObservation(raw: BashRawResult): string {
       ? undefined
       : `returnCodeInterpretation=${raw.returnCodeInterpretation}`,
     raw.error === undefined ? undefined : `error=${raw.error}`,
-    "preview:",
-    raw.preview,
+    raw.tty ? `screen=${raw.screenColumns ?? 80}x${raw.screenRows ?? 24}` : undefined,
+    raw.tty ? "current screen:" : "preview:",
+    raw.tty ? (raw.screen ?? "") : raw.preview,
   ]
     .filter((line): line is string => line !== undefined)
     .join("\n");
@@ -376,23 +398,48 @@ function renderTaskOutputObservation(raw: TaskOutputRawResult): string {
     return `TaskOutput failed for ${raw.taskId || "(unknown task ID)"}: ${raw.error ?? "Unknown error."}`;
   }
 
+  const terminalScreen = raw.task.tty;
   return [
     "Task output retrieved.",
     `taskId=${raw.taskId}`,
     `status=${raw.task.status}`,
     `command=${raw.task.command}`,
+    `tty=${terminalScreen}`,
     `outputFilePath=${raw.outputFilePath}`,
     `outputBytes=${raw.outputBytes ?? 0}`,
     `outputLines=${raw.outputLines ?? 0}`,
     `truncated=${raw.truncated ?? false}`,
     raw.omittedLines === undefined ? undefined : `omittedLines=${raw.omittedLines}`,
-    "preview:",
-    raw.preview ?? "",
+    terminalScreen
+      ? `screen=${raw.screenColumns ?? 80}x${raw.screenRows ?? 24}`
+      : undefined,
+    terminalScreen ? "current screen:" : "preview:",
+    terminalScreen ? (raw.screen ?? "") : (raw.preview ?? ""),
   ]
     .filter((line): line is string => line !== undefined)
     .join("\n");
 }
 
+function renderTaskInputObservation(raw: TaskInputRawResult): string {
+  if (!raw.ok) {
+    return `TaskInput failed for ${raw.taskId || "(unknown task ID)"}: ${raw.error}`;
+  }
+
+  return [
+    "Terminal input sent.",
+    `taskId=${raw.taskId}`,
+    `status=${raw.status}`,
+    `writtenBytes=${raw.writtenBytes}`,
+    `waitedMs=${raw.waitedMs}`,
+    `screen=${raw.screenColumns}x${raw.screenRows}`,
+    `outputFilePath=${raw.outputFilePath}`,
+    `outputBytes=${raw.outputBytes}`,
+    `outputLines=${raw.outputLines}`,
+    "current screen:",
+    raw.screen,
+  ].join("\n");
+}
+
 function renderTaskStopObservation(raw: TaskStopRawResult): string {
   if (!raw.ok || raw.task === undefined) {
     return `TaskStop failed for ${raw.taskId || "(unknown task ID)"}: ${raw.error ?? "Unknown error."}`;
@@ -417,6 +464,7 @@ function renderTaskSummary(task: TaskListRawResult["tasks"][number]): string {
     `taskId=${task.taskId}`,
     `description=${task.description}`,
     `status=${task.status}`,
+    `tty=${task.tty}`,
     `startedAt=${task.startedAt}`,
     task.endedAt === undefined ? undefined : `endedAt=${task.endedAt}`,
     task.exitCode === undefined ? undefined : `exitCode=${task.exitCode}`,

package/src/session/session-catalog.ts

@@ -34,6 +34,15 @@ export class SessionCatalog {
   }
 
   async list(currentSessionId?: SessionId): Promise<readonly SessionSummary[]> {
+    const summaries = await this.scan(currentSessionId);
+    return Object.freeze(summaries.slice(0, this.input.limit ?? 20));
+  }
+
+  async listAll(currentSessionId?: SessionId): Promise<readonly SessionSummary[]> {
+    return Object.freeze(await this.scan(currentSessionId));
+  }
+
+  private async scan(currentSessionId?: SessionId): Promise<SessionSummary[]> {
     const workspaceRoot = await this.workspaceRootPromise;
     const sessionsRoot = path.join(workspaceRoot, ".tinker", "sessions");
     let entries;
@@ -63,17 +72,14 @@ export class SessionCatalog {
       );
     }
 
-    return Object.freeze(
-      summaries
-        .filter(
-          (summary) =>
-            summary.turnCount > 0 ||
-            summary.status === "incomplete" ||
-            summary.status === "unavailable",
-        )
-        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
-        .slice(0, this.input.limit ?? 20),
-    );
+    return summaries
+      .filter(
+        (summary) =>
+          summary.turnCount > 0 ||
+          summary.status === "incomplete" ||
+          summary.status === "unavailable",
+      )
+      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
   }
 
   async get(

package/src/session/session-store.ts

@@ -4838,11 +4838,13 @@ export function decodeStoredToolRawResult(value: unknown): ToolRawResult {
       "read",
       "write",
       "edit",
+      "delete",
       "glob",
       "grep",
       "bash",
       "task_list",
       "task_output",
+      "task_input",
       "task_stop",
       "web_search",
       "web_fetch",

package/src/tools/bash-guard.ts

@@ -0,0 +1,131 @@
+import path from "node:path";
+
+export type BashRisk =
+  | { readonly dangerous: false }
+  | { readonly dangerous: true; readonly reason: string };
+
+export type BashRiskContext = {
+  readonly workspaceRoot?: string;
+};
+
+const SAFE: BashRisk = Object.freeze({ dangerous: false });
+
+export function classifyBashRisk(
+  command: string,
+  context: BashRiskContext = {},
+): BashRisk {
+  const normalized = command.trim();
+  if (normalized === "") {
+    return SAFE;
+  }
+
+  if (/:\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/.test(normalized)) {
+    return dangerous("fork bomb");
+  }
+
+  for (const segment of shellSegments(normalized)) {
+    const words = shellWords(segment);
+    const commandIndex = commandWordIndex(words);
+    if (commandIndex === -1) {
+      continue;
+    }
+    const name = basename(words[commandIndex] ?? "");
+    const args = words.slice(commandIndex + 1);
+
+    if (["shutdown", "reboot", "halt", "poweroff"].includes(name)) {
+      return dangerous(`system power command ${name}`);
+    }
+    if (name === "wipefs" || name.startsWith("mkfs.")) {
+      return dangerous(`block-device command ${name}`);
+    }
+    if (name === "dd" && args.some((word) => /^of=\/dev\/[^/]/.test(word))) {
+      return dangerous("dd writes directly to a device");
+    }
+    if ((name === "chmod" || name === "chown") && hasRecursiveFlag(args)) {
+      const operands = args.filter((word) => !word.startsWith("-"));
+      if (operands.at(-1) === "/") {
+        return dangerous(`${name} recursively targets the filesystem root`);
+      }
+    }
+    if (name === "rm" && hasRecursiveFlag(args) && hasForceFlag(args)) {
+      const operands = args.filter((word) => !word.startsWith("-"));
+      if (
+        operands.some((target) => isDestructiveRmTarget(target, context.workspaceRoot))
+      ) {
+        return dangerous("recursive forced removal targets a protected root");
+      }
+    }
+  }
+
+  return SAFE;
+}
+
+function dangerous(reason: string): BashRisk {
+  return Object.freeze({ dangerous: true, reason });
+}
+
+function shellSegments(command: string): string[] {
+  return command.split(/(?:&&|\|\||[;|\n])/);
+}
+
+function shellWords(segment: string): string[] {
+  return segment.match(/"(?:\\.|[^"])*"|'[^']*'|[^\s]+/g)?.map(unquote) ?? [];
+}
+
+function unquote(word: string): string {
+  if (
+    (word.startsWith('"') && word.endsWith('"')) ||
+    (word.startsWith("'") && word.endsWith("'"))
+  ) {
+    return word.slice(1, -1);
+  }
+  return word;
+}
+
+function commandWordIndex(words: readonly string[]): number {
+  let index = 0;
+  while (index < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[index] ?? "")) {
+    index += 1;
+  }
+  if (basename(words[index] ?? "") === "sudo") {
+    index += 1;
+    while ((words[index] ?? "").startsWith("-")) {
+      index += 1;
+    }
+  }
+  return index < words.length ? index : -1;
+}
+
+function basename(word: string): string {
+  return word.slice(word.lastIndexOf("/") + 1);
+}
+
+function hasRecursiveFlag(args: readonly string[]): boolean {
+  return args.some((word) => /^-[^-]*[rR]/.test(word) || word === "--recursive");
+}
+
+function hasForceFlag(args: readonly string[]): boolean {
+  return args.some((word) => /^-[^-]*f/.test(word) || word === "--force");
+}
+
+function isDestructiveRmTarget(
+  target: string,
+  workspaceRoot: string | undefined,
+): boolean {
+  if (target === "/" || target === "/*" || target === "~" || target === "~/*") {
+    return true;
+  }
+  if (
+    target === "$HOME" ||
+    target === "${HOME}" ||
+    target === "$HOME/*" ||
+    target === "${HOME}/*"
+  ) {
+    return true;
+  }
+  if (workspaceRoot === undefined || !path.isAbsolute(target)) {
+    return false;
+  }
+  const normalizedTarget = path.resolve(target.replace(/\/\*$/, ""));
+  return normalizedTarget === path.resolve(workspaceRoot);
+}