@buyong/pi-devin 0.0.0-stage → 0.1.0

package/src/pi/fusion-picker.ts

@@ -0,0 +1,171 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { decodeKittyPrintable, fuzzyFilter, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { FusionChoices, FusionSelection } from "./models.ts";
+
+export type PickerTheme = Pick<Theme, "fg" | "bold">;
+interface Item { id: string; name: string; recommended?: true }
+
+const VISIBLE_ROWS = 10;
+/** Below this width, only the focused column is drawn instead of two side by side. */
+const MIN_TWO_COLUMN_WIDTH = 60;
+const SEPARATOR = " │ ";
+const HELP = "tab switch column · ↑↓ move · type to search · ↵ save · esc cancel";
+
+class PickerColumn {
+  readonly title: string;
+  readonly currentID: string | undefined;
+  readonly items: Item[];
+  query = "";
+  selectedID: string | undefined;
+  private offset = 0;
+
+  constructor(title: string, items: readonly Item[], currentID: string | undefined) {
+    this.title = title;
+    this.currentID = currentID;
+    // Recommended items come first; catalog order is kept within each group.
+    this.items = [...items.filter((item) => item.recommended), ...items.filter((item) => !item.recommended)];
+    this.selectedID = (this.items.find((item) => item.id === currentID) ?? this.items[0])?.id;
+  }
+
+  visible(): Item[] {
+    return this.query.trim() ? fuzzyFilter(this.items, this.query.trim(), (item) => `${item.name} ${item.id}`) : this.items;
+  }
+
+  selected(): Item | undefined {
+    return this.visible().find((item) => item.id === this.selectedID);
+  }
+
+  /** If the search hides the selected item, the selection moves to the first match. */
+  setQuery(query: string): void {
+    this.query = query;
+    const visible = this.visible();
+    if (!visible.some((item) => item.id === this.selectedID)) this.selectedID = visible[0]?.id ?? this.selectedID;
+    this.offset = 0;
+  }
+
+  move(delta: number): void {
+    const visible = this.visible();
+    if (!visible.length) return;
+    const index = Math.max(0, visible.findIndex((item) => item.id === this.selectedID));
+    const next = Math.abs(delta) === 1 ? (index + delta + visible.length) % visible.length : Math.min(visible.length - 1, Math.max(0, index + delta));
+    this.selectedID = visible[next].id;
+  }
+
+  /** Scrolls so the selected item is visible, then returns the visible rows. */
+  rows(count: number): { items: Item[]; total: number } {
+    const visible = this.visible();
+    const index = visible.findIndex((item) => item.id === this.selectedID);
+    if (index >= 0 && index < this.offset) this.offset = index;
+    if (index >= this.offset + count) this.offset = index - count + 1;
+    this.offset = Math.max(0, Math.min(this.offset, Math.max(0, visible.length - count)));
+    return { items: visible.slice(this.offset, this.offset + count), total: visible.length };
+  }
+}
+
+export interface FusionPickerOptions {
+  choices: FusionChoices;
+  current: FusionSelection | undefined;
+  theme: PickerTheme;
+  requestRender: () => void;
+  done: (selection: FusionSelection | undefined) => void;
+}
+
+/** TUI picker for `/devin-fusion`. Choose the lead and sidekick columns on one screen and save both with Enter. */
+export class FusionPicker {
+  private readonly columns: [PickerColumn, PickerColumn];
+  private focus: 0 | 1 = 0;
+  private notice: string | undefined;
+  private cached: { width: number; lines: string[] } | undefined;
+  private readonly options: FusionPickerOptions;
+
+  constructor(options: FusionPickerOptions) {
+    this.options = options;
+    this.columns = [
+      new PickerColumn("LEAD", options.choices.leads, options.current?.leadID),
+      new PickerColumn("SIDEKICK", options.choices.sidekicks, options.current?.sidekickID),
+    ];
+  }
+
+  invalidate(): void { this.cached = undefined; }
+
+  private changed(): void { this.invalidate(); this.options.requestRender(); }
+
+  handleInput(data: string): void {
+    const column = this.columns[this.focus];
+    this.notice = undefined;
+    if (matchesKey(data, "ctrl+c")) return this.options.done(undefined);
+    if (matchesKey(data, "escape")) {
+      // While searching, the first esc only clears the search.
+      if (column.query) { column.setQuery(""); return this.changed(); }
+      return this.options.done(undefined);
+    }
+    if (matchesKey(data, "tab") || matchesKey(data, "shift+tab") || matchesKey(data, "left") || matchesKey(data, "right")) {
+      this.focus = this.focus === 0 ? 1 : 0;
+      return this.changed();
+    }
+    if (matchesKey(data, "up")) { column.move(-1); return this.changed(); }
+    if (matchesKey(data, "down")) { column.move(1); return this.changed(); }
+    if (matchesKey(data, "pageUp")) { column.move(-VISIBLE_ROWS); return this.changed(); }
+    if (matchesKey(data, "pageDown")) { column.move(VISIBLE_ROWS); return this.changed(); }
+    if (matchesKey(data, "enter")) {
+      const [lead, sidekick] = this.columns.map((item) => item.selected());
+      if (lead && sidekick) return this.options.done({ leadID: lead.id, sidekickID: sidekick.id });
+      this.notice = `Pick a model in the ${lead ? "sidekick" : "lead"} column. Press esc to clear the search.`;
+      return this.changed();
+    }
+    if (matchesKey(data, "backspace")) {
+      if (column.query) { column.setQuery(column.query.slice(0, -1)); this.changed(); }
+      return;
+    }
+    // The Kitty keyboard protocol sends characters as CSI-u sequences. Other input counts as text only when it has no control characters.
+    const text = decodeKittyPrintable(data) ?? (/^[^\p{Cc}]+$/u.test(data) ? data : undefined);
+    if (text) { column.setQuery(column.query + text); this.changed(); }
+  }
+
+  render(width: number): string[] {
+    if (this.cached?.width === width) return this.cached.lines;
+    const { theme } = this.options;
+    const name = (column: PickerColumn, id: string | undefined) => column.items.find((item) => item.id === id)?.name ?? "none";
+    const lines = [
+      theme.fg("accent", theme.bold("Devin Fusion")) + theme.fg("muted", " · choose the lead and sidekick on one screen"),
+      theme.fg("muted", `Current: ${this.options.current ? `${name(this.columns[0], this.options.current.leadID)} + ${name(this.columns[1], this.options.current.sidekickID)}` : "no saved pair"}`),
+      "",
+    ];
+    if (width >= MIN_TWO_COLUMN_WIDTH) {
+      const columnWidth = Math.floor((width - SEPARATOR.length) / 2);
+      const [left, right] = this.columns.map((column, index) => this.renderColumn(column, index === this.focus, columnWidth));
+      const separator = theme.fg("borderMuted", SEPARATOR);
+      for (let index = 0; index < left.length; index++) lines.push(left[index] + separator + right[index]);
+    } else {
+      const tabs = this.columns.map((column, index) => index === this.focus ? theme.fg("accent", theme.bold(`[${column.title}]`)) : theme.fg("muted", column.title)).join(" ");
+      lines.push(tabs, ...this.renderColumn(this.columns[this.focus], true, width));
+    }
+    const [lead, sidekick] = this.columns.map((column) => column.selected()?.name ?? "—");
+    lines.push("", theme.fg("accent", `Selected: ${lead} + ${sidekick}`), this.notice ? theme.fg("warning", this.notice) : theme.fg("dim", HELP));
+    const result = lines.map((line) => truncateToWidth(line, width));
+    this.cached = { width, lines: result };
+    return result;
+  }
+
+  private renderColumn(column: PickerColumn, isFocused: boolean, width: number): string[] {
+    const { theme } = this.options;
+    const { items, total } = column.rows(VISIBLE_ROWS);
+    const count = `${total}/${column.items.length}`;
+    const query = column.query ? ` search: ${column.query}${isFocused ? "▏" : ""}` : isFocused ? " (type to search)" : "";
+    const header = truncateToWidth(`${isFocused ? "▸ " : "  "}${column.title} ${count}${query}`, width, "…", true);
+    const lines = [isFocused ? theme.fg("accent", theme.bold(header)) : theme.fg("muted", header)];
+    for (let index = 0; index < VISIBLE_ROWS; index++) {
+      const item = items[index];
+      if (!item) {
+        const empty = index === 0 && total === 0 ? "  no matching models" : "";
+        lines.push(theme.fg("dim", truncateToWidth(empty, width, "…", true)));
+        continue;
+      }
+      const isSelected = item.id === column.selectedID;
+      const marks = `${isSelected ? "›" : " "}${item.id === column.currentID ? "●" : " "}${item.recommended ? "★" : " "} `;
+      const cell = truncateToWidth(marks + item.name, width, "…", true);
+      lines.push(isSelected && isFocused ? theme.fg("accent", theme.bold(cell)) : isSelected ? cell : theme.fg("muted", cell));
+    }
+    return lines;
+  }
+}

package/src/pi/fusion-settings.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { FusionSelection } from "./models.ts";
+
+const SCHEMA_VERSION = 1;
+
+/** Global store for the lead and sidekick chosen with `/devin-fusion`. Every session uses the same value. */
+export interface FusionSettings {
+  read(): FusionSelection | undefined;
+  write(selection: FusionSelection): void;
+}
+
+export function fusionSettingsPath(agentDir: string): string {
+  return join(agentDir, "pi-devin", "fusion.json");
+}
+
+/** Default store so SDK callers that register the extension directly, and tests, never write to the real agent directory. */
+export function memoryFusionSettings(initial?: FusionSelection): FusionSettings {
+  let current = initial;
+  return { read: () => current, write: (selection) => { current = { ...selection }; } };
+}
+
+/** An unreadable or malformed file reads as no saved value and is not overwritten. Writes are replaced atomically within the same directory. */
+export function fileFusionSettings(path: string): FusionSettings {
+  return {
+    read() {
+      try {
+        const value = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+        // Legacy IDs (`family:…`, `uid:…`) are read as is. `effectiveFusion` maps them to the current catalog's IDs.
+        if (value.schemaVersion === SCHEMA_VERSION && typeof value.leadID === "string" && value.leadID.trim() !== ""
+          && typeof value.sidekickID === "string" && value.sidekickID.trim() !== "") {
+          return { leadID: value.leadID, sidekickID: value.sidekickID };
+        }
+      } catch { /* A missing or corrupt file falls back to the default pair. */ }
+      return undefined;
+    },
+    write(selection) {
+      mkdirSync(dirname(path), { recursive: true });
+      const temporary = `${path}.${process.pid}.tmp`;
+      writeFileSync(temporary, JSON.stringify({ schemaVersion: SCHEMA_VERSION, leadID: selection.leadID, sidekickID: selection.sidekickID }, null, 2) + "\n");
+      renameSync(temporary, path);
+    },
+  };
+}

package/src/pi/lifecycle.ts

@@ -0,0 +1,217 @@
+import { randomUUID } from "node:crypto";
+import { awaitWithSignal } from "../core/protocol/transport.ts";
+
+export const DEVIN_STATE_ENTRY = "pi-devin.state.v1";
+export type ExecutionKind = "agent" | "pending" | "manual" | "tree" | "direct" | "recovered";
+export interface DevinSessionState {
+  version: 1;
+  sessionId: string;
+  ownerHash?: string;
+  cascadeId: string;
+  trajectoryId: string;
+  nextStepIndex: number;
+  execution?: { id: string; used: number; settled: boolean; kind: ExecutionKind };
+}
+export interface SessionBinding {
+  getSessionId(): string;
+  getBranch(): readonly { type: string; customType?: string; data?: unknown }[];
+  append(data: DevinSessionState): void;
+}
+interface Execution {
+  data: NonNullable<DevinSessionState["execution"]>;
+  controller: AbortController;
+  tail: Promise<void>;
+  cleanups: Set<() => void>;
+  activeRequests: number;
+  hasStarted: boolean;
+  nextIsRecovery: boolean;
+  hasCheckpoint: boolean;
+}
+export interface RequestLease {
+  signal: AbortSignal;
+  executionId: string;
+  cascadeId: string;
+  trajectoryId: string;
+  sessionId: string;
+  stepIndex: number;
+  isAuxiliary: boolean;
+  isRecovery: boolean;
+  consume(): void;
+  addCleanup(cleanup: () => void): void;
+  release(): void;
+}
+export class ModelBudgetError extends Error {
+  constructor(limit: number) { super(`Used all ${limit} Devin model HTTP requests in the budget.`); this.name = "ModelBudgetError"; }
+}
+
+/** Value of `PI_DEVIN_MAX_MODEL_CALLS`. Defaults to 8; anything other than an integer from 1 to 100 stops the extension from loading. */
+export function modelCallLimit(value: string | undefined): number | undefined {
+  if (value === undefined || value === "") return undefined;
+  if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 100) throw new Error("PI_DEVIN_MAX_MODEL_CALLS must be an integer from 1 to 100.");
+  return Number(value);
+}
+const cancelled = () => new DOMException("The previous Devin run ended.", "AbortError");
+const isUUID = (value: unknown): value is string => typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
+
+function restoreState(binding: SessionBinding): DevinSessionState {
+  const sessionId = binding.getSessionId();
+  const entry = [...binding.getBranch()].reverse().find((entry) => entry.type === "custom" && entry.customType === DEVIN_STATE_ENTRY);
+  if (!entry) return { version: 1, sessionId, cascadeId: randomUUID(), trajectoryId: randomUUID(), nextStepIndex: 0 };
+  const value = entry.data as DevinSessionState | undefined;
+  if (!value || value.version !== 1 || typeof value.sessionId !== "string" || !isUUID(value.cascadeId) || !isUUID(value.trajectoryId)
+    || !Number.isSafeInteger(value.nextStepIndex) || value.nextStepIndex < 0 || value.nextStepIndex > 2_147_483_647
+    || (value.ownerHash !== undefined && !/^[a-f0-9]{64}$/.test(value.ownerHash))
+    || (value.execution !== undefined && (!isUUID(value.execution.id) || !Number.isSafeInteger(value.execution.used)
+      || value.execution.used < 0 || value.execution.used > 100 || typeof value.execution.settled !== "boolean"))) {
+    throw new Error("The Devin session state is corrupt or an unsupported version. Start a new session.");
+  }
+  if (value.sessionId !== sessionId) return { version: 1, sessionId, cascadeId: randomUUID(), trajectoryId: randomUUID(), nextStepIndex: 0 };
+  return structuredClone(value);
+}
+
+/** One instance owns one Pi runtime. It never builds its own tool or retry loop. */
+export class DevinLifecycle {
+  private binding?: SessionBinding;
+  private state: DevinSessionState = { version: 1, sessionId: randomUUID(), cascadeId: randomUUID(), trajectoryId: randomUUID(), nextStepIndex: 0 };
+  private execution?: Execution;
+  private isClosed = false;
+  private isAuxiliary = false;
+  readonly maxModelCalls: number;
+  constructor(maxModelCalls = 8) {
+    if (!Number.isSafeInteger(maxModelCalls) || maxModelCalls < 1 || maxModelCalls > 100) throw new Error("The Devin request budget must be between 1 and 100.");
+    this.maxModelCalls = maxModelCalls;
+  }
+  snapshot(): DevinSessionState { return structuredClone(this.state); }
+  /** Model requests of the running or last finished run. used is 0 when this session has no run yet. */
+  budget(): { used: number; limit: number; isActive: boolean } {
+    const execution = this.state.execution;
+    return { used: execution?.used ?? 0, limit: this.maxModelCalls, isActive: execution !== undefined && !execution.settled };
+  }
+  private checkpoint(): void {
+    if (this.binding && this.binding.getSessionId() !== this.state.sessionId) throw cancelled();
+    this.binding?.append(structuredClone(this.state));
+  }
+  private activate(data: NonNullable<DevinSessionState["execution"]>, hasCheckpoint = false): Execution {
+    this.state.execution = data;
+    return this.execution = { data, controller: new AbortController(), tail: Promise.resolve(), cleanups: new Set(), activeRequests: 0, hasStarted: false, nextIsRecovery: false, hasCheckpoint };
+  }
+  attach(binding: SessionBinding): void {
+    this.abort(cancelled());
+    this.binding = binding;
+    this.state = restoreState(binding);
+    this.execution = undefined; this.isClosed = false; this.isAuxiliary = false;
+    if (this.state.execution && !this.state.execution.settled) {
+      this.activate({ ...this.state.execution, kind: "recovered" }, true);
+    }
+  }
+  begin(kind: ExecutionKind): void {
+    if (this.isClosed) throw cancelled();
+    if (this.execution && !this.execution.data.settled) {
+      if (kind === "agent" && ["pending", "recovered"].includes(this.execution.data.kind)) this.execution.data.kind = "agent";
+      else if (kind === "agent" && ["manual", "tree", "direct"].includes(this.execution.data.kind) && this.execution.activeRequests === 0) this.finish();
+      else return; // Retries and tool follow-up calls do not get a new budget.
+      if (this.execution) return;
+    }
+    this.activate({ id: randomUUID(), used: 0, settled: false, kind });
+  }
+  agentStarted(): void {
+    if (!this.execution) this.begin("agent");
+    this.execution!.nextIsRecovery = this.execution!.hasStarted;
+    this.execution!.hasStarted = true;
+  }
+  beforeCompaction(reason: "manual" | "threshold" | "overflow"): void {
+    this.begin(reason === "manual" ? "manual" : "pending");
+    this.isAuxiliary = true;
+  }
+  afterCompaction(reason: "manual" | "threshold" | "overflow"): void {
+    this.isAuxiliary = false;
+    if (reason === "manual" && this.execution?.data.kind === "manual") this.finish();
+  }
+  beforeTree(): void { this.begin("tree"); this.isAuxiliary = true; }
+  finish(): void {
+    if (!this.execution) return;
+    this.execution.data.settled = true;
+    this.abort(cancelled());
+    if (this.execution.hasCheckpoint) this.checkpoint();
+    this.execution = undefined; this.isAuxiliary = false;
+  }
+  abort(reason: unknown): void {
+    const active = this.execution;
+    if (!active) return;
+    if (!active.controller.signal.aborted) active.controller.abort(reason);
+    for (const cleanup of active.cleanups) { try { cleanup(); } catch { /* A cleanup error must not skip releasing other resources. */ } }
+  }
+  shutdown(): void {
+    if (this.isClosed) return;
+    this.abort(cancelled());
+    // An unfinished budget stays in the checkpoint so a reload cannot reset the limit.
+    this.isClosed = true;
+  }
+  treeChanged(): void {
+    if (!this.binding) return;
+    this.abort(cancelled());
+    this.state = restoreState(this.binding);
+    this.state.trajectoryId = randomUUID(); this.state.nextStepIndex = 0;
+    this.state.execution = undefined; this.execution = undefined; this.isAuxiliary = false;
+    if (this.state.ownerHash) this.checkpoint();
+  }
+  async acquire(ownerHash: string, callerSignal?: AbortSignal): Promise<RequestLease> {
+    if (this.isClosed) throw cancelled();
+    callerSignal?.throwIfAborted();
+    if (!/^[a-f0-9]{64}$/.test(ownerHash)) throw new Error("A verified Devin account scope is required.");
+    if (this.state.ownerHash && this.state.ownerHash !== ownerHash) throw new Error("This Pi session is bound to a different Devin account or endpoint. Start a new session.");
+    this.state.ownerHash = ownerHash;
+    if (!this.execution) this.begin("direct");
+    const active = this.execution!, state = this.state;
+    const signal = AbortSignal.any([active.controller.signal, ...(callerSignal ? [callerSignal] : [])]);
+    const previous = active.tail;
+    let releaseQueue!: () => void;
+    const completed = new Promise<void>((resolve) => { releaseQueue = resolve; });
+    active.tail = previous.then(() => completed);
+    let hasReleased = false, hasAcquired = false;
+    const ownCleanups = new Set<() => void>();
+    const clean = () => { for (const cleanup of ownCleanups) { try { cleanup(); } catch {} } };
+    const assertCurrent = () => {
+      signal.throwIfAborted();
+      if (this.execution !== active || this.state !== state || this.isClosed || (this.binding && this.binding.getSessionId() !== state.sessionId)) throw cancelled();
+    };
+    const release = () => {
+      if (hasReleased) return;
+      hasReleased = true;
+      signal.removeEventListener("abort", clean);
+      for (const cleanup of ownCleanups) { active.cleanups.delete(cleanup); try { cleanup(); } catch {} }
+      if (hasAcquired) active.activeRequests--;
+      releaseQueue();
+    };
+    try {
+      await awaitWithSignal(previous, signal);
+      assertCurrent();
+      if (active.data.used >= this.maxModelCalls) throw new ModelBudgetError(this.maxModelCalls);
+      if (state.nextStepIndex >= 2_147_483_647) throw new Error("The Devin step number limit was reached. Start a new session.");
+      active.activeRequests++; hasAcquired = true;
+      const stepIndex = state.nextStepIndex++;
+      active.hasCheckpoint = true;
+      this.checkpoint();
+      signal.addEventListener("abort", clean, { once: true });
+      const isAuxiliary = this.isAuxiliary;
+      const isRecovery = !isAuxiliary && active.nextIsRecovery;
+      if (!isAuxiliary) active.nextIsRecovery = false;
+      return {
+        signal, executionId: active.data.id, cascadeId: state.cascadeId, trajectoryId: state.trajectoryId,
+        sessionId: state.sessionId, stepIndex,
+        isAuxiliary, isRecovery,
+        consume: () => {
+          assertCurrent();
+          if (active.data.used >= this.maxModelCalls) { const error = new ModelBudgetError(this.maxModelCalls); this.abort(error); throw error; }
+          active.data.used++; this.checkpoint();
+        },
+        addCleanup: (cleanup) => {
+          let hasCleaned = false;
+          const once = () => { if (!hasCleaned) { hasCleaned = true; cleanup(); } };
+          ownCleanups.add(once); active.cleanups.add(once); if (signal.aborted) once();
+        },
+        release,
+      };
+    } catch (error) { release(); throw error; }
+  }
+}

package/src/pi/messages.ts

@@ -0,0 +1,107 @@
+import { randomUUID } from "node:crypto";
+import { getCurrentSystemPrompt, getCurrentTools, type AssistantMessage, type TranscriptContext } from "@earendil-works/pi-ai";
+import { imageFromBase64, MAX_IMAGES_BYTES } from "../core/inference/images.ts";
+import { object, requiredString, type ChatMessage, type ChatTool, type ModelInfo } from "../core/types.ts";
+import { DEVIN_API } from "./models.ts";
+
+const REPLAY_PREFIX = "devin:v1:";
+const replayStrings = ["signature", "signatureType", "geminiThoughtSignature", "outputId", "thinkingId", "phase", "modelUid"] as const;
+type ReplayMetadata = Pick<ChatMessage, typeof replayStrings[number] | "thinkingRedacted">;
+
+export function encodeReplayMetadata(message: ChatMessage): string {
+  const metadata: ReplayMetadata = {};
+  for (const key of replayStrings) if (message[key] !== undefined) metadata[key] = message[key];
+  if (message.thinkingRedacted !== undefined) metadata.thinkingRedacted = message.thinkingRedacted;
+  return REPLAY_PREFIX + JSON.stringify(metadata);
+}
+function replayMetadata(value: string | undefined): ReplayMetadata | undefined {
+  if (!value?.startsWith(REPLAY_PREFIX)) return undefined;
+  let parsed: Record<string, unknown>;
+  try { parsed = object(JSON.parse(value.slice(REPLAY_PREFIX.length)), "Devin replay metadata"); }
+  catch { throw new Error("Invalid Devin response replay metadata."); }
+  const result: ReplayMetadata = {};
+  for (const key of replayStrings) {
+    if (parsed[key] !== undefined && typeof parsed[key] !== "string") throw new Error("Unexpected Devin response replay metadata format.");
+    if (typeof parsed[key] === "string") result[key] = parsed[key];
+  }
+  if (parsed.thinkingRedacted !== undefined) {
+    if (typeof parsed.thinkingRedacted !== "boolean") throw new Error("Invalid Devin redacted thinking metadata.");
+    result.thinkingRedacted = parsed.thinkingRedacted;
+  }
+  return result;
+}
+
+export function attachReplayMetadata(output: AssistantMessage, message: ChatMessage): void {
+  const signature = encodeReplayMetadata(message);
+  for (const block of output.content) {
+    if (block.type === "thinking") block.thinkingSignature = signature;
+    else if (block.type === "text") block.textSignature = signature;
+    else block.thoughtSignature = signature;
+  }
+}
+
+export function toDevinTranscript(context: TranscriptContext, model: ModelInfo): { messages: ChatMessage[]; tools: ChatTool[]; systemPrompt: string } {
+  const declarations = getCurrentTools(context.messages);
+  if (declarations.length && !model.supportsToolCalls) throw new Error("This model does not support the current Pi tool declarations.");
+  const tools = declarations.map((tool) => {
+    if (tool.constrainedSampling && (tool.constrainedSampling.type === "grammar" || tool.constrainedSampling.strict === "require")) {
+      throw new Error(`Devin does not support this tool's forced sampling format: ${tool.name}`);
+    }
+    return { name: tool.name, description: tool.description, jsonSchemaString: JSON.stringify(tool.parameters) };
+  });
+  const failedCalls = new Set(context.messages.flatMap((message) => message.role === "assistant" && ["error", "aborted"].includes(message.stopReason)
+    ? message.content.filter((block) => block.type === "toolCall").map((block) => block.id) : []));
+  const messages: ChatMessage[] = [];
+  for (const message of context.messages) {
+    if (message.role === "system") continue;
+    if (message.role === "assistant") {
+      if (message.stopReason === "error" || message.stopReason === "aborted") continue;
+      if (message.stopReason === "pending") throw new Error("An unfinished assistant response cannot be sent as Devin history.");
+      const own = message.provider === "devin" && message.api === DEVIN_API;
+      const result: ChatMessage = { messageId: message.responseId ?? randomUUID(), source: "CHAT_MESSAGE_SOURCE_SYSTEM", prompt: "" };
+      let replay: ReplayMetadata | undefined;
+      for (const block of message.content) {
+        if (block.type === "text") result.prompt += block.text;
+        else if (block.type === "thinking") {
+          if (!block.redacted) result.thinking = (result.thinking ?? "") + block.thinking;
+          else result.thinkingRedacted = true;
+        } else {
+          result.toolCalls ??= [];
+          result.toolCalls.push({ id: requiredString(block.id, "tool call id"), name: block.namespace ? `${block.namespace}.${block.name}` : block.name,
+            argumentsJson: JSON.stringify(object(block.arguments, "tool arguments")) });
+        }
+        if (own) {
+          const metadata = replayMetadata(block.type === "text" ? block.textSignature : block.type === "thinking" ? block.thinkingSignature : block.thoughtSignature);
+          if (metadata) {
+            if (replay && JSON.stringify(replay) !== JSON.stringify(metadata)) throw new Error("Devin replay metadata differs within one response.");
+            replay = metadata;
+          }
+        }
+      }
+      Object.assign(result, replay);
+      if (own && message.providerThinkingLevel) result.modelUid = message.providerThinkingLevel;
+      if (result.thinkingRedacted) result.thinking = "";
+      messages.push(result);
+      continue;
+    }
+    if (message.role === "toolResult" && failedCalls.has(message.toolCallId)) continue;
+    const result: ChatMessage = {
+      messageId: randomUUID(), source: message.role === "toolResult" ? "CHAT_MESSAGE_SOURCE_TOOL" : "CHAT_MESSAGE_SOURCE_USER", prompt: "",
+      ...(message.role === "toolResult" ? { toolCallId: message.toolCallId, toolResultIsError: message.isError } : {}),
+    };
+    let imageBytes = 0;
+    const content = typeof message.content === "string" ? [{ type: "text" as const, text: message.content }] : message.content;
+    for (const block of content) {
+      if (block.type === "text") result.prompt += block.text;
+      else {
+        if (!model.supportsImages) throw new Error("This model does not support images in history or tool results.");
+        const converted = imageFromBase64(block.data, block.mimeType);
+        imageBytes += converted.sizeBytes;
+        if (imageBytes > MAX_IMAGES_BYTES) throw new Error(`Images in one message must total at most ${MAX_IMAGES_BYTES} bytes.`);
+        (result.images ??= []).push(converted.image);
+      }
+    }
+    messages.push(result);
+  }
+  return { messages, tools, systemPrompt: getCurrentSystemPrompt(context.messages) };
+}