@botbotgo/agent-harness 0.0.185 → 0.0.187

package/README.md

@@ -954,7 +954,7 @@ ACP transport notes:
 - `serveAcpStdio(runtime)` exposes newline-delimited JSON-RPC over stdio for local IDE, CLI, or subprocess clients.
 - `serveAcpHttp(runtime)` exposes JSON-RPC over HTTP plus SSE runtime events so remote operator surfaces can connect without importing the runtime in-process.
 - `serveA2aHttp(runtime)` exposes a minimal A2A-compatible HTTP JSON-RPC bridge plus agent card discovery, mapping `message/send`, `tasks/get`, and `tasks/cancel` onto the existing session/request runtime surface.
-- `serveAgUiHttp(runtime)` exposes a minimal AG-UI-compatible HTTP SSE bridge that projects `run + output.delta + final result` onto `RUN_STARTED`, `TEXT_MESSAGE_*`, and `RUN_FINISHED` events for UI clients.
+- `serveAgUiHttp(runtime)` exposes an AG-UI-compatible HTTP SSE bridge that projects runtime lifecycle, text output, upstream thinking, step progress, and tool calls onto `RUN_*`, `TEXT_MESSAGE_*`, `THINKING_TEXT_MESSAGE_*`, `STEP_*`, and `TOOL_CALL_*` events for UI clients.
 - `createRuntimeMcpServer(runtime)` and `serveRuntimeMcpOverStdio(runtime)` expose the persisted runtime control surface itself as MCP tools, including sessions, requests, approvals, artifacts, events, and package export helpers.
 - `listRequestEvents(...)` and `exportRequestPackage(...)` are the request-first inspection helpers.
 - `exportRequestPackage(...)` and `exportSessionPackage(...)` package stable runtime records, transcript, approvals, events, and artifacts for operator tooling without reaching into persistence internals.

package/README.zh.md

@@ -913,7 +913,7 @@ ACP transport 说明：
 - `serveAcpStdio(runtime)` 提供基于 stdio 的 newline-delimited JSON-RPC，适合本地 IDE、CLI 或子进程客户端。
 - `serveAcpHttp(runtime)` 提供基于 HTTP 的 JSON-RPC 与 SSE runtime events，适合远程 operator surface 或独立控制面接入。
 - `serveA2aHttp(runtime)` 提供最小可用的 A2A HTTP JSON-RPC bridge 与 agent card discovery，把 `message/send`、`tasks/get`、`tasks/cancel` 映射到现有 session/request runtime surface。
-- `serveAgUiHttp(runtime)` 提供最小可用的 AG-UI HTTP SSE bridge，把现有 `run + output.delta + final result` 投影成 `RUN_STARTED`、`TEXT_MESSAGE_*` 与 `RUN_FINISHED` 事件，便于 UI 客户端直接接入。
+- `serveAgUiHttp(runtime)` 提供 AG-UI HTTP SSE bridge，把 runtime 生命周期、文本输出、upstream thinking、step 进度与 tool call 投影成 `RUN_*`、`TEXT_MESSAGE_*`、`THINKING_TEXT_MESSAGE_*`、`STEP_*` 与 `TOOL_CALL_*` 事件，便于 UI 客户端直接接入。
 - `createRuntimeMcpServer(runtime)` 与 `serveRuntimeMcpOverStdio(runtime)` 会把持久化 runtime 控制面本身暴露成 MCP tools，包括 sessions、requests、approvals、artifacts、events 与 package export helpers。
 - `listRequestEvents(...)` 与 `exportRequestPackage(...)` 是 request-first 的检查 helper。
 - `exportRequestPackage(...)` 与 `exportSessionPackage(...)` 可把稳定 runtime 记录、transcript、approvals、events 和 artifacts 打包给 operator tooling，而不必直接访问 persistence 内部实现。

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.184";
+export declare const AGENT_HARNESS_VERSION = "0.0.186";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.184";
+export const AGENT_HARNESS_VERSION = "0.0.186";

package/dist/protocol/ag-ui/http.d.ts

@@ -20,6 +20,28 @@ export type AgUiEvent = (AgUiBaseEvent & {
     threadId: string;
     runId: string;
     input?: MessageContent;
+}) | (AgUiBaseEvent & {
+    type: "STEP_STARTED";
+    stepId: string;
+    title: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+}) | (AgUiBaseEvent & {
+    type: "STEP_FINISHED";
+    stepId: string;
+    title: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+    status: "completed" | "failed";
+}) | (AgUiBaseEvent & {
+    type: "THINKING_TEXT_MESSAGE_START";
+    messageId: string;
+    role: "assistant";
+}) | (AgUiBaseEvent & {
+    type: "THINKING_TEXT_MESSAGE_CONTENT";
+    messageId: string;
+    delta: string;
+}) | (AgUiBaseEvent & {
+    type: "THINKING_TEXT_MESSAGE_END";
+    messageId: string;
 }) | (AgUiBaseEvent & {
     type: "TEXT_MESSAGE_START";
     messageId: string;
@@ -31,6 +53,25 @@ export type AgUiEvent = (AgUiBaseEvent & {
 }) | (AgUiBaseEvent & {
     type: "TEXT_MESSAGE_END";
     messageId: string;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_START";
+    toolCallId: string;
+    toolName: string;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_ARGS";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_RESULT";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_END";
+    toolCallId: string;
+    toolName: string;
 }) | (AgUiBaseEvent & {
     type: "RUN_FINISHED";
     threadId: string;

package/dist/protocol/ag-ui/http.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { createPersistentId } from "../../utils/id.js";
+import { createUpstreamTimelineReducer } from "../../upstream-events.js";
 function normalizePath(value, fallback) {
     const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
     return source.startsWith("/") ? source : `/${source}`;
@@ -55,6 +56,63 @@ function toRunStarted(event, input) {
         input,
     };
 }
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readUpstreamEventName(event) {
+    return typeof asObject(event)?.event === "string" ? String(asObject(event)?.event) : "";
+}
+function readUpstreamToolName(event) {
+    return typeof asObject(event)?.name === "string" ? String(asObject(event)?.name) : "";
+}
+function readUpstreamRunType(event) {
+    return typeof asObject(event)?.run_type === "string" ? String(asObject(event)?.run_type) : "";
+}
+function isToolStartEvent(event) {
+    const eventName = readUpstreamEventName(event);
+    return eventName === "on_tool_start" || (eventName === "on_chain_start" && readUpstreamRunType(event) === "tool");
+}
+function isToolTerminalEvent(event) {
+    const eventName = readUpstreamEventName(event);
+    return eventName === "on_tool_end"
+        || eventName === "on_tool_error"
+        || ((eventName === "on_chain_end" || eventName === "on_chain_error") && readUpstreamRunType(event) === "tool");
+}
+function readToolArgs(event) {
+    const typed = asObject(event);
+    const data = asObject(typed?.data);
+    if (!data || !("input" in data)) {
+        return undefined;
+    }
+    return data.input;
+}
+function createToolCallState() {
+    const activeToolCallIds = new Map();
+    return {
+        start(toolName) {
+            const toolCallId = `tool-${createPersistentId()}`;
+            const activeIds = activeToolCallIds.get(toolName) ?? [];
+            activeIds.push(toolCallId);
+            activeToolCallIds.set(toolName, activeIds);
+            return toolCallId;
+        },
+        peek(toolName) {
+            const activeIds = activeToolCallIds.get(toolName);
+            return activeIds?.at(-1);
+        },
+        finish(toolName) {
+            const activeIds = activeToolCallIds.get(toolName);
+            if (!activeIds || activeIds.length === 0) {
+                return undefined;
+            }
+            const toolCallId = activeIds.pop();
+            if (!activeIds.length) {
+                activeToolCallIds.delete(toolName);
+            }
+            return toolCallId;
+        },
+    };
+}
 export async function serveAgUiOverHttp(runtime, options = {}) {
     const hostname = options.hostname?.trim() || "127.0.0.1";
     const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
@@ -74,7 +132,11 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
         let runId;
         let threadId;
         let messageId;
+        let thinkingMessageId;
         let textMessageStarted = false;
+        let thinkingMessageStarted = false;
+        const toolCalls = createToolCallState();
+        const upstreamReducer = createUpstreamTimelineReducer();
         const ensureTextStart = async () => {
             if (textMessageStarted) {
                 return;
@@ -88,6 +150,37 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                 role: "assistant",
             });
         };
+        const ensureThinkingTextStart = async () => {
+            if (thinkingMessageStarted) {
+                return;
+            }
+            thinkingMessageId = thinkingMessageId ?? `thinking-${createPersistentId()}`;
+            thinkingMessageStarted = true;
+            await writeSseEvent(response, {
+                type: "THINKING_TEXT_MESSAGE_START",
+                timestamp: createTimestamp(),
+                messageId: thinkingMessageId,
+                role: "assistant",
+            });
+        };
+        const closeOpenMessages = async () => {
+            if (thinkingMessageStarted) {
+                await writeSseEvent(response, {
+                    type: "THINKING_TEXT_MESSAGE_END",
+                    timestamp: createTimestamp(),
+                    messageId: thinkingMessageId,
+                });
+                thinkingMessageStarted = false;
+            }
+            if (textMessageStarted) {
+                await writeSseEvent(response, {
+                    type: "TEXT_MESSAGE_END",
+                    timestamp: createTimestamp(),
+                    messageId: messageId,
+                });
+                textMessageStarted = false;
+            }
+        };
         try {
             const body = await readRequestBody(request);
             const input = parseRunInput(JSON.parse(body));
@@ -120,6 +213,92 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                             });
                         }
                     },
+                    onUpstreamEvent: async (event) => {
+                        const eventName = readUpstreamEventName(event);
+                        const toolName = readUpstreamToolName(event);
+                        if (isToolStartEvent(event) && toolName) {
+                            const toolCallId = toolCalls.start(toolName);
+                            await writeSseEvent(response, {
+                                type: "TOOL_CALL_START",
+                                timestamp: createTimestamp(),
+                                toolCallId,
+                                toolName,
+                            });
+                            const args = readToolArgs(event);
+                            if (args !== undefined) {
+                                await writeSseEvent(response, {
+                                    type: "TOOL_CALL_ARGS",
+                                    timestamp: createTimestamp(),
+                                    toolCallId,
+                                    toolName,
+                                    args,
+                                });
+                            }
+                        }
+                        const projections = upstreamReducer.consume(event);
+                        for (const projection of projections) {
+                            if (projection.type === "thinking") {
+                                if (!projection.text) {
+                                    continue;
+                                }
+                                await ensureThinkingTextStart();
+                                await writeSseEvent(response, {
+                                    type: "THINKING_TEXT_MESSAGE_CONTENT",
+                                    timestamp: createTimestamp(),
+                                    messageId: thinkingMessageId,
+                                    delta: projection.text,
+                                });
+                                continue;
+                            }
+                            if (projection.type === "step") {
+                                if (projection.status === "started") {
+                                    await writeSseEvent(response, {
+                                        type: "STEP_STARTED",
+                                        timestamp: createTimestamp(),
+                                        stepId: projection.key,
+                                        title: projection.step,
+                                        category: projection.category,
+                                    });
+                                    continue;
+                                }
+                                await writeSseEvent(response, {
+                                    type: "STEP_FINISHED",
+                                    timestamp: createTimestamp(),
+                                    stepId: projection.key,
+                                    title: projection.step,
+                                    category: projection.category,
+                                    status: projection.status,
+                                });
+                                continue;
+                            }
+                            const toolCallId = toolCalls.peek(projection.toolName) ?? toolCalls.start(projection.toolName);
+                            await writeSseEvent(response, {
+                                type: "TOOL_CALL_RESULT",
+                                timestamp: createTimestamp(),
+                                toolCallId,
+                                toolName: projection.toolName,
+                                result: projection.output,
+                                ...(projection.isError !== undefined ? { isError: projection.isError } : {}),
+                            });
+                        }
+                        if (isToolTerminalEvent(event) && toolName) {
+                            const toolCallId = toolCalls.finish(toolName) ?? `tool-${createPersistentId()}`;
+                            await writeSseEvent(response, {
+                                type: "TOOL_CALL_END",
+                                timestamp: createTimestamp(),
+                                toolCallId,
+                                toolName,
+                            });
+                        }
+                        if (eventName === "on_chat_model_end" && thinkingMessageStarted) {
+                            await writeSseEvent(response, {
+                                type: "THINKING_TEXT_MESSAGE_END",
+                                timestamp: createTimestamp(),
+                                messageId: thinkingMessageId,
+                            });
+                            thinkingMessageStarted = false;
+                        }
+                    },
                 },
             });
             runId = runId ?? result.runId;
@@ -133,13 +312,7 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                     delta: result.output,
                 });
             }
-            if (textMessageStarted) {
-                await writeSseEvent(response, {
-                    type: "TEXT_MESSAGE_END",
-                    timestamp: createTimestamp(),
-                    messageId: messageId,
-                });
-            }
+            await closeOpenMessages();
             await writeSseEvent(response, {
                 type: "RUN_FINISHED",
                 timestamp: createTimestamp(),
@@ -151,6 +324,7 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
             });
         }
         catch (error) {
+            await closeOpenMessages();
             await writeSseEvent(response, {
                 type: "RUN_ERROR",
                 timestamp: createTimestamp(),

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.185",
+  "version": "0.0.187",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",