cortico 0.1.0

package/src/core/state.ts

@@ -0,0 +1,104 @@
+/** Core 机械状态，持久化到 `<dataDir>/core-state.json`。 */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export interface CoreStateData {
+  /** 上次截断时刻ISO */
+  lastTruncateAt: string | null;
+  /**
+   * 投递水位：该游标及之前的事件均已投递或已了结。
+   * 总线不持久化；重启仅补投水位之后需要投递的外部事件。
+   */
+  lastDeliveredCursor: number;
+  /**
+   * LLM 连续失败状态，时间单位为毫秒。since 为起点，0 表示没有连续失败；
+   * at 保存窗口内的失败时刻，重启后首次成功仍可报告。
+   */
+  llmStall: { since: number; at: number[] };
+  /** Persona所有的不透明状态；core 仅负责原子持久化。 */
+  persona: Record<string, unknown>;
+  /** World 可见性默认开启并跨重启保留；隐藏不改变挂载或运行状态。 */
+  worldVisibility: Record<string, boolean>;
+}
+
+const DEFAULTS: CoreStateData = {
+  lastTruncateAt: null,
+  lastDeliveredCursor: 0,
+  llmStall: { since: 0, at: [] },
+  persona: {},
+  worldVisibility: {},
+};
+
+function freshDefaults(): CoreStateData {
+  return { ...DEFAULTS, llmStall: { since: 0, at: [] }, persona: {}, worldVisibility: {} };
+}
+
+function readStall(raw: unknown): { since: number; at: number[] } {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { since: 0, at: [] };
+  const r = raw as { since?: unknown; at?: unknown };
+  return {
+    since: typeof r.since === 'number' && Number.isFinite(r.since) ? r.since : 0,
+    at: Array.isArray(r.at)
+      ? r.at.filter((t): t is number => typeof t === 'number' && Number.isFinite(t))
+      : [],
+  };
+}
+
+export class CoreState {
+  private file: string;
+  // 各实例需独立的 Persona 状态对象，不能共享 DEFAULTS 中的引用。
+  data: CoreStateData = freshDefaults();
+
+  constructor(dataDir: string) {
+    this.file = join(dataDir, 'core-state.json');
+  }
+
+  load(): void {
+    this.data = freshDefaults();
+    if (!existsSync(this.file)) return;
+    try {
+      const raw = JSON.parse(readFileSync(this.file, 'utf8')) as Partial<CoreStateData>;
+      this.data = {
+        lastTruncateAt: raw.lastTruncateAt ?? DEFAULTS.lastTruncateAt,
+        lastDeliveredCursor: Number.isInteger(raw.lastDeliveredCursor)
+          ? (raw.lastDeliveredCursor as number)
+          : DEFAULTS.lastDeliveredCursor,
+        llmStall: readStall(raw.llmStall),
+        persona:
+          raw.persona && typeof raw.persona === 'object' && !Array.isArray(raw.persona)
+            ? (raw.persona as Record<string, unknown>)
+            : {},
+        worldVisibility:
+          raw.worldVisibility && typeof raw.worldVisibility === 'object' && !Array.isArray(raw.worldVisibility)
+            ? Object.fromEntries(
+                Object.entries(raw.worldVisibility as Record<string, unknown>).map(([k, v]) => [k, v !== false]),
+              )
+            : {},
+      };
+    } catch {
+      // 损坏则用默认值
+    }
+  }
+
+  save(): void {
+    const dir = dirname(this.file);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const tmp = this.file + '.tmp';
+    writeFileSync(tmp, JSON.stringify(this.data, null, 2), 'utf8');
+    // 通过 rename 原子覆盖状态文件，不先删除，避免崩溃后状态缺失。Windows 的 renameSync 使用 MoveFileExW 与 MOVEFILE_REPLACE_EXISTING 支持覆盖。
+    renameSync(tmp, this.file);
+  }
+
+  /**
+   * 清除人格状态与截断标记并落盘。投递水位和运维可见性跨重置保留，避免重放
+   * 已投递事件或改变 World 可见性。
+   */
+  clear(): void {
+    this.data = {
+      ...freshDefaults(),
+      lastDeliveredCursor: this.data.lastDeliveredCursor,
+      worldVisibility: this.data.worldVisibility,
+    };
+    this.save();
+  }
+}

package/src/core/template.ts

@@ -0,0 +1,72 @@
+/**
+ * 模板语法：
+ * {{name}}：已声明变量为空时展开为空串。
+ * {{name | 缺省文案}}：已声明变量为空时使用缺省文案。
+ * 未在值表声明的占位符原样保留。
+ */
+
+/** `{{名字}}` 或 `{{名字 | 缺省文案}}`。名字限 `[\w.]`,缺省文案吃到 `}}` 为止。 */
+const PLACEHOLDER = /\{\{\s*([\w.]+)\s*(?:\|([^}]*))?\}\}/g;
+
+/** 模板里出现过的占位符名(按出现序,去重)。编辑器用它标"已用/未使用"。 */
+export function templateVarNames(template: string): string[] {
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (const m of template.matchAll(PLACEHOLDER)) {
+    const name = m[1];
+    if (!seen.has(name)) { seen.add(name); names.push(name); }
+  }
+  return names;
+}
+
+/**
+ * 渲染模板，vars 中缺席的占位符原样保留，默认值与空串规则见文件头。
+ */
+export function renderTemplate(template: string, vars: Readonly<Record<string, string>>): string {
+  return template.replace(PLACEHOLDER, (whole, name: string, fallback?: string) => {
+    if (!Object.prototype.hasOwnProperty.call(vars, name)) return whole;
+    const value = vars[name] ?? '';
+    if (value !== '') return value;
+    return fallback === undefined ? '' : fallback.trim();
+  });
+}
+
+/** 未在值表声明的占位符；控制台据此提示，仍允许保存。 */
+export function unknownVarNames(
+  template: string,
+  declared: readonly string[],
+): string[] {
+  const known = new Set(declared);
+  return templateVarNames(template).filter((name) => !known.has(name));
+}
+
+/** 顶层模板切出来的一段:`name` 是那个占位符,`text` 是它连同前面的字面文本。 */
+export interface RenderedSection {
+  name: string;
+  text: string;
+}
+
+/**
+ * 按占位符切分，满足 sections.map(s => s.text).join('') === text。
+ * 每段包含占位符前的字面文本，末尾文本归最后一段。
+ * 没有占位符时返回一段完整文本，name 为空串。
+ */
+export function renderSections(
+  template: string,
+  vars: Readonly<Record<string, string>>,
+): { text: string; sections: RenderedSection[] } {
+  const sections: RenderedSection[] = [];
+  let cursor = 0;
+  for (const m of template.matchAll(PLACEHOLDER)) {
+    const start = m.index ?? 0;
+    sections.push({
+      name: m[1],
+      text: template.slice(cursor, start) + renderTemplate(m[0], vars),
+    });
+    cursor = start + m[0].length;
+  }
+  const tail = template.slice(cursor);
+  if (sections.length === 0) return { text: tail, sections: [{ name: '', text: tail }] };
+  if (tail) sections[sections.length - 1].text += tail;
+  return { text: sections.map((s) => s.text).join(''), sections };
+}

package/src/core/timers.ts

@@ -0,0 +1,129 @@
+/**
+ * 通用持久定时器:到点回调持有方、跨重启恢复。载荷不透明——
+ * 闹钟的备注、阻断、关键词这些语义归持有它的Persona。
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import type { Logger, TimerEntry, TimersApi } from './types.ts';
+import { nullLogger, shortId } from './util.ts';
+
+const MAX_TIMEOUT = 2 ** 31 - 1; // setTimeout上限(~24.8天)
+
+export class TimerStore implements TimersApi {
+  private file: string;
+  private log: Logger;
+  private entries: TimerEntry[] = [];
+  private timers = new Map<string, ReturnType<typeof setTimeout>>();
+  private started = false;
+  private dueHandler: ((entry: TimerEntry) => void) | null = null;
+
+  /** 构造时即读盘,attach 阶段就能 list();到期定时在 start() 才布防。 */
+  constructor(dataDir: string, log: Logger = nullLogger()) {
+    this.file = join(dataDir, 'timers.json');
+    this.log = log;
+    this.load();
+  }
+
+  onDue(handler: (entry: TimerEntry) => void): void {
+    this.dueHandler = handler;
+  }
+
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+    for (const e of [...this.entries]) this.arm(e);
+  }
+
+  stop(): void {
+    this.started = false;
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+  }
+
+  set(atIso: string, payload: Record<string, unknown> = {}): { ok: true; id: string } | { ok: false; error: string } {
+    if (Number.isNaN(Date.parse(atIso))) {
+      return { ok: false, error: `could not parse time "${atIso}"` };
+    }
+    const entry: TimerEntry = { id: shortId('wake_'), atIso, payload };
+    this.entries.push(entry);
+    this.save();
+    if (this.started) this.arm(entry);
+    return { ok: true, id: entry.id };
+  }
+
+  cancel(id: string): boolean {
+    const idx = this.entries.findIndex((e) => e.id === id);
+    if (idx < 0) return false;
+    this.entries.splice(idx, 1);
+    const t = this.timers.get(id);
+    if (t) clearTimeout(t);
+    this.timers.delete(id);
+    this.save();
+    return true;
+  }
+
+  list(): ReadonlyArray<TimerEntry> {
+    return this.entries;
+  }
+
+  clearAll(): number {
+    const n = this.entries.length;
+    this.entries = [];
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    this.save();
+    if (n > 0) this.log.warn('定时器已全部清除', { cleared: n });
+    return n;
+  }
+
+  private arm(entry: TimerEntry): void {
+    const delay = Date.parse(entry.atIso) - Date.now();
+    if (delay <= 0) {
+      this.fire(entry.id);
+      return;
+    }
+    const existing = this.timers.get(entry.id);
+    if (existing) clearTimeout(existing);
+    if (delay > MAX_TIMEOUT) {
+      // 超长延迟按 MAX_TIMEOUT 分段重新 arm。
+      this.timers.set(entry.id, setTimeout(() => this.arm(entry), MAX_TIMEOUT));
+    } else {
+      this.timers.set(entry.id, setTimeout(() => this.fire(entry.id), delay));
+    }
+  }
+
+  private fire(id: string): void {
+    if (!this.started) return;
+    const idx = this.entries.findIndex((e) => e.id === id);
+    if (idx < 0) return;
+    const entry = this.entries[idx];
+    this.entries.splice(idx, 1);
+    const t = this.timers.get(id);
+    if (t) clearTimeout(t);
+    this.timers.delete(id);
+    this.save();
+    if (this.dueHandler) this.dueHandler(entry);
+    else this.log.warn('定时器到期但无人认领', { id, atIso: entry.atIso });
+  }
+
+  private load(): void {
+    if (existsSync(this.file)) {
+      try {
+        const raw = JSON.parse(readFileSync(this.file, 'utf8')) as TimerEntry[];
+        this.entries = Array.isArray(raw) ? raw : [];
+      } catch {
+        this.log.warn('timers.json损坏,已重置为空');
+        this.entries = [];
+      }
+    }
+  }
+
+  private save(): void {
+    const dir = dirname(this.file);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const tmp = this.file + '.tmp';
+    writeFileSync(tmp, JSON.stringify(this.entries, null, 2), 'utf8');
+    if (existsSync(this.file)) rmSync(this.file);
+    renameSync(tmp, this.file);
+  }
+}

package/src/core/tool-log.ts

@@ -0,0 +1,135 @@
+/**
+ * 模型工具调用写入 data/runs/<run>/toolcalls.jsonl，每次调用一行。
+ * args 保留模型原始参数；receipt 保存摘要，chars 记录全文长度。
+ * 完整回执可通过 call 在 transcript.jsonl 中查找。
+ */
+import { appendFileSync, existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { currentAnchors } from './log-context.ts';
+import { nowIso } from './util.ts';
+
+/** 回执正文进流水的上限;全长另记在 chars,全文在 transcript 里 */
+const RECEIPT_CHARS = 600;
+
+export interface ToolCallInput {
+  /** 发起调用的 session 声明 id */
+  role: string;
+  tool: string;
+  /** 工具所属 World id；Persona 工具不填。 */
+  mod?: string;
+  /** 模型原始参数，未经 World 归一化。 */
+  args: Record<string, unknown> | null;
+  durMs: number;
+  /** 回执全长(字符);receipt 只留前 RECEIPT_CHARS 个 */
+  chars: number;
+  receipt: string;
+  /** handler 抛错或 ToolOutcome.failed 标记的失败。 */
+  failed?: true;
+  /** 回执带的媒体件数 */
+  blobs?: number;
+}
+
+export interface ToolCallEntry extends ToolCallInput {
+  seq: number;
+  ts: string;
+  run: string;
+  round?: number;
+  resp?: string;
+  /** session 里的 tool_call id,与 transcript 的 function_call / function_call_output 对上 */
+  call?: string;
+}
+
+export interface ToolCallLogOptions {
+  timezone?: string;
+  run?: string;
+}
+
+/** JSONL 追加;不给文件名就只计数(测试与未配目录的部署) */
+export class ToolCallLog {
+  private seq = 0;
+  private dirReady = false;
+  private readonly timezone: string;
+  private readonly run: string;
+
+  constructor(private readonly file: string | null, opts: ToolCallLogOptions = {}) {
+    this.timezone = opts.timezone ?? 'Asia/Shanghai';
+    this.run = opts.run ?? 'r-none';
+  }
+
+  write(input: ToolCallInput): ToolCallEntry {
+    const anchors = currentAnchors();
+    const entry: ToolCallEntry = {
+      seq: ++this.seq,
+      ts: nowIso(this.timezone),
+      run: this.run,
+      ...(anchors.round !== undefined ? { round: anchors.round } : {}),
+      ...(anchors.resp !== undefined ? { resp: anchors.resp } : {}),
+      ...(anchors.call !== undefined ? { call: anchors.call } : {}),
+      ...input,
+      receipt: input.receipt.slice(0, RECEIPT_CHARS),
+    };
+    this.append(entry);
+    return entry;
+  }
+
+  /** 控制台存储清单的规模描述 */
+  stat(): string {
+    const size = this.bytes();
+    return `${this.seq}条 / ${size === null ? '(无文件)' : `${(size / 1024).toFixed(1)}KB`}`;
+  }
+
+  clear(): void {
+    if (!this.file || !existsSync(this.file)) return;
+    try {
+      writeFileSync(this.file, '', 'utf8');
+    } catch {
+      // 清空失败不致命
+    }
+  }
+
+  private bytes(): number | null {
+    if (!this.file || !existsSync(this.file)) return null;
+    try {
+      return statSync(this.file).size;
+    } catch {
+      return null;
+    }
+  }
+
+  private append(entry: ToolCallEntry): void {
+    if (!this.file) return;
+    try {
+      if (!this.dirReady) {
+        mkdirSync(dirname(this.file), { recursive: true });
+        this.dirReady = true;
+      }
+      appendFileSync(this.file, `${JSON.stringify(entry)}\n`, 'utf8');
+    } catch {
+      // 日志写不进去不影响运行
+    }
+  }
+}
+
+/** 一次调用的落盘记录(执行方在 handler 前后各取一次时刻) */
+export function recordToolCall(
+  log: ToolCallLog | undefined,
+  role: string,
+  tool: string,
+  args: Record<string, unknown> | null,
+  startedAt: number,
+  out: { text: string; blobs?: unknown[]; failed?: true },
+  mod?: string,
+): void {
+  if (!log) return;
+  log.write({
+    role,
+    tool,
+    ...(mod ? { mod } : {}),
+    args,
+    durMs: Date.now() - startedAt,
+    chars: out.text.length,
+    receipt: out.text,
+    ...(out.failed ? { failed: true as const } : {}),
+    ...(out.blobs?.length ? { blobs: out.blobs.length } : {}),
+  });
+}

package/src/core/transcript.ts

@@ -0,0 +1,92 @@
+/**
+ * 主 session 的追加记录，保存在 data/runs/<run>/transcript.jsonl。
+ * session-main.jsonl 会在上下文替换时重写；本文件保留每次追加的正文，
+ * 并在交接、清空和前缀重载时写入边界记录。
+ */
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import type { ContextRecord } from '../protocol/open-responses/context.ts';
+import { currentAnchors } from './log-context.ts';
+import { nowIso } from './util.ts';
+
+export type TranscriptBoundary = 'handoff' | 'clear' | 'prefix-reload' | 'ephemeral-drop';
+
+export interface TranscriptItemRecord {
+  kind: 'item';
+  ts: string;
+  run: string;
+  sess?: string;
+  round?: number;
+  /** session 里的下标(append 时刻) */
+  index: number;
+  item: ContextRecord['item'];
+  context: ContextRecord['context'];
+}
+
+export interface TranscriptBoundaryRecord {
+  kind: 'boundary';
+  ts: string;
+  run: string;
+  sess?: string;
+  round?: number;
+  event: TranscriptBoundary;
+  data: Record<string, unknown>;
+}
+
+export type TranscriptRecord = TranscriptItemRecord | TranscriptBoundaryRecord;
+
+export interface TranscriptOptions {
+  run?: string;
+  timezone?: string;
+}
+
+export class Transcript {
+  private readonly run: string;
+  private readonly timezone: string;
+  private dirReady = false;
+
+  constructor(private readonly file: string | null, opts: TranscriptOptions = {}) {
+    this.run = opts.run ?? 'r-none';
+    this.timezone = opts.timezone ?? 'Asia/Shanghai';
+  }
+
+  item(record: ContextRecord, index: number): void {
+    const anchors = currentAnchors();
+    this.append({
+      kind: 'item',
+      ts: record.context.ts ?? nowIso(this.timezone),
+      run: this.run,
+      ...(anchors.sess !== undefined ? { sess: anchors.sess } : {}),
+      ...(anchors.round !== undefined ? { round: anchors.round } : {}),
+      index,
+      item: record.item,
+      context: record.context,
+    });
+  }
+
+  boundary(event: TranscriptBoundary, data: Record<string, unknown>): void {
+    const anchors = currentAnchors();
+    this.append({
+      kind: 'boundary',
+      ts: nowIso(this.timezone),
+      run: this.run,
+      ...(anchors.sess !== undefined ? { sess: anchors.sess } : {}),
+      ...(anchors.round !== undefined ? { round: anchors.round } : {}),
+      event,
+      data,
+    });
+  }
+
+  private append(record: TranscriptRecord): void {
+    if (!this.file) return;
+    try {
+      if (!this.dirReady) {
+        mkdirSync(dirname(this.file), { recursive: true });
+        this.dirReady = true;
+      }
+      appendFileSync(this.file, `${JSON.stringify(record)}\n`, 'utf8');
+    } catch {
+      // 写不进去不影响运行
+    }
+  }
+}

package/src/core/truncate.ts

@@ -0,0 +1,121 @@
+/** Context compaction retains Item identity and repairs function-call pairing across response boundaries. */
+import { functionResult, withText, type ContextRecord } from '../protocol/open-responses/context.ts';
+import { hasRole, textOf } from '../protocol/open-responses/context-helpers.ts';
+import {
+  FOLD_ARGS_PLACEHOLDER,
+  FOLD_PLACEHOLDER,
+  MISSING_RESULT,
+  OVERSIZE_PLACEHOLDER,
+  PENDING_IN_MAIN_THREAD,
+} from './markers.ts';
+import { estimateMessagesTokens } from './util.ts';
+
+/** 回执与入参超过这么多字符就折叠成记号 */
+export const FOLD_THRESHOLD = 600;
+
+function responseKey(entry: ContextRecord): string | null {
+  return entry.context.responseId ?? null;
+}
+
+export function rebuildTail(
+  tail: readonly ContextRecord[],
+  budgetTokens: number,
+  estimate: (records: readonly ContextRecord[]) => number = estimateMessagesTokens,
+): ContextRecord[] {
+  if (!tail.length) return [];
+  const calls = new Set(tail.flatMap(({ item }) => item.type === 'function_call' ? [item.call_id] : []));
+  const folded = tail.map(entry => {
+    const item = entry.item;
+    if (item.type === 'function_call' && item.arguments.length > FOLD_THRESHOLD) {
+      return { ...entry, item: { ...item, arguments: FOLD_ARGS_PLACEHOLDER } };
+    }
+    if (item.type === 'function_call_output' && calls.has(item.call_id) && textOf(entry).length > FOLD_THRESHOLD) {
+      return withText(entry, FOLD_PLACEHOLDER);
+    }
+    return entry;
+  });
+  const oversized = new Set<number>();
+  let total = 0;
+  let budgetStart = 0;
+  for (let index = folded.length - 1; index >= 0; index--) {
+    const tokens = estimate([folded[index]]);
+    if (tokens > budgetTokens && index < folded.length - 1) { oversized.add(index); continue; }
+    if (total + tokens > budgetTokens && total > 0) { budgetStart = index + 1; break; }
+    total += tokens;
+  }
+  let start = folded.findIndex((entry, index) => index >= budgetStart && hasRole(entry, 'user'));
+  if (start < 0) start = budgetStart;
+  // A retained response begins at its first Item, including reasoning before its calls.
+  const key = responseKey(folded[start]);
+  while (start > 0 && key !== null && responseKey(folded[start - 1]) === key) start--;
+  const kept = folded.slice(start).map((entry, offset) => {
+    if (!oversized.has(start + offset)) return entry;
+    const item = entry.item;
+    if (item.type === 'message' || item.type === 'function_call_output') return withText(entry, OVERSIZE_PLACEHOLDER);
+    if (item.type === 'reasoning') return { ...entry, item: { type: 'reasoning' as const, id: item.id ?? 'rs_folded', summary: [{ type: 'summary_text' as const, text: OVERSIZE_PLACEHOLDER }] } };
+    return entry;
+  });
+  return fixPairing(kept);
+}
+
+/** Multiple calls, reasoning Items and commentary within one response share a pairing scope. */
+export function fixPairing(records: readonly ContextRecord[]): ContextRecord[] {
+  const out: ContextRecord[] = [];
+  const open = new Set<string>();
+  let group: string | null = null;
+  const close = (): void => {
+    for (const id of open) out.push(functionResult(id, MISSING_RESULT));
+    open.clear();
+  };
+  for (const entry of records) {
+    const item = entry.item;
+    if (item.type === 'function_call_output') {
+      if (open.delete(item.call_id)) out.push(entry);
+      continue;
+    }
+    const key = responseKey(entry);
+    if (hasRole(entry, 'user') || hasRole(entry, 'system') || hasRole(entry, 'developer') || (key !== null && group !== null && key !== group)) close();
+    if (key !== null) group = key;
+    out.push(entry);
+    if (item.type === 'function_call') open.add(item.call_id);
+  }
+  close();
+  return out;
+}
+
+export function validatePairing(records: readonly ContextRecord[]): string[] {
+  const problems: string[] = [];
+  const open = new Set<string>();
+  const seen = new Set<string>();
+  let group: string | null = null;
+  const close = (): void => {
+    if (open.size) problems.push(`Unanswered function calls: ${[...open].join(',')}`);
+    open.clear();
+  };
+  records.forEach((entry, index) => {
+    const item = entry.item;
+    if (item.type === 'function_call_output') {
+      if (!open.delete(item.call_id)) problems.push(`#${index} orphan function output: ${item.call_id}`);
+      return;
+    }
+    const key = responseKey(entry);
+    if (hasRole(entry, 'user') || hasRole(entry, 'system') || hasRole(entry, 'developer') || (key !== null && group !== null && key !== group)) close();
+    if (key !== null) group = key;
+    if (item.type === 'function_call') {
+      if (seen.has(item.call_id)) problems.push(`#${index} duplicate call_id: ${item.call_id}`);
+      seen.add(item.call_id);
+      open.add(item.call_id);
+    }
+  });
+  close();
+  return problems;
+}
+
+export function closeDanglingCalls(records: readonly ContextRecord[]): ContextRecord[] {
+  const open = new Set<string>();
+  for (const { item } of records) {
+    if (item.type === 'function_call') open.add(item.call_id);
+    if (item.type === 'function_call_output') open.delete(item.call_id);
+  }
+  return [...records, ...[...open].map(id => functionResult(id, PENDING_IN_MAIN_THREAD))];
+}