@qjp88995/agent-runtime 0.0.0-stage → 0.1.1

package/src/ports/index.ts

@@ -0,0 +1,56 @@
+export type {
+  ContextInputs,
+  ContextRow,
+  ContextStore,
+} from './context-store.js';
+export type {
+  ConversationMessage,
+  ConversationStore,
+  InboxItem,
+  InboxMessageKind,
+  InboxSourceKind,
+  ListMessagesFilter,
+  NewConversationMessage,
+} from './conversation-store.js';
+export {
+  AWAIT_LEASE_TTL_MS,
+  AWAIT_RENEW_INTERVAL_MS,
+  LOCK_TTL_MS,
+  type SessionLock,
+  type SubagentAwaitLease,
+  type TreeBudget,
+  type WakeChannel,
+} from './coordination.js';
+export type { ImageBytes, ImageSource } from './image-source.js';
+export {
+  consoleLogger,
+  type Logger,
+  type LoggerFactory,
+  silentLogger,
+} from './logger.js';
+export {
+  type NewQuestion,
+  QuestionConflictError,
+  type QuestionProbe,
+  type QuestionRecord,
+  type QuestionStore,
+  type SettledQuestionStatus,
+} from './question-store.js';
+export type {
+  RunFinishInput,
+  RunOpenInput,
+  RunStore,
+  StaleRun,
+} from './run-store.js';
+export type {
+  NewSubSession,
+  SessionKind,
+  SessionRecord,
+  SessionStore,
+} from './session-store.js';
+export type { SessionStreamEntry, StreamBus } from './stream-bus.js';
+export type {
+  VendorFileCache,
+  VendorFileKey,
+  VendorFileRecord,
+} from './vendor-file-cache.js';

package/src/ports/logger.ts

@@ -0,0 +1,34 @@
+/** 日志端口。runtime 不依赖任何日志框架；Nest 适配把它接到 Nest 的 Logger。 */
+export interface Logger {
+  debug(message: string): void;
+  log(message: string): void;
+  warn(message: string): void;
+  error(message: string, stack?: string): void;
+}
+
+/** 按作用域取一个 logger（对应 Nest 的 `new Logger(Class.name)`）。 */
+export type LoggerFactory = (scope: string) => Logger;
+
+/** 缺省实现：写 console，带作用域前缀；debug 只在 `AGENT_RUNTIME_DEBUG` 设置时输出。 */
+export const consoleLogger: LoggerFactory = scope => {
+  const tag = `[${scope}]`;
+  return {
+    debug: message => {
+      if (process.env.AGENT_RUNTIME_DEBUG) console.debug(tag, message);
+    },
+    log: message => console.log(tag, message),
+    warn: message => console.warn(tag, message),
+    error: (message, stack) =>
+      stack
+        ? console.error(tag, message, '\n', stack)
+        : console.error(tag, message),
+  };
+};
+
+/** 什么都不输出（单测用）。 */
+export const silentLogger: LoggerFactory = () => ({
+  debug: () => {},
+  log: () => {},
+  warn: () => {},
+  error: () => {},
+});

package/src/ports/question-store.ts

@@ -0,0 +1,117 @@
+import type {
+  AgentQuestionAnswer,
+  AgentQuestionStatus,
+  AskQuestionItem,
+} from '../builtins/ask-schema.js';
+
+/**
+ * `Ask` 工具的问题行。搬自 agent-base 的 `agent_question` 表：每一次提问一行，
+ * `pending` 的那一行就是「这一轮正在等用户」。
+ *
+ * **时间一律按存储自己的时钟**（数据库实现里是 `now()`）：期限在落行时由存储算出，
+ * 「到点没有」也由存储判——等待方、回答接口可能在不同实例上，各自的挂钟比出来的
+ * 结果不可信（容器的挂钟还会回拨）。
+ */
+export interface QuestionRecord {
+  id: string;
+  sessionId: string;
+  userId: string;
+  /** 提问的那一轮。 */
+  runId: string;
+  /** 那次 `Ask` 调用；界面按它把这一行对到工具卡上。 */
+  toolCallId: string;
+  questions: AskQuestionItem[];
+  status: AgentQuestionStatus;
+  /** null = 不限时（或已经停表，见 `hold`）。 */
+  deadlineAt: Date | null;
+  /** `answered` 是用户选的，`expired` 是默认项，其余为 null。 */
+  answers: AgentQuestionAnswer[] | null;
+  createdAt: Date;
+  resolvedAt: Date | null;
+}
+
+export type SettledQuestionStatus = Exclude<AgentQuestionStatus, 'pending'>;
+
+export interface NewQuestion {
+  sessionId: string;
+  userId: string;
+  runId: string;
+  toolCallId: string;
+  questions: AskQuestionItem[];
+  /** 从落行起多少秒到期；缺省不限时。 */
+  timeoutSeconds?: number;
+}
+
+/** `probe` 的读数：那一行，加上按存储时钟判出的两个标志。 */
+export interface QuestionProbe {
+  question: QuestionRecord;
+  /** 有期限且已到。 */
+  due: boolean;
+  /** 从落行起已经过了 `maxWaitSeconds`。 */
+  overdue: boolean;
+}
+
+/** 同一个会话里同一轮已有一个问题在等（`open` 抛它）。 */
+export class QuestionConflictError extends Error {
+  constructor(sessionId: string) {
+    super(`session ${sessionId} already has a pending question`);
+    this.name = 'QuestionConflictError';
+  }
+}
+
+/**
+ * 问题行的存储。
+ *
+ * **一个会话同时至多一个 pending**（数据库实现：`sessionId` 上 `status = 'pending'`
+ * 的部分唯一索引）。所有「给结局」的写法都带 `status = 'pending'` 谓词——回答、到点、
+ * 改为打字、停止抢的是同一句原子更新，只有一个生效。
+ */
+export interface QuestionStore {
+  /**
+   * 落一个新问题，**一个原子步骤**里先把这个会话里**别的轮次**留下的 pending 作废
+   * （那只可能是残骸：等它的那一轮已经死了），再插入。同一轮已有 pending 时抛
+   * `QuestionConflictError`（同一步里的第二次调用，让模型合并）。
+   *
+   * 返回新行与被作废的残骸（调用方要把它们也广播出去）。
+   */
+  open(
+    input: NewQuestion
+  ): Promise<{ question: QuestionRecord; swept: QuestionRecord[] }>;
+
+  /** 读一行并按存储时钟判到期；行不存在（会话被删）返回 null。 */
+  probe(id: string, maxWaitSeconds: number): Promise<QuestionProbe | null>;
+
+  /** 读一行；限定会话时，不属于它的当不存在。 */
+  get(id: string, sessionId?: string): Promise<QuestionRecord | null>;
+
+  /**
+   * 给一个 pending 的问题一个结局（CAS：仅当仍是 pending）。没抢到返回 null。
+   * 同时写 `resolvedAt`。
+   */
+  settle(
+    id: string,
+    status: SettledQuestionStatus,
+    answers: AgentQuestionAnswer[] | null
+  ): Promise<QuestionRecord | null>;
+
+  /**
+   * 这个会话所有 pending（或仅 `onlyId` 那一个）一律记为 `status`，返回被改的行。
+   */
+  settleSession(
+    sessionId: string,
+    status: Extract<SettledQuestionStatus, 'superseded' | 'cancelled'>,
+    onlyId?: string
+  ): Promise<QuestionRecord[]>;
+
+  /**
+   * 停表：仅当仍是 pending **且**还有期限时把期限摘掉，返回改后的行；条件不满足
+   * 返回 null（调用方自己读当前行）。与到点互斥靠同一个 pending 谓词。
+   */
+  hold(id: string, sessionId: string): Promise<QuestionRecord | null>;
+
+  /** 这个会话问过的全部问题，按落行时间正序。 */
+  list(sessionId: string): Promise<QuestionRecord[]>;
+
+  /** 存储时钟（算 `remainingMs` 用）。 */
+  now(): Promise<Date>;
+}

package/src/ports/run-store.ts

@@ -0,0 +1,69 @@
+import type {
+  AgentRunStatus,
+  AgentRunStepEntry,
+  StopReason,
+} from '../schema/agent-run.js';
+
+/**
+ * 开一个跑次要记的东西。
+ *
+ * `attrs` 是宿主的不透明附加列：跑的是哪个 agent（agent-base 是 `agent_id` / `builtin_agent`
+ * 两列二选一）、发布版号、账本序号……runtime 不解释，只从 turn 的入参原样转交给存储。
+ */
+export interface RunOpenInput {
+  id: string;
+  streamId: string;
+  parentRunId: string | null;
+  depth: number;
+  sessionId: string | null;
+  /** 父写给子的任务；根跑次为 null。 */
+  prompt: string | null;
+  /** 本轮实际用的模型与推理档位。 */
+  model: { modelId: string; label: string; reasoningEffort: string };
+  attrs?: Readonly<Record<string, unknown>>;
+}
+
+export interface RunFinishInput {
+  id: string;
+  status: AgentRunStatus;
+  stopReason: StopReason | null;
+  text: string;
+  steps: AgentRunStepEntry[];
+  usage?: Record<string, number>;
+  error?: string;
+}
+
+/** 孤儿收尾的候选（仍是 running 且开跑已久）。 */
+export interface StaleRun {
+  id: string;
+  streamId: string;
+  sessionId: string | null;
+  /** 补发会话事件要按根会话定位；会话已删时为 null。 */
+  rootSessionId: string | null;
+  parentRunId: string | null;
+  depth: number;
+}
+
+/**
+ * 跑次记录。搬自 agent-base `agent-core/runtime/agent-run.service.ts`，只留 runtime 要用的；
+ * 给界面用的读接口（调用树、按 agent 显示名）留在宿主。
+ */
+export interface RunStore {
+  /** 跑次开始即建记录（status = running）。 */
+  open(input: RunOpenInput): Promise<void>;
+  finish(input: RunFinishInput): Promise<void>;
+  /**
+   * 仍是 running、且开跑已超过 `olderThanMs` 的跑次——只出候选，是不是孤儿由调用方
+   * 问会话锁。时间下限挡住「刚 open、锁还没抢上」的窗口。
+   */
+  findStaleRunning(olderThanMs: number): Promise<StaleRun[]>;
+  /**
+   * 把一条孤儿收成 aborted。**只在它仍是 running 时生效**，返回是否由本次调用翻的牌
+   * （并发下只可能成功一次；调用方据此决定要不要再去改消息、发事件）。
+   */
+  markInterrupted(id: string, error: string): Promise<boolean>;
+  /** 跑次所属会话；缺记录返回 null。 */
+  getSessionId(runId: string): Promise<string | null>;
+  /** 跑次深度；缺记录返回 0。 */
+  getDepth(runId: string): Promise<number>;
+}

package/src/ports/session-store.ts

@@ -0,0 +1,80 @@
+/**
+ * 会话行：loop 与子 Agent 要读写的那几个字段。搬自 agent-base `chat_session` 被
+ * `subagent-session.service` / `loop-driver` 读写的部分；会话的其余一切（标题怎么改、
+ * 谁看得见、列表、删除）归宿主。
+ *
+ * **根会话由宿主建**（用户开对话是宿主的事），runtime 只建子会话。
+ */
+
+export type SessionKind = 'root' | 'subagent';
+
+export interface SessionRecord {
+  id: string;
+  kind: SessionKind;
+  /** 根会话 id；根会话等于自己的 id。 */
+  rootSessionId: string;
+  /** 子会话：派它的那一轮（父的跑次 id）。父会话经 `RunStore.getSessionId` 由它找到。根会话 null。 */
+  parentRunId: string | null;
+  /**
+   * 子会话钉住的子 Agent 名（派生时给的名字，可能是改名前的旧名——查定义要认
+   * `formerNames`）。根会话 null。
+   */
+  subagentName: string | null;
+  title: string | null;
+  userId: string | null;
+  /**
+   * 里程碑游标：上次回投覆盖到的子会话消息 `seq`。**null = 从未到达过 idle 终态**
+   * （＝「存活」，占着树的名额）。只经 `advanceMilestone` 的 CAS 推进。根会话恒 null。
+   */
+  lastMilestoneSeq: number | null;
+  /** 会话上的不透明附加信息（`ToolContext.sessionMetadata`）；子会话照抄父的。 */
+  metadata: Readonly<Record<string, unknown>>;
+  /** 宿主的不透明附加列（agent-base：跑哪个 agent、哪一版）。runtime 不解释。 */
+  attrs: Readonly<Record<string, unknown>>;
+}
+
+export interface NewSubSession {
+  rootSessionId: string;
+  parentRunId: string;
+  subagentName: string;
+  userId: string | null;
+  title: string;
+  metadata?: Readonly<Record<string, unknown>>;
+  attrs?: Readonly<Record<string, unknown>>;
+}
+
+export interface SessionStore {
+  /** 建一个子会话（`kind = 'subagent'`、游标 null）。 */
+  createSubSession(input: NewSubSession): Promise<SessionRecord>;
+
+  /** 会话行；不存在（或已删）返回 null。 */
+  getSession(id: string): Promise<SessionRecord | null>;
+
+  /**
+   * 里程碑游标的**乐观 CAS**：仅当游标仍等于 `expected`（null 即「仍为空」）时写成
+   * `next`，返回是否写成。
+   *
+   * 子会话的收尾可能并发进来两次（两次抢锁成功的唤醒），都读到同一个旧游标；恰有一个
+   * 能从它推进——回投、唤醒父、还名额这些副作用全收在这一步之后，所以恰好发生一次。
+   * 游标是整数，写回读出不丢精度（时间戳版本靠「两边都截到毫秒」才成立，一环换成
+   * 微秒就静默失配）。
+   */
+  advanceMilestone(
+    id: string,
+    expected: number | null,
+    next: number
+  ): Promise<boolean>;
+
+  /**
+   * 兜底扫描的候选：子会话、`idleForMs` 内没有新动静（`ConversationStore` 记的那个
+   * 「更新时间」）、且有 `seq > coalesce(游标, 0)` 的 assistant 消息——收尾可能在回投之前
+   * 崩掉，这些是「跑完了却没人通知父」的嫌疑。是不是真的漏了由收尾自己判（它是幂等的）。
+   */
+  listSubagentSessionsForSweep(idleForMs: number): Promise<SessionRecord[]>;
+
+  /**
+   * 每棵树此刻「存活」的子会话数（`kind = 'subagent'` 且游标为 null）。零存活的树
+   * 可以不出现，调用方自己补 0。兜底扫描据此校正 `TreeBudget`。
+   */
+  countAliveSubsByRoot(): Promise<{ rootSessionId: string; count: number }[]>;
+}

package/src/ports/stream-bus.ts

@@ -0,0 +1,59 @@
+import type { AgentEvent } from '../schema/agent-event.js';
+
+/** 会话级订阅的一条：游标（断线续订用，实现自定格式）+ 领域事件。 */
+export interface SessionStreamEntry {
+  id: string;
+  event: AgentEvent;
+}
+
+/**
+ * 事件总线。搬自 agent-base `agent-core/events/stream-bus.interface.ts`。
+ *
+ * 两个面：
+ * - **per-stream 面**（`open` / `publish` / `subscribe` / `close` / `abort`）：一轮一条流，
+ *   带 seq 分配与中断信号。
+ * - **会话面**（`subscribeSession`）：按根会话聚合整棵树的事件，跨轮、跨子会话；前端走这个。
+ *
+ * 默认实现 `InProcessStreamBus` 只在单进程里成立（POST 落 A 实例、SSE 落 B 实例就收不到）；
+ * 多实例换 Redis 适配。
+ */
+export interface StreamBus {
+  /** 开一条流；返回该流的 seq 分配器。重复 open 同一 id 抛错。 */
+  open(streamId: string): { nextSeq: () => number };
+  /** 发布事件（seq 由调用方用 open 返回的分配器取）。流未 open / 已 close 时丢弃。 */
+  publish(event: AgentEvent): void;
+  /**
+   * 发布一条**不属于任何 run** 的会话级事件，直接进会话面。
+   * `event` 的 `seq` / `streamId` / `runId` 对本方法无意义（填 0 / 会话 id），消费方不得读。
+   */
+  publishSessionEvent(event: AgentEvent): void;
+  /**
+   * 订阅一条流。`fromSeq` 给出时先补发 seq >= fromSeq 的历史，再接活流；流已结束则补完即止。
+   * `signal` abort 时等待中的迭代立即结束并摘掉监听（否则 `.return()` 会卡在未 settle 的
+   * promise 上，订阅者变僵尸）。
+   */
+  subscribe(
+    streamId: string,
+    fromSeq?: number,
+    signal?: AbortSignal
+  ): AsyncIterable<AgentEvent>;
+  /** 按根会话树订阅。`fromId` 给出时从该游标之后补发；缺省从最旧保留项起。 */
+  subscribeSession(
+    rootSessionId: string,
+    fromId: string | undefined,
+    signal: AbortSignal
+  ): AsyncIterable<SessionStreamEntry>;
+  /**
+   * 这一轮 seq ≤ `uptoSeq` 的事件已完整落库，会话面可以让它们退役（刷新重建时由库里的行顶替）。
+   * 实现可以留宽限期再删，也可以是 no-op。
+   */
+  retireUpTo(runId: string, uptoSeq: number): void;
+  /** 标记流结束，唤醒所有订阅者收尾。buffer 保留一段时间供重连补发。 */
+  close(streamId: string): void;
+  /** 请求取消：触发该流的 AbortSignal。 */
+  abort(streamId: string): void;
+  /** 该流是否仍在生成中（未 close）。 */
+  isActive(streamId: string): boolean;
+  /** 取该流的 AbortSignal，喂给模型调用。 */
+  signalOf(streamId: string): AbortSignal | undefined;
+}

package/src/ports/vendor-file-cache.ts

@@ -0,0 +1,54 @@
+/**
+ * 厂商文件按「哪家、哪个账号、哪份字节」定位：同一份字节传到不同账号是不同的文件，
+ * 一个账号传上去的 file id 别的账号用不了。
+ */
+export interface VendorFileKey {
+  /** 厂商 slug（`ModelRef.vendor`）。 */
+  vendor: string;
+  /**
+   * 文件落在哪个账号上：中心模式是上传结果的 `credentialRef`（之后引用它要 pin 这把），
+   * 直连模式是 `DIRECT_ACCOUNT`。
+   */
+  account: string;
+  /** 上传字节的 sha256 hex。 */
+  contentHash: string;
+}
+
+export interface VendorFileRecord extends VendorFileKey {
+  fileId: string;
+  /** 来自哪张图（只做关联、排查用）。 */
+  src: string | null;
+  mediaType: string;
+  bytes: number;
+  /** 厂商侧到期时间；null = 永久。 */
+  expiresAt: Date | null;
+  lastUsedAt: Date;
+}
+
+/**
+ * 厂商 Files API 的上传缓存（agent-base 的 `llm_vendor_file` 表）。只是存储：
+ * 新鲜度判据（到期前留余量）、上传合流、失效重传都在 `VendorFiles` 里。
+ *
+ * 多实例共用一份时，宿主用自己的库实现（唯一约束 `(vendor, account, contentHash)`）；
+ * 进程内实现只保证单实例——两个实例同时首传同一张图会各传一份，后写的覆盖前写的，
+ * 前一份成为厂商侧的孤儿直到它自己到期，代价只是厂商配额里多一份副本。
+ */
+export interface VendorFileCache {
+  /** 这家厂商下，这些字节在**任一账号**上的记录（含已到期的，判据归调用方）。 */
+  find(
+    vendor: string,
+    contentHashes: readonly string[]
+  ): Promise<VendorFileRecord[]>;
+  /** 按 `(vendor, account, contentHash)` 插入或覆盖。 */
+  put(record: VendorFileRecord): Promise<void>;
+  /** 更新 `lastUsedAt`（调用方已节流）。记录不在就什么都不做。 */
+  touch(key: VendorFileKey, at: Date): Promise<void>;
+  /** 删掉这个账号下这些 file id 的记录（厂商说它们不存在了 / 已到期重传）。 */
+  forget(
+    vendor: string,
+    account: string,
+    fileIds: readonly string[]
+  ): Promise<void>;
+  /** 删掉 `expiresAt < now` 的记录，返回删了几条。 */
+  sweepExpired(now: Date): Promise<number>;
+}

package/src/schema/agent-event.ts

@@ -0,0 +1,69 @@
+/**
+ * 内层领域事件。搬自 agent-base `agent-core/events/agent-event.ts`（2026-11-11）。
+ *
+ * 刻意不用 AI SDK 的 UIMessageChunk：① 会把内核钉死在 SDK 版本的内部形状上；
+ * ② 子 Agent 的 runId / parentRunId / depth 在里面无处安放。
+ *
+ * 只列 runtime 自己产生的类型。宿主的**会话级**事件（自动标题、追问、确认面板……）
+ * 经 `StreamBus.publishSessionEvent` 发，类型名由宿主定——所以 `AgentEvent.type`
+ * 也接受任意字符串；runtime 只对下面这些分支。
+ */
+export const AGENT_EVENT_TYPES = [
+  'run-start',
+  'step-start',
+  'text-delta',
+  'text-end',
+  'reasoning-delta',
+  'tool-input-start',
+  'tool-input-delta',
+  /** 入参流式构建的进度（`{toolCallId, toolName, chars}`），节流后发出，只服务界面。 */
+  'tool-input-progress',
+  /** 入参的内容预览（白名单工具），只服务界面、不落库、不进模型。 */
+  'tool-input-preview',
+  'tool-call',
+  'tool-result',
+  'step-finish',
+  /**
+   * 这一步在响应中途断连、内核把已经播出去的半截产出作废并原地重发
+   * （`{afterSeq, textChars, reasoningChars, attempt, maxAttempts, message}`）。
+   * 账本那边这些事件已物理删除，本事件只服务界面。
+   */
+  'step-retract',
+  /** 一步的真实用量（`{usage, runUsage}`，后者是本轮累计）。只服务界面。 */
+  'step-usage',
+  'run-finish',
+  'error',
+  /** loop 从 inbox 取走 ≥1 条待处理项后发出，供前端失效待处理队列。 */
+  'inbox-drained',
+  /** 向用户提问的会话级事件（问题落库或状态变了），载荷是整行 `{question}`。 */
+  'agent-question',
+] as const;
+
+export type AgentEventType = (typeof AGENT_EVENT_TYPES)[number];
+
+export interface AgentEvent {
+  /** 每个 streamId 内单调递增，从 1 开始。断线补发的基础。 */
+  seq: number;
+  /** 根 turn 的 id。子 Agent 事件共享父的 streamId 与 seq 序列。 */
+  streamId: string;
+  /** 根会话 id（树级作用域键）。 */
+  rootSessionId: string;
+  /** 产生该事件的会话 id（根或子）。 */
+  sessionId: string;
+  /** 产生该事件的跑次（根或子）。 */
+  runId: string;
+  /** 输出归属哪一条 assistant 消息（恒等于 `runId`）；会话级事件没有。 */
+  messageId?: string;
+  parentRunId: string | null;
+  depth: number;
+  ts: number;
+  /** runtime 的类型见 `AGENT_EVENT_TYPES`；宿主的会话级事件用自己的名字。 */
+  type: AgentEventType | (string & {});
+  payload: unknown;
+}
+
+/** 每个 stream 一个自增计数器。 */
+export function createSeqCounter(): () => number {
+  let seq = 0;
+  return () => ++seq;
+}

package/src/schema/agent-run.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+/** 跑次（一次 agent 执行，根或子）的状态。 */
+export const AGENT_RUN_STATUSES = [
+  'running',
+  'completed',
+  'aborted',
+  'rejected',
+  'failed',
+] as const;
+export type AgentRunStatus = (typeof AGENT_RUN_STATUSES)[number];
+
+/** 一轮为什么停下。 */
+export const STOP_REASONS = [
+  'stop',
+  'max-steps',
+  'timeout',
+  'aborted',
+  'api-error',
+  'rejected-by-hook',
+  'blocked-by-hook',
+  'error',
+] as const;
+export type StopReason = (typeof STOP_REASONS)[number];
+
+/** 步级明细（随跑次一起存，不另开子表）。 */
+export const AgentRunStepEntrySchema = z.object({
+  index: z.number().int(),
+  text: z.string().optional(),
+  toolCalls: z
+    .array(
+      z.object({
+        toolCallId: z.string(),
+        toolName: z.string(),
+        input: z.unknown(),
+        output: z.unknown().optional(),
+        ok: z.boolean().optional(),
+        durationMs: z.number().optional(),
+      })
+    )
+    .default([]),
+  usage: z.record(z.string(), z.number()).optional(),
+});
+export type AgentRunStepEntry = z.infer<typeof AgentRunStepEntrySchema>;

package/src/schema/index.ts

@@ -0,0 +1,25 @@
+export {
+  AGENT_EVENT_TYPES,
+  type AgentEvent,
+  type AgentEventType,
+  createSeqCounter,
+} from './agent-event.js';
+export {
+  AGENT_RUN_STATUSES,
+  type AgentRunStatus,
+  type AgentRunStepEntry,
+  AgentRunStepEntrySchema,
+  STOP_REASONS,
+  type StopReason,
+} from './agent-run.js';
+export {
+  COMPACTION_CHECKPOINT_KIND,
+  LOOP_REMINDER_KIND,
+  type MessagePart,
+  MessagePartSchema,
+  type PartProviderMetadata,
+  PartProviderMetadataSchema,
+  TODO_REMINDER_KIND,
+  type ToolResultImage,
+  ToolResultImageSchema,
+} from './message-part.js';