@botbotgo/agent-harness 0.0.184 → 0.0.186

package/README.md

@@ -47,6 +47,17 @@
 - **Extend:** drop `tool({...})` modules and SKILL trees under `resources/`, wire shared tools and MCP in catalogs, and let agents whitelist what they use.
 - **Built into the runtime:** persisted `requests`, `sessions`, `approvals`, and `events`; recovery and queueing; streaming listeners; MCP in/out; LangChain v1 and DeepAgents adapters—so you do not rebuild that layer per app.
 
+## Current Public Surface
+
+The repository now ships more than a thin runtime bootstrap. The public surface is already broad enough that the homepage and docs need to describe it as a product runtime with external protocol boundaries, not only as YAML plus tools.
+
+- **Core runtime API:** `createAgentHarness`, `request`, `subscribe`, `resolveApproval`, inspection helpers, and stable persisted runtime records for `requests`, `sessions`, `approvals`, `events`, and artifacts.
+- **Runtime memory and evidence:** `memorize`, `recall`, `listMemories`, memory policy hooks, `listArtifacts`, `getArtifact`, `exportEvaluationBundle`, `replayEvaluationBundle`, and request/session evidence export helpers.
+- **Protocol and transport surfaces:** `createAcpServer`, `serveAcpStdio`, `serveAcpHttp`, `serveA2aHttp`, `serveAgUiHttp`, and `createRuntimeMcpServer` / `serveRuntimeMcpOverStdio`.
+- **Governed workspace runtime:** YAML-owned routing, concurrency, maintenance, MCP policy, runtime governance bundles, and approval defaults for sensitive memory or write-like MCP side effects.
+
+`deepagents-acp` is part of the current public story, not only a direction hidden in planning notes: `agent-harness` is moving toward a standard runtime boundary that external clients can talk to directly while the harness keeps persistence, recovery, approvals, and operator control runtime-owned.
+
 ## What Problem We Solve
 
 In one line: `agent-harness` productizes the runtime work that usually appears after the demo.
@@ -127,13 +138,13 @@ The runtime provides:
 - YAML-defined workspace assembly for routing, models, tools, stores, backends, MCP, recovery, and maintenance
 - backend-adapted execution with current LangChain v1 and DeepAgents adapters
 - local `resources/tools/` `tool({...})` modules and `resources/skills/` discovery
-- persisted threads, runs, approvals, events, queue state, and recovery metadata
+- persisted sessions, requests, approvals, events, queue state, and recovery metadata
 
 In practice, the harness exists for the parts that are expensive and repetitive to rebuild inside every agent app:
 
 - approval inboxes and human decision flow
-- persisted runs, threads, and inspectable event history
-- run correlation, continuity, and recovery inspection that still works after a stream fallback or restart
+- persisted requests, sessions, and inspectable event history
+- request correlation, continuity, and recovery inspection that still works after a stream fallback or restart
 - runtime-managed recovery after interrupts, failures, or process restart
 - queueing, concurrency, maintenance, and operational policy
 - stable runtime records that stay usable even if the backend changes
@@ -189,17 +200,17 @@ Most agent tooling stops at execution. Production software does not.
 
 Real products need a runtime that can answer harder questions:
 
-- Where do runs live?
+- Where do requests live?
 - How are approvals resolved?
 - What survives process restart?
-- How do you inspect threads and events without exposing raw backend state?
+- How do you inspect sessions and events without exposing raw backend state?
 - How do you swap backend implementations without rewriting the product model?
 
 `agent-harness` is the layer that answers those questions without turning your application API into a mirror of LangChain v1 or DeepAgents.
 
 ## What Makes It Different
 
-- It treats `runs`, `threads`, `approvals`, `events`, and recovery as first-class product records
+- It treats `requests`, `sessions`, `approvals`, `events`, and recovery as first-class product records
 - It gives operators a runtime control surface instead of exposing raw backend internals
 - It keeps observability and governance runtime-owned with trace correlation, continuity metadata, and approval defaults for sensitive side effects
 - It keeps checkpoint resume system-managed instead of promoting checkpoint internals into the primary API
@@ -211,7 +222,7 @@ Real products need a runtime that can answer harder questions:
 Use `agent-harness` when:
 
 - you already know your product needs agents, tools, prompts, or MCP access, but the missing layer is runtime operations
-- you need approvals, restart recovery, queueing, or inspectable run records as part of the shipped product
+- you need approvals, restart recovery, queueing, or inspectable request records as part of the shipped product
 - you want one workspace-shaped assembly model instead of hand-written runtime bootstrapping in every app
 - you want to keep backend execution semantics upstream while holding the product contract stable
 
@@ -300,9 +311,9 @@ If you want the shortest possible mental model:
 - LangChain v1 and DeepAgents backend adaptation
 - Auto-discovered local `tool({...})` tools and SKILL packages
 - provider-native tools, MCP tools, and workspace-local tool modules
-- persisted threads, runs, approvals, lifecycle events, and queued runs
+- persisted sessions, requests, approvals, lifecycle events, and queued requests
 - runtime-managed recovery and checkpoint maintenance
-- structured output and multimodal content preservation in run results
+- structured output and multimodal content preservation in request results
 - MCP bridge support for agent-declared MCP servers
 - MCP server support for exposing harness tools outward
 - optional `mem0` semantic recall augmentation over canonical SQLite durable memory
@@ -658,7 +669,7 @@ Important fields:
 `maintenance.checkpoints` and `maintenance.records` are separate retention layers:
 
 - `maintenance.checkpoints` trims backend checkpoint state used for resume/recovery
-- `maintenance.records` trims harness-owned terminal thread/run records stored in `runtime.sqlite`
+- `maintenance.records` trims harness-owned terminal session/request records stored in `runtime.sqlite`
 
 Example:
 
@@ -845,7 +856,7 @@ spec:
     systemPrompt: Answer simple requests directly.
 ```
 
-When `config.filesystem.sessionStorage.enabled: true` is set for a LangChain binding, the runtime keeps one filesystem root per persisted session/thread and reuses the same runnable cache entry for repeated work on that session instead of collapsing every run onto one shared workspace directory.
+When `config.filesystem.sessionStorage.enabled: true` is set for a LangChain binding, the runtime keeps one filesystem root per persisted session and reuses the same runnable cache entry for repeated work on that session instead of collapsing every request onto one shared workspace directory.
 
 Example orchestra host:
 

package/README.zh.md

@@ -47,6 +47,17 @@
 - **扩展：** 在 `resources/` 下放置 `tool({...})` 模块与 SKILL 目录，在目录里声明共享工具与 MCP，再由各 agent 按名字白名单启用。
 - **内建运行时：** 持久化 `requests`、`sessions`、`approvals` 与 `events`；恢复与排队；流式监听；MCP 接入与对外暴露；LangChain v1 与 DeepAgents 适配——避免每个应用重复造这一层。
 
+## 当前公开能力面
+
+这个仓库现在公开交付的已经不只是一个很薄的 runtime bootstrap。对外能力已经足够大，首页和文档也应该把它描述成一个带外部协议边界的产品级 runtime，而不只是 “YAML + tools”。
+
+- **核心 runtime API：** `createAgentHarness`、`request`、`subscribe`、`resolveApproval`、各类 inspection helper，以及稳定持久化的 `requests`、`sessions`、`approvals`、`events` 和 artifacts 记录。
+- **运行时 memory 与证据能力：** `memorize`、`recall`、`listMemories`、memory policy hooks、`listArtifacts`、`getArtifact`、`exportEvaluationBundle`、`replayEvaluationBundle`，以及 request / session 级证据导出 helper。
+- **协议与传输接面：** `createAcpServer`、`serveAcpStdio`、`serveAcpHttp`、`serveA2aHttp`、`serveAgUiHttp`、以及 `createRuntimeMcpServer` / `serveRuntimeMcpOverStdio`。
+- **受治理的工作区运行时：** 由 YAML 持有的路由、并发、维护、MCP 策略、runtime governance bundles，以及针对敏感 memory 或写类 MCP 副作用的默认审批门槛。
+
+`deepagents-acp` 已不应该只藏在规划文档里。它已经是当前公开产品叙事的一部分：`agent-harness` 正在朝一个可被外部客户端直接接入的标准 runtime boundary 演进，同时继续把持久化、恢复、审批和 operator control 保持为 harness 自有职责。
+
 ## 我们解决什么问题
 
 一句话概括：`agent-harness` 把通常在 demo 之后才暴露出来的运行时工作，提前做成产品 runtime 的一部分。
@@ -127,13 +138,13 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正更
 - 以 YAML 描述的工作区装配：路由、模型、工具、存储、后端、MCP、恢复与维护等
 - 通过适配器对接当前的 LangChain v1 与 DeepAgents 执行
 - 本地 `resources/tools/` 中 `tool({...})` 工具模块与 `resources/skills/` 的发现
-- 持久化的线程、运行、审批、事件、队列状态与恢复元数据
+- 持久化的会话、请求、审批、事件、队列状态与恢复元数据
 
 落到实际系统里，harness 主要解决那些每个 agent 应用都不应该重复造一遍的运行时难题：
 
 - 审批收件箱与人工决策流
-- 持久化的 runs、threads 与可查询事件历史
-- 即使发生 stream fallback 或进程重启也还能成立的 run 关联、连续性与恢复观测
+- 持久化的 requests、sessions 与可查询事件历史
+- 即使发生 stream fallback 或进程重启也还能成立的 request 关联、连续性与恢复观测
 - 中断、失败或进程重启后的运行时托管恢复
 - 队列、并发、维护与运维策略
 - 即使后端变更也保持稳定的运行时记录模型
@@ -186,17 +197,17 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正更
 
 真实产品需要能回答更难问题的运行时：
 
-- 运行（runs）存在哪里？
+- 请求（requests）存在哪里？
 - 审批如何闭环？
 - 进程重启后什么还在？
-- 如何在不暴露原始后端状态的前提下检查线程与事件？
+- 如何在不暴露原始后端状态的前提下检查会话与事件？
 - 如何在不大改产品模型的前提下替换后端实现？
 
 `agent-harness` 在不把应用 API 做成 LangChain v1 / DeepAgents 翻版的前提下，回答这些问题。
 
 ## 有何不同
 
-- 将 `runs`、`threads`、`approvals`、`events` 与恢复视为一等产品记录
+- 将 `requests`、`sessions`、`approvals`、`events` 与恢复视为一等产品记录
 - 给运维侧提供运行时控制面，而不是暴露原始后端内部结构
 - 将可观测性与治理留在运行时：包括 trace correlation、continuity metadata，以及高风险副作用的默认审批
 - 将 checkpoint 恢复作为系统管理的行为，而不是把 checkpoint 细节抬成主 API
@@ -208,7 +219,7 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正更
 下面这些场景适合用 `agent-harness`：
 
 - 你已经确定产品需要 agents、tools、prompts 或 MCP，但真正缺的是运行时运维层
-- 你需要把审批、重启恢复、排队调度或可查询运行记录一起作为产品能力交付出去
+- 你需要把审批、重启恢复、排队调度或可查询请求记录一起作为产品能力交付出去
 - 你希望用一个 workspace 形态的装配模型取代每个应用各写一套启动和运行时胶水
 - 你想把 backend 的执行语义留在上游，同时把产品契约稳定下来
 
@@ -297,7 +308,7 @@ try {
 - LangChain v1 与 DeepAgents 后端适配
 - 自动发现本地工具与 SKILL 包
 - 原生 provider 工具、MCP 工具与工作区本地工具模块
-- 持久化线程、运行、审批、生命周期事件与排队运行
+- 持久化会话、请求、审批、生命周期事件与排队请求
 - 运行时管理的恢复与 checkpoint 维护
 - 运行结果中的结构化输出与多模态内容保留
 - 将 agent 声明的 MCP 服务桥接进来
@@ -618,7 +629,7 @@ await stop(runtime);
 `maintenance.checkpoints` 与 `maintenance.records` 是两层独立的保留策略：
 
 - `maintenance.checkpoints` 清理后端用于 resume/recovery 的 checkpoint 状态
-- `maintenance.records` 清理 harness 自己保存在 `runtime.sqlite` 中、已结束的 thread/run 记录
+- `maintenance.records` 清理 harness 自己保存在 `runtime.sqlite` 中、已结束的 session/request 记录
 
 示例：
 
@@ -804,7 +815,7 @@ spec:
     systemPrompt: Answer simple requests directly.
 ```
 
-当 LangChain 绑定启用 `config.filesystem.sessionStorage.enabled: true` 时，runtime 会为每个持久化 session/thread 维护独立的 filesystem 根目录，并按 session 复用 runnable cache，而不是把所有运行都压到同一个共享工作目录里。
+当 LangChain 绑定启用 `config.filesystem.sessionStorage.enabled: true` 时，runtime 会为每个持久化 session 维护独立的 filesystem 根目录，并按 session 复用 runnable cache，而不是把所有请求都压到同一个共享工作目录里。
 
 orchestra 主机示例：
 

package/dist/api.d.ts

@@ -77,21 +77,22 @@ type PublicApprovalFilter = {
     sessionId?: string;
     requestId?: string;
 };
-type PublicRunStartOptions = Omit<RunStartOptions, "threadId" | "listeners"> & {
+type PublicRequestStartOptions = Omit<RunStartOptions, "threadId" | "listeners"> & {
     sessionId?: string;
     listeners?: PublicRunListeners;
 };
-type PublicRunDecisionOptions = Omit<RunDecisionOptions, "threadId" | "runId" | "listeners"> & {
+type PublicRequestDecisionOptions = Omit<RunDecisionOptions, "threadId" | "runId" | "listeners"> & {
     sessionId: string;
     requestId?: string;
     listeners?: PublicRunListeners;
 };
-type PublicRunOptions = PublicRunStartOptions | PublicRunDecisionOptions;
-type PublicRunResult = Omit<RunResult, "threadId" | "runId"> & {
+type PublicRequestOptions = PublicRequestStartOptions | PublicRequestDecisionOptions;
+type PublicRequestResult = Omit<RunResult, "threadId" | "runId"> & {
     sessionId: string;
     requestId: string;
 };
-export type RequestResult = PublicRunResult;
+type PublicRunResult = PublicRequestResult;
+export type RequestResult = PublicRequestResult;
 export type UserChatMessage = {
     role: "user";
     content: MessageContent;
@@ -111,14 +112,14 @@ type CreateAgentHarnessOptions = {
 export declare function createAgentHarness(): Promise<AgentHarnessRuntime>;
 export declare function createAgentHarness(workspaceRoot: string, options?: CreateAgentHarnessOptions): Promise<AgentHarnessRuntime>;
 export declare function normalizeUserChatInput(input: UserChatInput, options?: NormalizeUserChatInputOptions): Pick<RunStartOptions, "input" | "invocation">;
-export declare function request(runtime: AgentHarnessRuntime, options: PublicRunOptions): Promise<PublicRunResult>;
+export declare function request(runtime: AgentHarnessRuntime, options: PublicRequestOptions): Promise<PublicRequestResult>;
 export declare function memorize(runtime: AgentHarnessRuntime, input: MemorizeInput): Promise<MemorizeResult>;
 export declare function recall(runtime: AgentHarnessRuntime, input: RecallInput): Promise<RecallResult>;
 export declare function listMemories(runtime: AgentHarnessRuntime, input?: ListMemoriesInput): Promise<ListMemoriesResult>;
 export declare function updateMemory(runtime: AgentHarnessRuntime, input: UpdateMemoryInput): Promise<MemoryRecord>;
 export declare function removeMemory(runtime: AgentHarnessRuntime, input: RemoveMemoryInput): Promise<MemoryRecord>;
 export declare function subscribe(runtime: AgentHarnessRuntime, listener: (event: RequestEvent) => void | Promise<void>): () => void;
-export declare function listSessions(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listThreads"]>[0]): Promise<SessionSummary[]>;
+export declare function listSessions(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listSessions"]>[0]): Promise<SessionSummary[]>;
 export declare function listRequests(runtime: AgentHarnessRuntime, filter?: {
     agentId?: string;
     sessionId?: string;

package/dist/api.js

@@ -9,54 +9,6 @@ export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
 export { buildFlowGraph, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid } from "./flow/index.js";
 export { createUpstreamTimelineReducer } from "./upstream-events.js";
-function toSessionSummary(summary) {
-    return {
-        agentId: summary.agentId,
-        sessionId: summary.threadId,
-        latestRequestId: summary.latestRunId,
-        createdAt: summary.createdAt,
-        updatedAt: summary.updatedAt,
-        status: summary.status,
-        currentAgentId: summary.currentAgentId,
-    };
-}
-function toRequestSummary(summary) {
-    return {
-        requestId: summary.runId,
-        sessionId: summary.threadId,
-        agentId: summary.agentId,
-        executionMode: summary.executionMode,
-        adapterKind: summary.adapterKind,
-        createdAt: summary.createdAt,
-        updatedAt: summary.updatedAt,
-        state: summary.state,
-        checkpointRef: summary.checkpointRef,
-        resumable: summary.resumable,
-        startedAt: summary.startedAt,
-        endedAt: summary.endedAt,
-        lastActivityAt: summary.lastActivityAt,
-        currentAgentId: summary.currentAgentId,
-        delegationChain: summary.delegationChain,
-        runtimeSnapshot: summary.runtimeSnapshot,
-    };
-}
-function toSessionRecord(record) {
-    return {
-        sessionId: record.threadId,
-        entryAgentId: record.entryAgentId,
-        currentAgentId: record.currentAgentId,
-        currentState: record.currentState,
-        latestRequestId: record.latestRunId,
-        createdAt: record.createdAt,
-        updatedAt: record.updatedAt,
-        messages: record.messages,
-        requests: record.runs.map(toRequestSummary),
-        pendingDecision: record.pendingDecision,
-    };
-}
-function toRequestRecord(record) {
-    return toRequestSummary(record);
-}
 function toApprovalRecord(record) {
     return {
         approvalId: record.approvalId,
@@ -218,25 +170,19 @@ export function subscribe(runtime, listener) {
     });
 }
 export async function listSessions(runtime, filter) {
-    return (await runtime.listThreads(filter)).map(toSessionSummary);
+    return runtime.listSessions(filter);
 }
 export async function listRequests(runtime, filter) {
-    return (await runtime.listRuns({
-        agentId: filter?.agentId,
-        state: filter?.state,
-        threadId: filter?.sessionId,
-    })).map(toRequestSummary);
+    return runtime.listRequests(filter);
 }
 export async function getSession(runtime, sessionId) {
-    const record = await runtime.getThread(sessionId);
-    return record ? toSessionRecord(record) : null;
+    return runtime.getSessionRecord(sessionId);
 }
 export async function getRequest(runtime, requestId) {
-    const record = await runtime.getRun(requestId);
-    return record ? toRequestRecord(record) : null;
+    return runtime.getRequest(requestId);
 }
 export async function deleteSession(runtime, sessionId) {
-    return runtime.deleteThread(sessionId);
+    return runtime.deleteSession(sessionId);
 }
 export async function listApprovals(runtime, filter) {
     return (await runtime.listApprovals({
@@ -256,13 +202,13 @@ export async function getArtifact(runtime, input) {
     return runtime.readArtifact(input.sessionId, input.requestId, input.artifactPath);
 }
 export async function listRequestEvents(runtime, input) {
-    return (await runtime.listRunEvents(input.sessionId, input.requestId)).map(toPublicEvent);
+    return (await runtime.listRequestEvents(input.sessionId, input.requestId)).map(toPublicEvent);
 }
 export async function getHealth(runtime) {
     return runtime.getHealth();
 }
 export async function exportRequestPackage(runtime, input) {
-    return toRequestPackage(await runtime.exportRunPackage(input));
+    return toRequestPackage(await runtime.exportRequestPackage(input));
 }
 export async function exportSessionPackage(runtime, input) {
     return runtime.exportSessionPackage(input);

package/dist/contracts/runtime.d.ts

@@ -1,22 +1,24 @@
 import type { RunState } from "./core.js";
 import type { CompiledAgentBinding, CompiledModel, CompiledTool, ParsedAgentObject, ParsedToolObject, WorkspaceBundle } from "./workspace.js";
 /**
- * Persisted runtime summary for an inspectable conversation thread.
- * This projects upstream session/thread execution state into a stable runtime
- * inspection surface.
+ * Persisted runtime summary for an inspectable conversation session.
+ * This is the canonical runtime-facing conversation record.
  */
-export type ThreadSummary = {
+export type SessionSummary = {
     agentId: string;
-    threadId: string;
-    latestRunId: string;
+    sessionId: string;
+    latestRequestId: string;
     createdAt: string;
     updatedAt: string;
     status: RunState;
     currentAgentId?: string;
 };
-export type SessionSummary = Omit<ThreadSummary, "threadId" | "latestRunId"> & {
-    sessionId: string;
-    latestRequestId: string;
+/**
+ * Backward-compatible alias for older thread/run terminology.
+ */
+export type ThreadSummary = Omit<SessionSummary, "sessionId" | "latestRequestId"> & {
+    threadId: string;
+    latestRunId: string;
 };
 export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
 export type HarnessEventType = KnownHarnessEventType | (string & {});
@@ -192,6 +194,8 @@ export type MemorizeInputRecord = {
 };
 export type MemorizeInput = {
     records: MemorizeInputRecord[];
+    sessionId?: string;
+    requestId?: string;
     threadId?: string;
     runId?: string;
     agentId?: string;
@@ -209,6 +213,7 @@ export type RecallInput = {
     kinds?: MemoryKind[];
     topK?: number;
     includeStale?: boolean;
+    sessionId?: string;
     threadId?: string;
     agentId?: string;
     workspaceId?: string;
@@ -222,6 +227,7 @@ export type ListMemoriesInput = {
     scopes?: MemoryScope[];
     kinds?: MemoryKind[];
     status?: MemoryRecordStatus[];
+    sessionId?: string;
     threadId?: string;
     agentId?: string;
     workspaceId?: string;
@@ -418,29 +424,36 @@ export type ThreadRunRecord = {
     runtimeSnapshot?: RuntimeSnapshot;
 };
 /**
- * Persisted run summary projected from upstream execution state plus runtime lifecycle metadata.
+ * Persisted request summary projected from upstream execution state plus runtime lifecycle metadata.
+ * This is the canonical runtime-facing execution record.
  */
-export type RunSummary = ThreadRunRecord;
-export type RunRecord = RunSummary;
-export type RequestSummary = Omit<RunSummary, "threadId" | "runId"> & {
+export type RequestSummary = Omit<ThreadRunRecord, "threadId" | "runId"> & {
     sessionId: string;
     requestId: string;
 };
 export type RequestRecord = RequestSummary;
 /**
- * Persisted thread inspection record assembled from runtime records.
- * This is an inspectable projection, not a second thread semantic model.
+ * Backward-compatible alias for older thread/run terminology.
  */
-export type ThreadRecord = {
+export type RunSummary = Omit<RequestSummary, "sessionId" | "requestId"> & {
     threadId: string;
+    runId: string;
+};
+export type RunRecord = RunSummary;
+/**
+ * Persisted session inspection record assembled from runtime records.
+ * This is an inspectable projection, not a second session semantic model.
+ */
+export type SessionRecord = {
+    sessionId: string;
     entryAgentId: string;
     currentAgentId?: string;
     currentState: RunState;
-    latestRunId: string;
+    latestRequestId: string;
     createdAt: string;
     updatedAt: string;
     messages: TranscriptMessage[];
-    runs: ThreadRunRecord[];
+    requests: RequestSummary[];
     pendingDecision?: {
         approvalId: string;
         pendingActionId: string;
@@ -449,10 +462,13 @@ export type ThreadRecord = {
         requestedAt: string;
     };
 };
-export type SessionRecord = Omit<ThreadRecord, "threadId" | "latestRunId" | "runs"> & {
-    sessionId: string;
-    latestRequestId: string;
-    requests: RequestSummary[];
+/**
+ * Backward-compatible alias for older thread/run terminology.
+ */
+export type ThreadRecord = Omit<SessionRecord, "sessionId" | "latestRequestId" | "requests"> & {
+    threadId: string;
+    latestRunId: string;
+    runs: RunSummary[];
 };
 export type ResumeOptions = {
     threadId?: string;

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ApprovalRecord, ArtifactListing, CompiledTool, HarnessEvent, ParsedToolObject, RunResult, RunState, RunSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, ThreadRecord, ThreadSummary } from "./contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CompiledTool, HarnessEvent, ParsedToolObject, RequestRecord, RunResult, RunState, RequestSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, SessionRecord, SessionSummary } from "./contracts/types.js";
 export type ToolMcpServerOptions = {
     agentId: string;
     serverInfo?: {
@@ -20,16 +20,16 @@ export type RuntimeMcpServerOptions = {
     };
 };
 type RuntimeMcpRuntime = {
-    listThreads: (filter?: {
+    listSessions: (filter?: {
         agentId?: string;
-    }) => Promise<ThreadSummary[]>;
-    getThread: (threadId: string) => Promise<ThreadRecord | null>;
-    listRuns: (filter?: {
+    }) => Promise<SessionSummary[]>;
+    getSessionRecord: (sessionId: string) => Promise<SessionRecord | null>;
+    listRequests: (filter?: {
         agentId?: string;
-        threadId?: string;
+        sessionId?: string;
         state?: RunState;
-    }) => Promise<RunSummary[]>;
-    getRun: (runId: string) => Promise<RunSummary | null>;
+    }) => Promise<RequestSummary[]>;
+    getRequest: (requestId: string) => Promise<RequestRecord | null>;
     listApprovals: (filter?: {
         status?: ApprovalRecord["status"];
         threadId?: string;
@@ -43,10 +43,10 @@ type RuntimeMcpRuntime = {
         decision?: "approve" | "edit" | "reject";
         editedInput?: Record<string, unknown>;
     }) => Promise<RunResult>;
-    listArtifacts: (threadId: string, runId: string) => Promise<ArtifactListing>;
-    readArtifact: (threadId: string, runId: string, artifactPath: string) => Promise<unknown>;
-    listRunEvents: (sessionId: string, requestId: string) => Promise<HarnessEvent[]>;
-    exportRunPackage: (input: {
+    listArtifacts: (sessionId: string, requestId: string) => Promise<ArtifactListing>;
+    readArtifact: (sessionId: string, requestId: string, artifactPath: string) => Promise<unknown>;
+    listRequestEvents: (sessionId: string, requestId: string) => Promise<HarnessEvent[]>;
+    exportRequestPackage: (input: {
         sessionId: string;
         requestId: string;
         includeArtifacts?: boolean;

package/dist/mcp.js

@@ -120,7 +120,7 @@ export async function createRuntimeMcpServer(runtime, options = {}) {
     }, async (input) => ({
         content: [{
                 type: "text",
-                text: renderToolOutput(await runtime.listThreads(input.agentId ? { agentId: input.agentId } : undefined)),
+                text: renderToolOutput(await runtime.listSessions(input.agentId ? { agentId: input.agentId } : undefined)),
             }],
     }));
     server.tool("get_session", "Get one persisted runtime session by id.", {
@@ -128,7 +128,7 @@ export async function createRuntimeMcpServer(runtime, options = {}) {
     }, async (input) => ({
         content: [{
                 type: "text",
-                text: renderToolOutput(await runtime.getThread(input.sessionId)),
+                text: renderToolOutput(await runtime.getSessionRecord(input.sessionId)),
             }],
     }));
     server.tool("list_requests", "List persisted runtime requests.", {
@@ -138,9 +138,9 @@ export async function createRuntimeMcpServer(runtime, options = {}) {
     }, async (input) => ({
         content: [{
                 type: "text",
-                text: renderToolOutput(await runtime.listRuns({
+                text: renderToolOutput(await runtime.listRequests({
                     ...(input.agentId ? { agentId: input.agentId } : {}),
-                    ...(input.sessionId ? { threadId: input.sessionId } : {}),
+                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
                     ...(input.state ? { state: input.state } : {}),
                 })),
             }],
@@ -150,7 +150,7 @@ export async function createRuntimeMcpServer(runtime, options = {}) {
     }, async (input) => ({
         content: [{
                 type: "text",
-                text: renderToolOutput(await runtime.getRun(input.requestId)),
+                text: renderToolOutput(await runtime.getRequest(input.requestId)),
             }],
     }));
     server.tool("list_approvals", "List runtime approvals.", {
@@ -218,7 +218,7 @@ export async function createRuntimeMcpServer(runtime, options = {}) {
     }, async (input) => ({
         content: [{
                 type: "text",
-                text: renderToolOutput(await runtime.listRunEvents(input.sessionId, input.requestId)),
+                text: renderToolOutput(await runtime.listRequestEvents(input.sessionId, input.requestId)),
             }],
     }));
     server.tool("export_request_package", "Export a stable runtime request package for one request.", {
@@ -230,7 +230,7 @@ export async function createRuntimeMcpServer(runtime, options = {}) {
     }, async (input) => ({
         content: [{
                 type: "text",
-                text: renderToolOutput(await runtime.exportRunPackage(input)),
+                text: renderToolOutput(await runtime.exportRequestPackage(input)),
             }],
     }));
     server.tool("export_session_package", "Export a stable runtime session package.", {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.183";
+export declare const AGENT_HARNESS_VERSION = "0.0.185";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.183";
+export const AGENT_HARNESS_VERSION = "0.0.185";

package/dist/runtime/harness/run/thread-records.d.ts

@@ -1,5 +1,9 @@
-import type { ApprovalRecord, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
+import type { ApprovalRecord, SessionRecord, SessionSummary, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
+export declare function buildSessionInspectionRecord(input: {
+    persistence: RuntimePersistence;
+    getSession: (sessionId: string) => Promise<SessionSummary | null>;
+}, sessionId: string): Promise<SessionRecord | null>;
 export declare function buildThreadInspectionRecord(input: {
     persistence: RuntimePersistence;
     getSession: (threadId: string) => Promise<ThreadSummary | null>;
@@ -19,3 +23,8 @@ export declare function deleteThreadRecord(input: {
     deleteThread: (threadId: string) => Promise<boolean>;
     deleteThreadCheckpoints: (threadId: string) => Promise<void>;
 }, threadId: string): Promise<boolean>;
+export declare function deleteSessionRecord(input: {
+    getSession: (sessionId: string) => Promise<SessionRecord | null>;
+    deleteSession: (sessionId: string) => Promise<boolean>;
+    deleteSessionCheckpoints: (sessionId: string) => Promise<void>;
+}, sessionId: string): Promise<boolean>;

package/dist/runtime/harness/run/thread-records.js

@@ -4,29 +4,46 @@ function selectLatestPendingApproval(approvals) {
         .filter((approval) => approval.status === "pending")
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
 }
-export async function buildThreadInspectionRecord(input, threadId) {
-    const [threadSummary, meta, messages, runs] = await Promise.all([
-        input.getSession(threadId),
-        input.persistence.getThreadMeta(threadId),
-        input.persistence.listThreadMessages(threadId, 200),
-        input.persistence.listThreadRuns(threadId),
+export async function buildSessionInspectionRecord(input, sessionId) {
+    const [sessionSummary, meta, messages, requests] = await Promise.all([
+        input.getSession(sessionId),
+        input.persistence.getThreadMeta(sessionId),
+        input.persistence.listThreadMessages(sessionId, 200),
+        input.persistence.listThreadRuns(sessionId),
     ]);
-    if (!threadSummary || !meta) {
+    if (!sessionSummary || !meta) {
         return null;
     }
-    const latestRunId = threadSummary.latestRunId;
-    const latestApprovals = await input.persistence.getRunApprovals(threadId, latestRunId);
+    const latestRequestId = sessionSummary.latestRequestId;
+    const latestApprovals = await input.persistence.getRunApprovals(sessionId, latestRequestId);
     const pendingApproval = selectLatestPendingApproval(latestApprovals);
     return {
-        threadId,
+        sessionId,
         entryAgentId: meta.entryAgentId,
-        currentAgentId: threadSummary.currentAgentId,
-        currentState: threadSummary.status,
-        latestRunId,
+        currentAgentId: sessionSummary.currentAgentId,
+        currentState: sessionSummary.status,
+        latestRequestId,
         createdAt: meta.createdAt,
-        updatedAt: threadSummary.updatedAt,
+        updatedAt: sessionSummary.updatedAt,
         messages,
-        runs,
+        requests: requests.map((request) => ({
+            requestId: request.runId,
+            sessionId: request.threadId,
+            agentId: request.agentId,
+            executionMode: request.executionMode,
+            adapterKind: request.adapterKind,
+            createdAt: request.createdAt,
+            updatedAt: request.updatedAt,
+            state: request.state,
+            checkpointRef: request.checkpointRef,
+            resumable: request.resumable,
+            startedAt: request.startedAt,
+            endedAt: request.endedAt,
+            lastActivityAt: request.lastActivityAt,
+            currentAgentId: request.currentAgentId,
+            delegationChain: request.delegationChain,
+            runtimeSnapshot: request.runtimeSnapshot,
+        })),
         pendingDecision: pendingApproval
             ? {
                 approvalId: pendingApproval.approvalId,
@@ -38,6 +55,56 @@ export async function buildThreadInspectionRecord(input, threadId) {
             : undefined,
     };
 }
+export async function buildThreadInspectionRecord(input, threadId) {
+    const session = await buildSessionInspectionRecord({
+        persistence: input.persistence,
+        getSession: async (sessionId) => {
+            const summary = await input.getSession(sessionId);
+            return summary
+                ? {
+                    agentId: summary.agentId,
+                    sessionId: summary.threadId,
+                    latestRequestId: summary.latestRunId,
+                    createdAt: summary.createdAt,
+                    updatedAt: summary.updatedAt,
+                    status: summary.status,
+                    currentAgentId: summary.currentAgentId,
+                }
+                : null;
+        },
+    }, threadId);
+    return session
+        ? {
+            threadId: session.sessionId,
+            entryAgentId: session.entryAgentId,
+            currentAgentId: session.currentAgentId,
+            currentState: session.currentState,
+            latestRunId: session.latestRequestId,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            messages: session.messages,
+            runs: session.requests.map((request) => ({
+                runId: request.requestId,
+                threadId: request.sessionId,
+                agentId: request.agentId,
+                executionMode: request.executionMode,
+                adapterKind: request.adapterKind,
+                createdAt: request.createdAt,
+                updatedAt: request.updatedAt,
+                state: request.state,
+                checkpointRef: request.checkpointRef,
+                resumable: request.resumable,
+                startedAt: request.startedAt,
+                endedAt: request.endedAt,
+                lastActivityAt: request.lastActivityAt,
+                currentAgentId: request.currentAgentId,
+                delegationChain: request.delegationChain,
+                runtimeSnapshot: request.runtimeSnapshot,
+            })),
+            pendingDecision: session.pendingDecision,
+        }
+        : null;
+}
 export async function listPublicApprovals(input, filter) {
     const approvals = await input.persistence.listApprovals(filter);
     return approvals.map((approval) => toInspectableApprovalRecord(approval));
@@ -61,3 +128,18 @@ export async function deleteThreadRecord(input, threadId) {
     }
     return deleted;
 }
+export async function deleteSessionRecord(input, sessionId) {
+    const session = await input.getSession(sessionId);
+    if (!session) {
+        return false;
+    }
+    const activeRequest = session.requests.find((request) => !isTerminalRunState(request.state));
+    if (activeRequest) {
+        throw new Error(`Cannot delete session ${sessionId} while request ${activeRequest.requestId} is ${activeRequest.state}`);
+    }
+    const deleted = await input.deleteSession(sessionId);
+    if (deleted) {
+        await input.deleteSessionCheckpoints(sessionId);
+    }
+    return deleted;
+}

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRunPackage, RuntimeRunPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRunPackage, RuntimeRunPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, SessionSummary, ThreadSummary, ThreadRecord, SessionRecord, RequestRecord, RequestSummary, WorkspaceBundle } from "../contracts/types.js";
 import { type RuntimeMcpServerOptions, type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -60,9 +60,17 @@ export declare class AgentHarnessRuntime {
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
+    listSessions(filter?: {
+        agentId?: string;
+    }): Promise<SessionSummary[]>;
     listThreads(filter?: {
         agentId?: string;
     }): Promise<ThreadSummary[]>;
+    listRequests(filter?: {
+        agentId?: string;
+        sessionId?: string;
+        state?: RequestSummary["state"];
+    }): Promise<RequestSummary[]>;
     listRuns(filter?: {
         agentId?: string;
         threadId?: string;
@@ -73,8 +81,11 @@ export declare class AgentHarnessRuntime {
     listMemories(input?: ListMemoriesInput): Promise<ListMemoriesResult>;
     updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
     removeMemory(input: RemoveMemoryInput): Promise<MemoryRecord>;
+    getRequest(requestId: string): Promise<RequestRecord | null>;
     getRun(runId: string): Promise<RunRecord | null>;
+    private getSessionSummary;
     private getSession;
+    getSessionRecord(sessionId: string): Promise<SessionRecord | null>;
     getThread(threadId: string): Promise<ThreadRecord | null>;
     listApprovals(filter?: {
         status?: ApprovalRecord["status"];
@@ -84,7 +95,9 @@ export declare class AgentHarnessRuntime {
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
     listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
     readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
+    listRequestEvents(sessionId: string, requestId: string): Promise<HarnessEvent[]>;
     listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
+    exportRequestPackage(input: RuntimeRunPackageInput): Promise<RuntimeRunPackage>;
     exportRunPackage(input: RuntimeRunPackageInput): Promise<RuntimeRunPackage>;
     exportSessionPackage(input: RuntimeSessionPackageInput): Promise<RuntimeSessionPackage>;
     exportEvaluationBundle(input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
@@ -96,7 +109,9 @@ export declare class AgentHarnessRuntime {
         agents: InventoryAgentRecord[];
     };
     private deleteThreadCheckpoints;
+    deleteSession(sessionId: string): Promise<boolean>;
     deleteThread(threadId: string): Promise<boolean>;
+    deleteThreadLegacy(threadId: string): Promise<boolean>;
     createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     createRuntimeMcpServer(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;

package/dist/runtime/harness.js

@@ -38,7 +38,7 @@ import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
-import { buildThreadInspectionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
+import { buildSessionInspectionRecord, deleteSessionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -286,11 +286,79 @@ export class AgentHarnessRuntime {
         }
         return createDefaultHealthSnapshot(this.activeRunSlots, this.pendingRunSlots.length);
     }
+    async listSessions(filter) {
+        const sessions = await this.persistence.listSessions(filter);
+        return sessions.map((session) => ({
+            agentId: session.agentId,
+            sessionId: session.threadId,
+            latestRequestId: session.latestRunId,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            status: session.status,
+            currentAgentId: session.currentAgentId,
+        }));
+    }
     async listThreads(filter) {
-        return this.persistence.listSessions(filter);
+        const sessions = await this.listSessions(filter);
+        return sessions.map((session) => ({
+            agentId: session.agentId,
+            threadId: session.sessionId,
+            latestRunId: session.latestRequestId,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            status: session.status,
+            currentAgentId: session.currentAgentId,
+        }));
+    }
+    async listRequests(filter) {
+        const requests = await this.persistence.listRuns({
+            agentId: filter?.agentId,
+            threadId: filter?.sessionId,
+            state: filter?.state,
+        });
+        return requests.map((request) => ({
+            requestId: request.runId,
+            sessionId: request.threadId,
+            agentId: request.agentId,
+            executionMode: request.executionMode,
+            adapterKind: request.adapterKind,
+            createdAt: request.createdAt,
+            updatedAt: request.updatedAt,
+            state: request.state,
+            checkpointRef: request.checkpointRef,
+            resumable: request.resumable,
+            startedAt: request.startedAt,
+            endedAt: request.endedAt,
+            lastActivityAt: request.lastActivityAt,
+            currentAgentId: request.currentAgentId,
+            delegationChain: request.delegationChain,
+            runtimeSnapshot: request.runtimeSnapshot,
+        }));
     }
     async listRuns(filter) {
-        return this.persistence.listRuns(filter);
+        const requests = await this.listRequests({
+            agentId: filter?.agentId,
+            sessionId: filter?.threadId,
+            state: filter?.state,
+        });
+        return requests.map((request) => ({
+            runId: request.requestId,
+            threadId: request.sessionId,
+            agentId: request.agentId,
+            executionMode: request.executionMode,
+            adapterKind: request.adapterKind,
+            createdAt: request.createdAt,
+            updatedAt: request.updatedAt,
+            state: request.state,
+            checkpointRef: request.checkpointRef,
+            resumable: request.resumable,
+            startedAt: request.startedAt,
+            endedAt: request.endedAt,
+            lastActivityAt: request.lastActivityAt,
+            currentAgentId: request.currentAgentId,
+            delegationChain: request.delegationChain,
+            runtimeSnapshot: request.runtimeSnapshot,
+        }));
     }
     async memorize(input) {
         const binding = this.defaultRuntimeEntryBinding;
@@ -309,12 +377,14 @@ export class AgentHarnessRuntime {
         if (candidates.some((record) => typeof record.content !== "string" || record.content.trim().length === 0)) {
             throw new Error("memorize requires every record to include non-empty content.");
         }
-        if (candidates.some((record) => (record.scope ?? "thread") === "thread") && !input.threadId) {
-            throw new Error("memorize requires threadId when storing thread-scoped memory.");
+        const sessionId = input.sessionId ?? input.threadId;
+        const requestId = input.requestId ?? input.runId;
+        if (candidates.some((record) => (record.scope ?? "thread") === "thread") && !sessionId) {
+            throw new Error("memorize requires sessionId (or legacy threadId) when storing thread-scoped memory.");
         }
         const recordedAt = input.recordedAt ?? new Date().toISOString();
-        const runId = input.runId ?? createPersistentId(new Date(recordedAt));
-        const threadId = input.threadId ?? `memory-api-${runId}`;
+        const runId = requestId ?? createPersistentId(new Date(recordedAt));
+        const threadId = sessionId ?? `memory-api-${runId}`;
         return this.persistStructuredMemoryCandidates(binding, {
             candidates: candidates.map((record) => ({ ...record, content: record.content.trim() })),
             threadId,
@@ -334,6 +404,7 @@ export class AgentHarnessRuntime {
         if (typeof input.query !== "string" || input.query.trim().length === 0) {
             throw new Error("recall requires a non-empty query.");
         }
+        const sessionId = input.sessionId ?? input.threadId;
         const workspaceId = this.getWorkspaceId(binding);
         const agentId = input.agentId ?? binding.agent.id;
         const userId = input.userId ?? "default";
@@ -350,7 +421,7 @@ export class AgentHarnessRuntime {
             topK,
             includeStale: input.includeStale === true,
             filters: {
-                threadId: input.threadId,
+                threadId: sessionId,
                 agentId,
                 workspaceId: input.workspaceId ?? workspaceId,
                 userId,
@@ -366,6 +437,7 @@ export class AgentHarnessRuntime {
         if (!binding) {
             throw new Error("listMemories requires a runtime entry binding.");
         }
+        const sessionId = input.sessionId ?? input.threadId;
         const workspaceId = this.getWorkspaceId(binding);
         const scopes = Array.isArray(input.scopes) && input.scopes.length > 0
             ? Array.from(new Set(input.scopes))
@@ -379,7 +451,7 @@ export class AgentHarnessRuntime {
             .filter((record) => statuses.has(record.status))
             .filter((record) => !kinds || kinds.has(record.kind))
             .filter((record) => this.matchesMemoryFilters(record, {
-            threadId: input.threadId,
+            threadId: sessionId,
             agentId: input.agentId,
             workspaceId: input.workspaceId ?? workspaceId,
             userId: input.userId,
@@ -453,17 +525,119 @@ export class AgentHarnessRuntime {
         await this.refreshStructuredMemoryScope(binding, existing);
         return existing;
     }
+    async getRequest(requestId) {
+        const request = await this.persistence.getRun(requestId);
+        return request
+            ? {
+                requestId: request.runId,
+                sessionId: request.threadId,
+                agentId: request.agentId,
+                executionMode: request.executionMode,
+                adapterKind: request.adapterKind,
+                createdAt: request.createdAt,
+                updatedAt: request.updatedAt,
+                state: request.state,
+                checkpointRef: request.checkpointRef,
+                resumable: request.resumable,
+                startedAt: request.startedAt,
+                endedAt: request.endedAt,
+                lastActivityAt: request.lastActivityAt,
+                currentAgentId: request.currentAgentId,
+                delegationChain: request.delegationChain,
+                runtimeSnapshot: request.runtimeSnapshot,
+            }
+            : null;
+    }
     async getRun(runId) {
-        return this.persistence.getRun(runId);
+        const request = await this.getRequest(runId);
+        return request
+            ? {
+                runId: request.requestId,
+                threadId: request.sessionId,
+                agentId: request.agentId,
+                executionMode: request.executionMode,
+                adapterKind: request.adapterKind,
+                createdAt: request.createdAt,
+                updatedAt: request.updatedAt,
+                state: request.state,
+                checkpointRef: request.checkpointRef,
+                resumable: request.resumable,
+                startedAt: request.startedAt,
+                endedAt: request.endedAt,
+                lastActivityAt: request.lastActivityAt,
+                currentAgentId: request.currentAgentId,
+                delegationChain: request.delegationChain,
+                runtimeSnapshot: request.runtimeSnapshot,
+            }
+            : null;
+    }
+    async getSessionSummary(sessionId) {
+        const session = await this.persistence.getSession(sessionId);
+        return session
+            ? {
+                agentId: session.agentId,
+                sessionId: session.threadId,
+                latestRequestId: session.latestRunId,
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+                status: session.status,
+                currentAgentId: session.currentAgentId,
+            }
+            : null;
     }
     async getSession(threadId) {
-        return this.persistence.getSession(threadId);
+        const session = await this.getSessionSummary(threadId);
+        return session
+            ? {
+                agentId: session.agentId,
+                threadId: session.sessionId,
+                latestRunId: session.latestRequestId,
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+                status: session.status,
+                currentAgentId: session.currentAgentId,
+            }
+            : null;
     }
-    async getThread(threadId) {
-        return buildThreadInspectionRecord({
+    async getSessionRecord(sessionId) {
+        return buildSessionInspectionRecord({
             persistence: this.persistence,
-            getSession: (currentThreadId) => this.getSession(currentThreadId),
-        }, threadId);
+            getSession: (currentSessionId) => this.getSessionSummary(currentSessionId),
+        }, sessionId);
+    }
+    async getThread(threadId) {
+        const session = await this.getSessionRecord(threadId);
+        return session
+            ? {
+                threadId: session.sessionId,
+                entryAgentId: session.entryAgentId,
+                currentAgentId: session.currentAgentId,
+                currentState: session.currentState,
+                latestRunId: session.latestRequestId,
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+                messages: session.messages,
+                runs: session.requests.map((request) => ({
+                    runId: request.requestId,
+                    threadId: request.sessionId,
+                    agentId: request.agentId,
+                    executionMode: request.executionMode,
+                    adapterKind: request.adapterKind,
+                    createdAt: request.createdAt,
+                    updatedAt: request.updatedAt,
+                    state: request.state,
+                    checkpointRef: request.checkpointRef,
+                    resumable: request.resumable,
+                    startedAt: request.startedAt,
+                    endedAt: request.endedAt,
+                    lastActivityAt: request.lastActivityAt,
+                    currentAgentId: request.currentAgentId,
+                    delegationChain: request.delegationChain,
+                    runtimeSnapshot: request.runtimeSnapshot,
+                })),
+                pendingDecision: session.pendingDecision,
+            }
+            : null;
     }
     async listApprovals(filter) {
         return listPublicApprovals({
@@ -481,15 +655,18 @@ export class AgentHarnessRuntime {
     async readArtifact(threadId, runId, artifactPath) {
         return this.persistence.readArtifact(threadId, runId, artifactPath);
     }
+    async listRequestEvents(sessionId, requestId) {
+        return this.persistence.listRunEvents(sessionId, requestId);
+    }
     async listRunEvents(threadId, runId) {
-        return this.persistence.listRunEvents(threadId, runId);
+        return this.listRequestEvents(threadId, runId);
     }
-    async exportRunPackage(input) {
-        const thread = await this.getThread(input.sessionId);
-        const run = await this.getRun(input.requestId);
+    async exportRequestPackage(input) {
+        const session = await this.getSessionRecord(input.sessionId);
+        const request = await this.getRequest(input.requestId);
         const approvals = await this.listApprovals({ threadId: input.sessionId, runId: input.requestId });
         const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
-        const events = await this.persistence.listRunEvents(input.sessionId, input.requestId);
+        const events = await this.listRequestEvents(input.sessionId, input.requestId);
         const artifactsListing = input.includeArtifacts === false
             ? { items: [] }
             : await this.persistence.listArtifacts(input.sessionId, input.requestId);
@@ -500,8 +677,8 @@ export class AgentHarnessRuntime {
                 : {}),
         })));
         return {
-            session: thread ? toSessionRecord(thread) : null,
-            request: run ? toRequestRecord(run) : null,
+            session,
+            request,
             approvals,
             transcript,
             events,
@@ -509,10 +686,13 @@ export class AgentHarnessRuntime {
             ...(input.includeRuntimeHealth === false ? {} : { runtimeHealth: await this.getHealth() }),
         };
     }
+    async exportRunPackage(input) {
+        return this.exportRequestPackage(input);
+    }
     async exportSessionPackage(input) {
-        const thread = await this.getThread(input.sessionId);
-        const runIds = Array.from(new Set((thread?.runs ?? []).map((item) => item.runId)));
-        const runs = await Promise.all(runIds.map((requestId) => this.exportRunPackage({
+        const session = await this.getSessionRecord(input.sessionId);
+        const requestIds = Array.from(new Set((session?.requests ?? []).map((item) => item.requestId)));
+        const runs = await Promise.all(requestIds.map((requestId) => this.exportRequestPackage({
             sessionId: input.sessionId,
             requestId,
             includeArtifacts: input.includeArtifacts,
@@ -520,7 +700,7 @@ export class AgentHarnessRuntime {
             includeRuntimeHealth: false,
         })));
         return {
-            session: thread ? toSessionRecord(thread) : null,
+            session,
             requests: runs.map((item) => item.request).filter((item) => Boolean(item)),
             approvals: await this.listApprovals({ threadId: input.sessionId }),
             transcript: await this.persistence.listThreadMessages(input.sessionId, 500),
@@ -638,7 +818,17 @@ export class AgentHarnessRuntime {
             }
         }
     }
+    async deleteSession(sessionId) {
+        return deleteSessionRecord({
+            getSession: (currentSessionId) => this.getSessionRecord(currentSessionId),
+            deleteSession: (currentSessionId) => this.persistence.deleteThread(currentSessionId),
+            deleteSessionCheckpoints: (currentSessionId) => this.deleteThreadCheckpoints(currentSessionId),
+        }, sessionId);
+    }
     async deleteThread(threadId) {
+        return this.deleteSession(threadId);
+    }
+    async deleteThreadLegacy(threadId) {
         return deleteThreadRecord({
             getThread: (currentThreadId) => this.getThread(currentThreadId),
             deleteThread: (currentThreadId) => this.persistence.deleteThread(currentThreadId),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.184",
+  "version": "0.0.186",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",