@botbotgo/agent-harness 0.0.155 → 0.0.157

package/README.md

@@ -118,7 +118,7 @@ That means:
 
 The runtime provides:
 
-- `createAgentHarness(workspaceRoot)`, `run(...)`, `memorize(...)`, `recall(...)`, `resolveApproval(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
+- `createAgentHarness(workspaceRoot)`, `run(...)`, `memorize(...)`, `recall(...)`, `listMemories(...)`, `updateMemory(...)`, `removeMemory(...)`, `resolveApproval(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
 - 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
@@ -414,10 +414,13 @@ const recalled = await recall(runtime, {
 });
 ```
 
-Use `memorize(...)` and `recall(...)` when an application needs a stable public runtime memory surface without importing internal `runtime/harness/system/*` modules.
+Use `memorize(...)`, `recall(...)`, `listMemories(...)`, `updateMemory(...)`, and `removeMemory(...)` when an application needs a stable public runtime memory surface without importing internal `runtime/harness/system/*` modules.
 
 - `memorize(...)` returns stable `MemoryRecord` and `MemoryDecision` results while leaving merge, review, archive, and storage layout runtime-managed
 - `recall(...)` returns ranked `MemoryRecord` items filtered by runtime memory scope and kind
+- `listMemories(...)` returns stable `MemoryRecord` items for inspection and admin workflows, defaulting to `active` records unless status filters are provided
+- `updateMemory(...)` edits one durable memory record by `memoryId` without exposing internal store namespaces
+- `removeMemory(...)` deletes one durable memory record by `memoryId` and rebuilds runtime-managed projections
 - app-specific knowledge taxonomy, review UI, and admin surfaces still belong in the application layer
 
 ### Let The Runtime Route
@@ -467,6 +470,7 @@ The runtime event stream includes:
 
 ```ts
 import {
+  deleteSession,
   getSession,
   getApproval,
   listSessions,
@@ -485,6 +489,10 @@ if (approval) {
     decision: "approve",
   });
 }
+
+if (session && session.currentState === "completed") {
+  await deleteSession(runtime, session.sessionId);
+}
 ```
 
 These methods return runtime-facing records, not raw checkpoint or backend objects.
@@ -548,6 +556,13 @@ Core workspace files:
 - `resources/tools/`
 - `resources/skills/`
 
+Discovery rules:
+
+- every YAML document under `config/**` is discovered recursively; filenames and subfolders are organizational only
+- YAML object semantics come from `kind`, `metadata.name` or `id`, and object content rather than the file path
+- local tools are auto-discovered from `resources/tools/**/*.js|*.mjs|*.cjs` when they export `tool({...})`
+- skills are auto-discovered from `resources/skills/**/SKILL.md`
+
 Workspace-local tool modules in `resources/tools/` should be exported with `tool({...})`.
 Any other local module shape is not supported, and unsupported shapes are rejected at load time.
 
@@ -563,7 +578,7 @@ There are three main configuration layers:
 
 - runtime policy in `config/runtime/workspace.yaml`
 - reusable object catalogs in `config/catalogs/*.yaml`
-- agent assembly in `config/agents/*.yaml`
+- agent assembly in `config/**/*.yaml`
 
 ### Backend Guidance
 
@@ -633,7 +648,7 @@ Use this file for shared bootstrap memory loaded at agent construction time.
 
 Keep stable project context here. Treat it as startup context, not mutable long-term memory.
 
-### `config/catalogs/models.yaml`
+### Models Catalogs In `config/**`
 
 Use named chat-model presets:
 
@@ -649,7 +664,9 @@ spec:
 
 These load as `model/default`.
 
-### `config/catalogs/embedding-models.yaml`
+You can place `kind: Models` catalogs anywhere under `config/`; `config/catalogs/models.yaml` is only the recommended layout.
+
+### Embedding Model Catalogs In `config/**`
 
 Use named embedding-model presets for retrieval-oriented tools.
 
@@ -740,10 +757,12 @@ spec:
 
 `spec[].kind` can be omitted here; catalog entries default to `McpServer`.
 
-### `config/agents/*.yaml`
+### Agents In `config/**`
 
 Agents always use `kind: Agent` plus `spec.backend`.
 
+Agent YAML can live anywhere under `config/`; `config/agents/*.yaml` is the recommended layout, not a loader requirement.
+
 Use two sections:
 
 - `spec.runtime` for harness-owned runtime placement such as `spec.runtime.runRoot`
@@ -777,10 +796,15 @@ spec:
       rootDir: .
       virtualMode: true
       maxFileSizeMb: 10
+      sessionStorage:
+        enabled: true
+        rootDir: "{runRoot}/threads/{threadId}/filesystem"
     middleware: []
     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.
+
 Example orchestra host:
 
 ```yaml
@@ -841,6 +865,10 @@ Primary exports:
 - `deleteSession`
 - `listApprovals`
 - `getApproval`
+- `listArtifacts`
+- `getArtifact`
+- `exportEvaluationBundle`
+- `createAcpServer`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`

package/README.zh.md

@@ -118,7 +118,7 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正更
 
 运行时提供：
 
-- `createAgentHarness(workspaceRoot)`、`run(...)`、`memorize(...)`、`recall(...)`、`resolveApproval(...)`、`subscribe(...)`、各类查询方法，以及 `stop(...)`
+- `createAgentHarness(workspaceRoot)`、`run(...)`、`memorize(...)`、`recall(...)`、`listMemories(...)`、`updateMemory(...)`、`removeMemory(...)`、`resolveApproval(...)`、`subscribe(...)`、各类查询方法，以及 `stop(...)`
 - 以 YAML 描述的工作区装配：路由、模型、工具、存储、后端、MCP、恢复与维护等
 - 通过适配器对接当前的 LangChain v1 与 DeepAgents 执行
 - 本地 `resources/tools/` 中 `tool({...})` 工具模块与 `resources/skills/` 的发现
@@ -386,10 +386,13 @@ const recalled = await recall(runtime, {
 });
 ```
 
-当应用需要稳定的公开 runtime memory 接口，而不想依赖内部 `runtime/harness/system/*` 模块时，使用 `memorize(...)` 与 `recall(...)`。
+当应用需要稳定的公开 runtime memory 接口，而不想依赖内部 `runtime/harness/system/*` 模块时，使用 `memorize(...)`、`recall(...)`、`listMemories(...)`、`updateMemory(...)` 与 `removeMemory(...)`。
 
 - `memorize(...)` 返回稳定的 `MemoryRecord` 与 `MemoryDecision` 结果，而 merge、review、archive 与存储布局仍由 runtime 内部托管
 - `recall(...)` 返回按相关性排序、并按 scope / kind 过滤后的 `MemoryRecord`
+- `listMemories(...)` 返回稳定的 `MemoryRecord`，用于 inspection / admin 场景；如果不传 status 过滤器，默认只返回 `active`
+- `updateMemory(...)` 通过 `memoryId` 更新单条 durable memory，而不暴露内部 store namespace
+- `removeMemory(...)` 通过 `memoryId` 删除单条 durable memory，并重建运行时托管的 projection
 - 业务知识分类、review UI 与管理后台仍应留在应用层
 
 ### 由运行时路由
@@ -439,6 +442,7 @@ const result = await run(runtime, {
 
 ```ts
 import {
+  deleteSession,
   getApproval,
   getSession,
   listApprovals,
@@ -457,6 +461,10 @@ if (approval) {
     decision: "approve",
   });
 }
+
+if (session && session.currentState === "completed") {
+  await deleteSession(runtime, session.sessionId);
+}
 ```
 
 这些方法返回面向运行时的记录，而非原始 checkpoint 或后端对象。
@@ -520,6 +528,13 @@ await stop(runtime);
 - `resources/tools/`
 - `resources/skills/`
 
+发现规则：
+
+- `config/**` 下的所有 YAML 文档都会被递归发现；文件名与子目录只用于组织，不参与语义
+- YAML 对象语义由 `kind`、`metadata.name` 或 `id` 以及对象内容决定，而不是由文件路径决定
+- 本地工具会从 `resources/tools/**/*.js|*.mjs|*.cjs` 中自动发现，前提是模块导出 `tool({...})`
+- skills 会从 `resources/skills/**/SKILL.md` 自动发现
+
 `resources/tools/` 下的工作区本地工具模块应统一用 `tool({...})` 导出。
 不支持历史/兼容写法，任何不带该导出形式的工具模块都会在工作区加载时被拒绝。
 
@@ -529,7 +544,7 @@ await stop(runtime);
 - agent 再按名字白名单选择 tools 与 skills
 - `config/runtime/workspace.yaml` 中的运行时策略
 - `config/catalogs/*.yaml` 中的可复用对象目录
-- `config/agents/*.yaml` 中的 agent 装配
+- `config/**/*.yaml` 中的 agent 装配
 
 ### Backend 选择建议
 
@@ -602,7 +617,7 @@ spec:
 
 在此放置稳定的项目上下文；视为启动上下文，而非可变长期记忆。
 
-### `config/catalogs/models.yaml`
+### `config/**` 下的 Models Catalog
 
 命名聊天模型预设：
 
@@ -618,7 +633,9 @@ spec:
 
 加载为 `model/default`。
 
-### `config/catalogs/embedding-models.yaml`
+`kind: Models` catalog 可以放在 `config/` 下任意位置；`config/catalogs/models.yaml` 只是推荐布局。
+
+### `config/**` 下的 Embedding Model Catalog
 
 面向检索类工具的命名嵌入模型预设。
 
@@ -707,10 +724,12 @@ spec:
 
 这里可以省略 `spec[].kind`；catalog 项会默认按 `McpServer` 处理。
 
-### `config/agents/*.yaml`
+### `config/**` 下的 Agent YAML
 
 Agent 始终使用 `kind: Agent` 以及 `spec.backend`。
 
+Agent YAML 可以放在 `config/` 下任意位置；`config/agents/*.yaml` 是推荐布局，不是 loader 的硬性要求。
+
 两个区块：
 
 - `spec.runtime`：harness 侧运行时放置，例如 `spec.runtime.runRoot`
@@ -744,10 +763,15 @@ spec:
       rootDir: .
       virtualMode: true
       maxFileSizeMb: 10
+      sessionStorage:
+        enabled: true
+        rootDir: "{runRoot}/threads/{threadId}/filesystem"
     middleware: []
     systemPrompt: Answer simple requests directly.
 ```
 
+当 LangChain 绑定启用 `config.filesystem.sessionStorage.enabled: true` 时，runtime 会为每个持久化 session/thread 维护独立的 filesystem 根目录，并按 session 复用 runnable cache，而不是把所有运行都压到同一个共享工作目录里。
+
 orchestra 主机示例：
 
 ```yaml
@@ -808,6 +832,10 @@ spec:
 - `deleteSession`
 - `listApprovals`
 - `getApproval`
+- `listArtifacts`
+- `getArtifact`
+- `exportEvaluationBundle`
+- `createAcpServer`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`

package/dist/acp.d.ts

@@ -0,0 +1,86 @@
+import type { ArtifactRecord, HarnessEvent, RequestRecord, RunOptions, SessionRecord } from "./contracts/types.js";
+import type { AgentHarnessRuntime } from "./runtime/harness.js";
+import { getApproval } from "./api.js";
+type JsonRpcId = string | number | null;
+export type AcpJsonRpcRequest = {
+    jsonrpc?: "2.0";
+    id?: JsonRpcId;
+    method: string;
+    params?: unknown;
+};
+export type AcpJsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+export type AcpJsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: unknown;
+};
+export type AcpJsonRpcResponse = AcpJsonRpcError | AcpJsonRpcSuccess;
+export type AcpSessionRecord = SessionRecord;
+export type AcpRequestRecord = RequestRecord;
+export type AcpApproval = Awaited<ReturnType<typeof getApproval>> extends infer T ? Exclude<T, null> : never;
+export type AcpArtifact = ArtifactRecord & {
+    content?: unknown;
+};
+export type AcpRunRequestParams = Omit<Extract<RunOptions, {
+    input: unknown;
+}>, "threadId"> & {
+    sessionId?: string;
+};
+export type AcpServerCapabilities = {
+    sessions: {
+        list: true;
+        get: true;
+    };
+    requests: {
+        submit: true;
+        list: true;
+        get: true;
+    };
+    approvals: {
+        list: true;
+        get: true;
+        resolve: true;
+    };
+    artifacts: {
+        list: true;
+        read: true;
+    };
+    events: {
+        subscribe: true;
+    };
+};
+export type AcpEventNotification = {
+    jsonrpc: "2.0";
+    method: "events.runtime";
+    params: {
+        event: {
+            eventId: string;
+            eventType: string;
+            timestamp: string;
+            sessionId: string;
+            requestId: string;
+            sequence: number;
+            source: HarnessEvent["source"];
+            payload: Record<string, unknown>;
+        };
+    };
+};
+export declare class AgentHarnessAcpServer {
+    private readonly runtime;
+    constructor(runtime: AgentHarnessRuntime);
+    capabilities(): AcpServerCapabilities;
+    subscribe(listener: (notification: AcpEventNotification) => void): () => void;
+    handle(request: AcpJsonRpcRequest): Promise<AcpJsonRpcResponse | undefined>;
+    private methodExists;
+    private dispatch;
+}
+export declare function createAcpServer(runtime: AgentHarnessRuntime): AgentHarnessAcpServer;
+export {};

package/dist/acp.js

@@ -0,0 +1,208 @@
+import { getApproval, getArtifact, getRequest, getSession, listApprovals, listArtifacts, listRequests, listSessions, resolveApproval, run, } from "./api.js";
+const CAPABILITIES = {
+    sessions: { list: true, get: true },
+    requests: { submit: true, list: true, get: true },
+    approvals: { list: true, get: true, resolve: true },
+    artifacts: { list: true, read: true },
+    events: { subscribe: true },
+};
+function asObject(value, method) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${method} requires an object params payload.`);
+    }
+    return value;
+}
+function readOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readRequiredString(value, field, method) {
+    const normalized = readOptionalString(value);
+    if (!normalized) {
+        throw new Error(`${method} requires ${field}.`);
+    }
+    return normalized;
+}
+function toNotification(event) {
+    return {
+        jsonrpc: "2.0",
+        method: "events.runtime",
+        params: {
+            event: {
+                eventId: event.eventId,
+                eventType: event.eventType,
+                timestamp: event.timestamp,
+                sessionId: event.threadId,
+                requestId: event.runId,
+                sequence: event.sequence,
+                source: event.source,
+                payload: event.payload,
+            },
+        },
+    };
+}
+async function readArtifactContent(runtime, params) {
+    const method = "artifacts.read";
+    const sessionId = readRequiredString(params.sessionId, "sessionId", method);
+    const requestId = readRequiredString(params.requestId, "requestId", method);
+    const artifactPath = readRequiredString(params.artifactPath, "artifactPath", method);
+    const listing = await listArtifacts(runtime, { sessionId, requestId });
+    const artifact = listing.items.find((item) => item.path === artifactPath);
+    if (!artifact) {
+        throw new Error(`Artifact not found for ${requestId}: ${artifactPath}`);
+    }
+    return {
+        ...artifact,
+        content: await getArtifact(runtime, { sessionId, requestId, artifactPath }),
+    };
+}
+export class AgentHarnessAcpServer {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    capabilities() {
+        return CAPABILITIES;
+    }
+    subscribe(listener) {
+        return this.runtime.subscribe((event) => {
+            listener(toNotification(event));
+        });
+    }
+    async handle(request) {
+        const id = request.id ?? null;
+        if (!request || typeof request !== "object" || typeof request.method !== "string" || request.method.trim().length === 0) {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Invalid JSON-RPC request.",
+                },
+            };
+        }
+        if (request.jsonrpc !== undefined && request.jsonrpc !== "2.0") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Only JSON-RPC 2.0 requests are supported.",
+                },
+            };
+        }
+        try {
+            const result = await this.dispatch(request.method, request.params);
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return {
+                jsonrpc: "2.0",
+                id,
+                result,
+            };
+        }
+        catch (error) {
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: this.methodExists(request.method) ? -32602 : -32601,
+                    message: error instanceof Error ? error.message : "ACP request failed.",
+                },
+            };
+        }
+    }
+    methodExists(method) {
+        return new Set([
+            "capabilities.get",
+            "sessions.list",
+            "sessions.get",
+            "requests.submit",
+            "requests.list",
+            "requests.get",
+            "approvals.list",
+            "approvals.get",
+            "approvals.resolve",
+            "artifacts.list",
+            "artifacts.read",
+        ]).has(method);
+    }
+    async dispatch(method, params) {
+        switch (method) {
+            case "capabilities.get":
+                return this.capabilities();
+            case "sessions.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listSessions(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                });
+            }
+            case "sessions.get": {
+                const payload = asObject(params, method);
+                return getSession(this.runtime, readRequiredString(payload.sessionId, "sessionId", method));
+            }
+            case "requests.submit": {
+                const payload = asObject(params, method);
+                return run(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                    input: payload.input,
+                    invocation: payload.invocation,
+                    listeners: payload.listeners,
+                    priority: typeof payload.priority === "number" ? payload.priority : undefined,
+                    sessionId: readOptionalString(payload.sessionId),
+                });
+            }
+            case "requests.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listRequests(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                    sessionId: readOptionalString(payload.sessionId),
+                    state: payload.state,
+                });
+            }
+            case "requests.get": {
+                const payload = asObject(params, method);
+                return getRequest(this.runtime, readRequiredString(payload.requestId, "requestId", method));
+            }
+            case "approvals.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listApprovals(this.runtime, {
+                    status: payload.status,
+                    sessionId: readOptionalString(payload.sessionId),
+                    requestId: readOptionalString(payload.requestId),
+                });
+            }
+            case "approvals.get": {
+                const payload = asObject(params, method);
+                return getApproval(this.runtime, readRequiredString(payload.approvalId, "approvalId", method));
+            }
+            case "approvals.resolve": {
+                const payload = asObject(params, method);
+                return resolveApproval(this.runtime, {
+                    approvalId: readRequiredString(payload.approvalId, "approvalId", method),
+                    decision: payload.decision,
+                    editedInput: payload.editedInput,
+                    requestId: readOptionalString(payload.requestId),
+                    sessionId: readOptionalString(payload.sessionId),
+                });
+            }
+            case "artifacts.list": {
+                const payload = asObject(params, method);
+                return listArtifacts(this.runtime, {
+                    sessionId: readRequiredString(payload.sessionId, "sessionId", method),
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                });
+            }
+            case "artifacts.read":
+                return readArtifactContent(this.runtime, asObject(params, method));
+            default:
+                throw new Error(`Unknown ACP method: ${method}`);
+        }
+    }
+}
+export function createAcpServer(runtime) {
+    return new AgentHarnessAcpServer(runtime);
+}

package/dist/api.d.ts

@@ -1,11 +1,13 @@
-import type { CancelOptions, InvocationEnvelope, MemorizeInput, MemorizeResult, MessageContent, RecallInput, RecallResult, RequestRecord, RequestSummary, ResumeOptions, RunDecisionOptions, RunResult, RunStartOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, SessionRecord, SessionSummary, WorkspaceLoadOptions } from "./contracts/types.js";
+import type { ArtifactListing, CancelOptions, InvocationEnvelope, ListMemoriesInput, ListMemoriesResult, MemoryRecord, MemorizeInput, MemorizeResult, MessageContent, RecallInput, RecallResult, RemoveMemoryInput, RequestRecord, RequestSummary, ResumeOptions, RunDecisionOptions, RunResult, RunStartOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, SessionRecord, SessionSummary, UpdateMemoryInput, WorkspaceLoadOptions } from "./contracts/types.js";
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./runtime/harness/system/skill-requirements.js";
 import type { ToolMcpServerOptions } from "./mcp.js";
+export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
+export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRunRequestParams, AcpServerCapabilities, AcpSessionRecord, } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
 export { createUpstreamTimelineReducer } from "./upstream-events.js";
-export type { MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, RecallInput, RecallResult, } from "./contracts/types.js";
+export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, UpdateMemoryInput, } from "./contracts/types.js";
 type PublicApprovalRecord = {
     approvalId: string;
     pendingActionId: string;
@@ -57,6 +59,9 @@ export declare function normalizeUserChatInput(input: UserChatInput, options?: N
 export declare function run(runtime: AgentHarnessRuntime, options: PublicRunOptions): Promise<PublicRunResult>;
 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: Parameters<AgentHarnessRuntime["subscribe"]>[0]): () => void;
 export declare function listSessions(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listThreads"]>[0]): Promise<SessionSummary[]>;
 export declare function listRequests(runtime: AgentHarnessRuntime, filter?: {
@@ -69,7 +74,17 @@ export declare function getRequest(runtime: AgentHarnessRuntime, requestId: stri
 export declare function deleteSession(runtime: AgentHarnessRuntime, sessionId: string): Promise<boolean>;
 export declare function listApprovals(runtime: AgentHarnessRuntime, filter?: PublicApprovalFilter): Promise<PublicApprovalRecord[]>;
 export declare function getApproval(runtime: AgentHarnessRuntime, approvalId: string): Promise<PublicApprovalRecord | null>;
+export declare function listArtifacts(runtime: AgentHarnessRuntime, input: {
+    sessionId: string;
+    requestId: string;
+}): Promise<ArtifactListing>;
+export declare function getArtifact(runtime: AgentHarnessRuntime, input: {
+    sessionId: string;
+    requestId: string;
+    artifactPath: string;
+}): Promise<unknown>;
 export declare function getHealth(runtime: AgentHarnessRuntime): Promise<RuntimeHealthSnapshot>;
+export declare function exportEvaluationBundle(runtime: AgentHarnessRuntime, input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
 export declare function listAgentSkills(runtime: AgentHarnessRuntime, agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
 export declare function getAgent(runtime: AgentHarnessRuntime, agentId: string, options?: RequirementAssessmentOptions): InventoryAgentRecord | null;
 export declare function describeInventory(runtime: AgentHarnessRuntime, options?: RequirementAssessmentOptions): {

package/dist/api.js

@@ -1,6 +1,7 @@
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import { normalizeMessageContent } from "./utils/message-content.js";
 import { loadWorkspace } from "./workspace/compile.js";
+export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
 export { createUpstreamTimelineReducer } from "./upstream-events.js";
 function toSessionSummary(summary) {
@@ -134,6 +135,15 @@ export async function memorize(runtime, input) {
 export async function recall(runtime, input) {
     return runtime.recall(input);
 }
+export async function listMemories(runtime, input = {}) {
+    return runtime.listMemories(input);
+}
+export async function updateMemory(runtime, input) {
+    return runtime.updateMemory(input);
+}
+export async function removeMemory(runtime, input) {
+    return runtime.removeMemory(input);
+}
 export function subscribe(runtime, listener) {
     return runtime.subscribe(listener);
 }
@@ -169,9 +179,18 @@ export async function getApproval(runtime, approvalId) {
     const record = await runtime.getApproval(approvalId);
     return record ? toApprovalRecord(record) : null;
 }
+export async function listArtifacts(runtime, input) {
+    return runtime.listArtifacts(input.sessionId, input.requestId);
+}
+export async function getArtifact(runtime, input) {
+    return runtime.readArtifact(input.sessionId, input.requestId, input.artifactPath);
+}
 export async function getHealth(runtime) {
     return runtime.getHealth();
 }
+export async function exportEvaluationBundle(runtime, input) {
+    return runtime.exportEvaluationBundle(input);
+}
 export function listAgentSkills(runtime, agentId, options) {
     return runtime.listAgentSkills(agentId, options);
 }