tinker-agent 1.0.65

package/src/events/append-private-file.ts

@@ -0,0 +1,16 @@
+import path from "node:path";
+import { chmod, mkdir, open } from "node:fs/promises";
+
+export async function appendPrivateFile(
+  filePath: string,
+  content: string,
+): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const handle = await open(filePath, "a", 0o600);
+  try {
+    await handle.writeFile(content, "utf8");
+  } finally {
+    await handle.close();
+  }
+  await chmod(filePath, 0o600);
+}

package/src/events/bash-result-detail.ts

@@ -0,0 +1,70 @@
+const successPreviewLines = 5;
+const failurePreviewLines = 15;
+
+export type BashDisplayDetail = {
+  command: string;
+  outputPreview?: string[];
+  omittedOutputLines?: number;
+  outputFilePath?: string;
+};
+
+export function bashCommandFromArgs(args: unknown): string | undefined {
+  return nonEmptyString(asRecord(args).command);
+}
+
+export function bashResultDetail(raw: unknown): BashDisplayDetail | undefined {
+  const rawRecord = asRecord(raw);
+  const taskRecord = asRecord(rawRecord.task);
+  const command =
+    nonEmptyString(rawRecord.command) ?? nonEmptyString(taskRecord.command);
+
+  if (command === undefined) {
+    return undefined;
+  }
+
+  const preview = typeof rawRecord.preview === "string" ? rawRecord.preview : "";
+  const previewLines = preview === "" ? [] : preview.split("\n");
+  const maxLines = rawRecord.ok === true ? successPreviewLines : failurePreviewLines;
+  const outputPreview = previewLines.slice(-maxLines).map(sanitizeOutputLine);
+  const totalLines =
+    typeof rawRecord.outputLines === "number"
+      ? rawRecord.outputLines
+      : previewLines.length;
+  const omittedOutputLines = Math.max(0, totalLines - outputPreview.length);
+
+  return {
+    command,
+    outputPreview,
+    omittedOutputLines,
+    outputFilePath:
+      nonEmptyString(rawRecord.outputFilePath) ??
+      nonEmptyString(taskRecord.outputFilePath),
+  };
+}
+
+// Terminal output routinely carries ANSI escapes and control characters that
+// would corrupt the Ink layout, so both patterns intentionally match them.
+/* eslint-disable no-control-regex */
+const ansiEscapePattern = new RegExp(
+  "\\u001b(?:\\[[0-9;?]*[@-~]|\\][^\\u0007\\u001b]*(?:\\u0007|\\u001b\\\\)?|[@-Z\\\\-_])",
+  "g",
+);
+const controlCharPattern = new RegExp("[\\u0000-\\u0008\\u000b-\\u001f\\u007f]", "g");
+/* eslint-enable no-control-regex */
+
+export function sanitizeOutputLine(line: string): string {
+  return line
+    .replace(ansiEscapePattern, "")
+    .replace(controlCharPattern, "")
+    .replaceAll("\t", "  ");
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}

package/src/events/composite-event-sink.ts

@@ -0,0 +1,82 @@
+import type {
+  EventSink,
+  EventSinkAppendResult,
+  EventSinkDiagnostic,
+} from "./event-sink";
+import type { AgentEvent } from "./types";
+
+export class CompositeEventSink implements EventSink {
+  private tail: Promise<void> = Promise.resolve();
+  private readonly requiredSinks: EventSink[];
+  private readonly auxiliarySinks: EventSink[];
+  private readonly disabledAuxiliarySinks = new Set<EventSink>();
+
+  constructor(input: {
+    requiredSinks: EventSink[];
+    auxiliarySinks: EventSink[];
+  }) {
+    this.requiredSinks = input.requiredSinks;
+    this.auxiliarySinks = input.auxiliarySinks;
+  }
+
+  append(event: AgentEvent): Promise<void | EventSinkAppendResult> {
+    const write = this.tail.then(() => this.appendToSinks(event));
+    this.tail = write.then(
+      () => undefined,
+      () => undefined,
+    );
+    return write;
+  }
+
+  private async appendToSinks(
+    event: AgentEvent,
+  ): Promise<void | EventSinkAppendResult> {
+    const requiredErrors: Error[] = [];
+    for (const sink of this.requiredSinks) {
+      try {
+        await sink.append(event);
+      } catch (error) {
+        requiredErrors.push(
+          new Error(
+            `Required event sink ${sinkName(sink)} failed while appending ${event.type}.`,
+            { cause: error },
+          ),
+        );
+      }
+    }
+
+    const diagnostics: EventSinkDiagnostic[] = [];
+    for (const sink of this.auxiliarySinks) {
+      if (this.disabledAuxiliarySinks.has(sink)) {
+        continue;
+      }
+      try {
+        await sink.append(event);
+      } catch (error) {
+        this.disabledAuxiliarySinks.add(sink);
+        diagnostics.push({
+          sinkName: sinkName(sink),
+          failedEventType: event.type,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    if (requiredErrors.length === 1) {
+      throw requiredErrors[0];
+    }
+    if (requiredErrors.length > 1) {
+      throw new AggregateError(
+        requiredErrors,
+        `Multiple required event sinks failed while appending ${event.type}.`,
+      );
+    }
+    if (diagnostics.length > 0) {
+      return { diagnostics };
+    }
+  }
+}
+
+function sinkName(sink: EventSink): string {
+  return sink.name ?? sink.constructor.name ?? "anonymous";
+}

package/src/events/event-sink.ts

@@ -0,0 +1,16 @@
+import type { AgentEvent, AgentEventType } from "./types";
+
+export type EventSinkDiagnostic = {
+  sinkName: string;
+  failedEventType: AgentEventType;
+  error: string;
+};
+
+export type EventSinkAppendResult = {
+  diagnostics: EventSinkDiagnostic[];
+};
+
+export interface EventSink {
+  readonly name?: string;
+  append(event: AgentEvent): Promise<void | EventSinkAppendResult>;
+}

package/src/events/jsonl-event-log.ts

@@ -0,0 +1,13 @@
+import type { EventSink } from "./event-sink";
+import type { AgentEvent } from "./types";
+import { appendPrivateFile } from "./append-private-file";
+
+export class JsonlEventLog implements EventSink {
+  readonly name = "jsonl-event-log";
+
+  constructor(private readonly filePath: string) {}
+
+  async append(event: AgentEvent): Promise<void> {
+    await appendPrivateFile(this.filePath, `${JSON.stringify(event)}\n`);
+  }
+}

package/src/events/observation-text-log.ts

@@ -0,0 +1,195 @@
+import type { ToolCall } from "../agent/types";
+import type { ToolObservation } from "../observation/observation-builder";
+import type { EventSink } from "./event-sink";
+import type { AgentEvent, TurnFinishedData } from "./types";
+import { appendPrivateFile } from "./append-private-file";
+
+export class ObservationTextLog implements EventSink {
+  readonly name = "observation-text-log";
+
+  constructor(private readonly filePath: string) {}
+
+  async append(event: AgentEvent): Promise<void> {
+    const text = renderObservationLogBlock(event);
+    if (text === undefined) {
+      return;
+    }
+
+    await appendPrivateFile(this.filePath, text);
+  }
+}
+
+function renderObservationLogBlock(event: AgentEvent): string | undefined {
+  switch (event.type) {
+    case "session.started":
+      return renderSessionStarted(event);
+    case "session.resumed":
+      return [
+        "---",
+        "",
+        `Resumed: ${event.timestamp}`,
+        `Open count: ${event.data.openCount}`,
+        `Recovered synthetic completions: ${event.data.syntheticCompletionCount}`,
+        `Recall index rebuilt: ${event.data.recallIndexRebuilt}`,
+        "",
+      ].join("\n");
+    case "turn.started":
+      return renderTurnStarted(event);
+    case "assistant.progress":
+      return renderAssistantProgress(event);
+    case "tool.observation":
+      return renderToolObservation(event);
+    case "turn.finished":
+      return renderTurnFinished(event.data);
+    case "turn.cancelled":
+      return renderTurnCancelled(event);
+    case "turn.failed":
+      return renderTurnFailed(event.data.error);
+    default:
+      return undefined;
+  }
+}
+
+function renderSessionStarted(
+  event: Extract<AgentEvent, { type: "session.started" }>,
+): string {
+  return [
+    `# Tinker Session ${event.sessionId}`,
+    "",
+    `Started: ${event.timestamp}`,
+    `Workspace: ${event.data.workspaceRoot}`,
+    `Model: ${event.data.model}`,
+    `Max iterations: ${event.data.maxIterations}`,
+    "",
+    "---",
+    "",
+  ].join("\n");
+}
+
+function renderTurnStarted(
+  event: Extract<AgentEvent, { type: "turn.started" }>,
+): string {
+  return [
+    `## Turn ${event.turnNumber ?? ""} - Prompt`,
+    "",
+    event.data.userPrompt,
+    "",
+    "---",
+    "",
+  ].join("\n");
+}
+
+function renderAssistantProgress(
+  event: Extract<AgentEvent, { type: "assistant.progress" }>,
+): string {
+  return [
+    `## Iteration ${event.iterationId} - Assistant`,
+    "",
+    event.data.content,
+    "",
+    "---",
+    "",
+  ].join("\n");
+}
+
+function renderToolObservation(
+  event: Extract<AgentEvent, { type: "tool.observation" }>,
+): string {
+  return [
+    `## Iteration ${event.iterationId} - ${event.data.call.name}`,
+    "",
+    toolCallSummary(event.data.call),
+    "",
+    observationContent(event.data.observation),
+    "",
+    "---",
+    "",
+  ].join("\n");
+}
+
+function renderTurnFinished(data: TurnFinishedData): string {
+  return [
+    "## Final",
+    "",
+    data.finalText.trim() === "" ? "(no final response)" : data.finalText,
+    "",
+  ].join("\n");
+}
+
+function renderTurnFailed(error: string): string {
+  return ["## Failed", "", error, ""].join("\n");
+}
+
+function renderTurnCancelled(
+  event: Extract<AgentEvent, { type: "turn.cancelled" }>,
+): string {
+  return [
+    "## Cancelled",
+    "",
+    `Cancelled: ${event.timestamp}`,
+    `Phase: ${event.data.cancellation.phase}`,
+    `Iteration: ${event.data.cancellation.iterationNumber}`,
+    event.data.cancellation.toolName === undefined
+      ? undefined
+      : `Tool: ${event.data.cancellation.toolName}`,
+    event.data.cancellation.toolCallId === undefined
+      ? undefined
+      : `Call ID: ${event.data.cancellation.toolCallId}`,
+    "",
+  ]
+    .filter((line): line is string => line !== undefined)
+    .join("\n");
+}
+
+function toolCallSummary(call: ToolCall): string {
+  const args = asRecord(call.args);
+
+  if (call.name === "Bash") {
+    const description = stringProperty(args, "description");
+    const command = stringProperty(args, "command");
+    return [
+      `Call ID: ${call.toolCallId}`,
+      description === undefined ? undefined : `Description: ${description}`,
+      command === undefined ? undefined : `Command: ${command}`,
+    ]
+      .filter((line): line is string => line !== undefined)
+      .join("\n");
+  }
+
+  if (call.name === "TaskOutput" || call.name === "TaskStop") {
+    const taskId = stringProperty(args, "task_id");
+    return [
+      `Call ID: ${call.toolCallId}`,
+      taskId === undefined ? undefined : `Task ID: ${taskId}`,
+    ]
+      .filter((line): line is string => line !== undefined)
+      .join("\n");
+  }
+
+  const filePath = stringProperty(args, "file_path");
+  const pattern = stringProperty(args, "pattern");
+  return [
+    `Call ID: ${call.toolCallId}`,
+    filePath === undefined ? undefined : `Path: ${filePath}`,
+    pattern === undefined ? undefined : `Pattern: ${pattern}`,
+  ]
+    .filter((line): line is string => line !== undefined)
+    .join("\n");
+}
+
+function observationContent(observation: ToolObservation): string {
+  return observation.content;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function stringProperty(
+  record: Record<string, unknown>,
+  property: string,
+): string | undefined {
+  return typeof record[property] === "string" ? record[property] : undefined;
+}