diff --git a/.changeset/bailian-builtin-tool-permissions.md b/.changeset/bailian-builtin-tool-permissions.md new file mode 100644 index 0000000..678d14d --- /dev/null +++ b/.changeset/bailian-builtin-tool-permissions.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": patch +--- + +Support Bailian builtin-tool approval policies during validation and Agent create/update. Preserve toolkit defaults and per-tool overrides in provider requests and exports, detect effective approval changes during drift comparison, and retain legacy allow-only comparison baselines. Reject effective approval policies on project-declared subagents and delegated Self; fail closed when an implicitly enabled remote tool catalogue cannot be exported losslessly. diff --git a/.changeset/bailian-memory-id-identity.md b/.changeset/bailian-memory-id-identity.md new file mode 100644 index 0000000..fffd186 --- /dev/null +++ b/.changeset/bailian-memory-id-identity.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": patch +--- + +Identify Bailian Memory Stores by their remote ID rather than their non-unique display name. Disable name-based conflict adoption, create a new store when no remote ID is recorded, and exclude archived stores from ID-based lifecycle lookups. diff --git a/.changeset/bailian-multiagent-self.md b/.changeset/bailian-multiagent-self.md new file mode 100644 index 0000000..00925a8 --- /dev/null +++ b/.changeset/bailian-multiagent-self.md @@ -0,0 +1,7 @@ +--- +"@openagentpack/sdk": minor +--- + +为百炼多智能体名册增加原生 `{type: "self"}` 成员,可独立使用或与项目 Agent、外部 Agent 混用。 +补齐声明类型与严格校验、引用解析、发布映射、导出和漂移比较。Self 不生成普通自引用或额外受管资源, +计入名册上限并禁止重复及附带 ID/版本字段;其他 Provider 明确拒绝未验证的 Self 能力。 diff --git a/.changeset/bailian-native-memory-lifecycle.md b/.changeset/bailian-native-memory-lifecycle.md new file mode 100644 index 0000000..fa00285 --- /dev/null +++ b/.changeset/bailian-native-memory-lifecycle.md @@ -0,0 +1,9 @@ +--- +"@openagentpack/sdk": minor +--- + +Add native Bailian Memory Store, memory file, and historical version APIs, including store archive, file rename, content SHA preconditions, version redaction, and opaque `page`/`next_page` pagination. Preserve native absolute paths, response fields, operation names, and service errors. + +Enable declarative Bailian Memory Stores with ID-only identity, explicit import, declared-key metadata reconciliation, and recoverable initialization. Persist the created store ID and pending initializer hashes before writing content; retries resume missing pending paths without overwriting existing files. Existing and imported stores preserve runtime content by default, while explicit `entries_mode: sync` manages declared paths. Removing a store and applying, or destroying it, irreversibly archives it. + +Resolve logical Memory references into native Session resources with access settings, instructions, deduplication, and an eight-store limit. Block Session mounting until initialization completes and reject Memory mounts in file-only Bailian Deployments. diff --git a/.changeset/bailian-session-event-snapshots.md b/.changeset/bailian-session-event-snapshots.md new file mode 100644 index 0000000..caa3fb1 --- /dev/null +++ b/.changeset/bailian-session-event-snapshots.md @@ -0,0 +1,11 @@ +--- +"@openagentpack/sdk": minor +--- + +为百炼 BMA Session 增加显式开启的结构化事件快照和正文/推理增量订阅。SDK 按消息与内容块 +归并累计快照,保留工具调用、线程、审批、错误和多模态内容;从已确认的 `mark_artifacts` +工具结果派生文件描述,继续复用现有 `SessionEvent` 契约。 + +补齐 SSE 分块解析、连接就绪回调、取消、超时及可选的断流后历史核对恢复。高层发送入口 +通过 `stream` 传递配置,恢复不会重发用户消息。sanitizer 支持结构化快照的递归脱敏和按文本 +叶子截断。旧调用仍使用 legacy 输出,默认脱敏和截断、默认不重连的行为保持不变。 diff --git a/.changeset/bailian-session-runtime-resources.md b/.changeset/bailian-session-runtime-resources.md new file mode 100644 index 0000000..de0f39c --- /dev/null +++ b/.changeset/bailian-session-runtime-resources.md @@ -0,0 +1,16 @@ +--- +"@openagentpack/sdk": minor +--- + +为百炼 Managed Agents 增加会话运行时资源 API(挂载/列出/查详情/卸载),支持向已创建的 +Session 动态追加文件:`mountRemoteSessionResource`、`listRemoteSessionResources`、 +`getRemoteSessionResource`、`unmountRemoteSessionResource`(bailian adapter 的 +`mountSessionResource` / `listSessionResources` / `getSessionResource` / `unmountSessionResource` +可选方法)。中性层沿用全沙箱路径(`/mnt/session/uploads/…`),bailian wire 自动换算为运行时 +端点要求的 `/uploads/…` 前缀并在非法根路径上客户端拒绝;资源响应补齐 `SessionResourceInfo.id` +(`sesrsc_…`,卸载凭据)。挂载与卸载不产生会话事件;provider 返回的 `file_id` 是服务端内部副本 +id,完整载荷保留在 `attributes` 中。运行时挂载不进入 `getSession` 的 `resources` 回显,对账请 +使用列表端点。合同经 2026-11-02 live 实测校准。 + +上述四个 SDK 入口接受仅含 Provider 配置的 `ManagedApiContext`,无需项目配置或本地 State; +现有 `ProjectRuntimeContext` 调用保持兼容。 diff --git a/.changeset/bailian-stream-envelopes.md b/.changeset/bailian-stream-envelopes.md new file mode 100644 index 0000000..9a9a33a --- /dev/null +++ b/.changeset/bailian-stream-envelopes.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": patch +--- + +修复百炼 BMA Session 混合流中 event_start/event_delta 的身份及正文累积,避免首个推理分片触发协议错误;保留完整消息、线程身份和断流恢复语义。 diff --git a/.changeset/bailian-usage-queries.md b/.changeset/bailian-usage-queries.md new file mode 100644 index 0000000..92ac576 --- /dev/null +++ b/.changeset/bailian-usage-queries.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": minor +--- + +新增百炼资源用量查询:`listModelUsage` / `listToolUsage` 对接 app-control `usage.listModelUsage` / `usage.listToolUsage`,支持 workspace/agent/session 三种 scope、毫秒级 time_range 交叉校验(session 禁止、其余必传)、来源与名称过滤及分页排序,并公开 `UsageScope`、`ModelUsagePage`、`ToolUsagePage` 等类型。apps/server 同步暴露 `POST /api/usage/models`、`POST /api/usage/tools` 并刷新 OpenAPI 快照。 diff --git a/.changeset/browser-bailian-session-normalizer.md b/.changeset/browser-bailian-session-normalizer.md new file mode 100644 index 0000000..a35ac3c --- /dev/null +++ b/.changeset/browser-bailian-session-normalizer.md @@ -0,0 +1,10 @@ +--- +"@openagentpack/sdk": minor +--- + +新增浏览器安全的 `createBailianSessionEventNormalizer`,从 `@openagentpack/sdk/session-events` +接收原始百炼业务帧并输出累计 `SessionEvent`。历史进行中消息保留展示及运行身份,等待完整快照 +后恢复正文;完成消息保护、按实例隔离和有界缓存避免重连期间重复追加。既有 SDK 入口与 +sanitizer 默认脱敏、截断行为不变。 + +同一浏览器子路径公开导出现有 `SessionEvent` 类型,纯浏览器调用方无需通过 SDK Node 主入口引用事件契约。 diff --git a/.changeset/configurable-session-event-redaction.md b/.changeset/configurable-session-event-redaction.md new file mode 100644 index 0000000..9f47b6e --- /dev/null +++ b/.changeset/configurable-session-event-redaction.md @@ -0,0 +1,8 @@ +--- +"@openagentpack/sdk": minor +--- + +为 `sanitizeSessionEvent()` 和 `sanitizeSessionEvents()` 增加独立的 `redact` 与 `truncate` +配置,保留默认开启脱敏和截断的行为。需要完整 SSE 内容的调用方可显式传入 +`{ redact: false, truncate: false }`。导出 `SessionEventSanitizerOptions` 类型, +让 `metadata.tool_input` 使用同一脱敏策略,并保持 `includeRaw` 独立。 diff --git a/.changeset/fix-linear-redaction-scans.md b/.changeset/fix-linear-redaction-scans.md new file mode 100644 index 0000000..314c569 --- /dev/null +++ b/.changeset/fix-linear-redaction-scans.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": patch +--- + +修复会话文本处理中的两处正则回溯风险,使用线性扫描识别 Markdown 链接和 HTML 标签,保留媒体签名链接、敏感信息脱敏与截断边界的既有行为。 diff --git a/.changeset/fix-vite-hono-audit.md b/.changeset/fix-vite-hono-audit.md new file mode 100644 index 0000000..c7bc099 --- /dev/null +++ b/.changeset/fix-vite-hono-audit.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/playground": patch +--- + +升级 Vite、Hono 与 Node 静态文件服务依赖,修复开发服务及静态路径处理的已知安全漏洞。 diff --git a/.changeset/literal-config-state-storage.md b/.changeset/literal-config-state-storage.md new file mode 100644 index 0000000..ea5b150 --- /dev/null +++ b/.changeset/literal-config-state-storage.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": minor +--- + +新增对象声明的字面正文解析选项与公开内存 state 管理器,支持宿主使用数据库保存检查点。默认正文文件解析、文件 state 和现有发布行为保持兼容。 diff --git a/.changeset/memory-entry-initialization-default.md b/.changeset/memory-entry-initialization-default.md new file mode 100644 index 0000000..9e216e7 --- /dev/null +++ b/.changeset/memory-entry-initialization-default.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": minor +--- + +Default declarative memory entries to initialization of newly created stores only. Existing, imported, or adopted stores retain their runtime content, and initialization-only entry changes no longer schedule updates. Add entries_mode: sync as an explicit opt-in to the previous continuous YAML synchronization behavior. diff --git a/.changeset/optional-mcp-tool-overrides.md b/.changeset/optional-mcp-tool-overrides.md new file mode 100644 index 0000000..1e0997e --- /dev/null +++ b/.changeset/optional-mcp-tool-overrides.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": patch +--- + +Allow MCP toolkit configs and agent-builder tool overrides to be omitted or empty. Bailian requests normalize missing overrides to an empty array, so default_config.enabled can enable all MCP tools without placeholder names. Preserve the disabled default and explicit per-tool overrides. diff --git a/.changeset/secure-build-dependencies.md b/.changeset/secure-build-dependencies.md new file mode 100644 index 0000000..a3e3dca --- /dev/null +++ b/.changeset/secure-build-dependencies.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/playground": patch +--- + +Update the bundled editor to a patched ProseMirror view version and refresh vulnerable build dependencies. Backport bounded nesting and AST traversal checks for the workspace's braces dependency while an official fix is unavailable. diff --git a/.changeset/session-recovery-backend-commit.md b/.changeset/session-recovery-backend-commit.md new file mode 100644 index 0000000..b2b0922 --- /dev/null +++ b/.changeset/session-recovery-backend-commit.md @@ -0,0 +1,9 @@ +--- +"@openagentpack/sdk": patch +"@openagentpack/playground": patch +--- + +修复百炼 Session 重连时历史结束状态抢先终止单轮读取的问题,确保恢复期间缓冲的完整回复先交付。 +修复结构化资源执行在 StateBackend 最终提交失败时丢失报告的问题,保留远端写入状态、逐资源结果和已知资源 ID,legacy 异常行为保持兼容。 + +将 Playground 的 `@hono/node-server` 最低版本升级至 `2.1.6`,修复上游 WebSocket 连接重置和请求路径解析问题。 diff --git a/.changeset/session-thread-history.md b/.changeset/session-thread-history.md new file mode 100644 index 0000000..b5bad40 --- /dev/null +++ b/.changeset/session-thread-history.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": minor +--- + +新增百炼 Session 子 Agent 线程列表和事件历史查询,保留分页、取消及完整快照语义,并公开浏览器可用的线程类型。 diff --git a/.changeset/tidy-webhook-context.md b/.changeset/tidy-webhook-context.md new file mode 100644 index 0000000..6962fd5 --- /dev/null +++ b/.changeset/tidy-webhook-context.md @@ -0,0 +1,5 @@ +--- +"@openagentpack/sdk": minor +--- + +Add workspace-level Bailian Webhook endpoint management and delivery-event queries through a provider-only API context. Expose endpoint URL normalization and cancellable requests while preserving one-time signing-secret responses, opaque pagination cursors, request IDs, and provider errors. These APIs do not read project files or write project state. diff --git a/.changeset/zod-security-bound.md b/.changeset/zod-security-bound.md new file mode 100644 index 0000000..203dfbb --- /dev/null +++ b/.changeset/zod-security-bound.md @@ -0,0 +1,6 @@ +--- +"@openagentpack/sdk": patch +"@openagentpack/playground": patch +--- + +将 Zod 依赖下界更新为 4.6.6,修复 GHSA-mrhx-c7xc-m3w5,避免新安装解析到受影响版本。 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8fc5dfd..bd6b128 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -25,7 +25,7 @@ jobs: fetch-depth: 0 - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - id: profile name: Read full profile from the verification module run: echo "steps=$(bun scripts/verify.ts full --list-steps)" >> "$GITHUB_OUTPUT" @@ -44,7 +44,7 @@ jobs: fetch-depth: 0 - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - run: bun install --frozen-lockfile - name: Run verification step env: @@ -73,7 +73,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6 - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 with: node-version: ${{ matrix.node }} diff --git a/.github/workflows/compatibility-canary.yml b/.github/workflows/compatibility-canary.yml index af64de1..75f313d 100644 --- a/.github/workflows/compatibility-canary.yml +++ b/.github/workflows/compatibility-canary.yml @@ -24,7 +24,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6 - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 with: node-version: "26" diff --git a/.github/workflows/release-pr.yml b/.github/workflows/release-pr.yml index 82b2ce8..0dd8035 100644 --- a/.github/workflows/release-pr.yml +++ b/.github/workflows/release-pr.yml @@ -21,7 +21,7 @@ jobs: - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - name: Install dependencies run: bun install --frozen-lockfile diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 377f063..b1960dc 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -43,7 +43,7 @@ jobs: - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 with: @@ -92,7 +92,7 @@ jobs: - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 with: @@ -146,7 +146,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6 - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 with: node-version: "24" @@ -170,7 +170,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v6 - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 with: - bun-version: "1.3.5" + bun-version: "1.4.4" - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 with: node-version: ${{ matrix.node }} diff --git a/apps/server/openapi.json b/apps/server/openapi.json index 0ba12f1..78022c8 100644 --- a/apps/server/openapi.json +++ b/apps/server/openapi.json @@ -1795,6 +1795,305 @@ } }, "required": ["id", "type", "status", "created_at", "updated_at", "events"] + }, + "ModelUsagePage": { + "type": "object", + "properties": { + "items": { + "type": "array", + "items": { + "$ref": "#/components/schemas/ModelUsageItem" + } + }, + "total": { + "type": "integer", + "description": "Total rows across all pages." + }, + "total_call_count": { + "type": "integer", + "description": "Total calls across all pages." + }, + "page_no": { + "type": "integer" + }, + "page_size": { + "type": "integer" + }, + "data_updated_at": { + "type": "integer", + "description": "Data freshness, Unix epoch milliseconds." + } + }, + "required": ["items", "total", "total_call_count", "page_no", "page_size", "data_updated_at"] + }, + "ModelUsageItem": { + "type": "object", + "properties": { + "workspace_id": { + "type": "string" + }, + "model_name": { + "type": "string" + }, + "call_count": { + "type": "integer" + }, + "failed_count": { + "type": "integer" + }, + "tokens": { + "$ref": "#/components/schemas/UsageTokenStats" + } + }, + "required": ["workspace_id", "model_name", "call_count", "failed_count", "tokens"] + }, + "UsageTokenStats": { + "type": "object", + "properties": { + "input_tokens": { + "type": "integer" + }, + "output_tokens": { + "type": "integer" + }, + "cache_read_tokens": { + "type": "integer" + }, + "cache_creation_tokens": { + "type": "integer" + }, + "total_tokens": { + "type": "integer" + }, + "cache_hit_ratio": { + "type": "number" + } + }, + "required": [ + "input_tokens", + "output_tokens", + "cache_read_tokens", + "cache_creation_tokens", + "total_tokens", + "cache_hit_ratio" + ] + }, + "ListModelUsageRequest": { + "type": "object", + "properties": { + "scope": { + "$ref": "#/components/schemas/UsageScope" + }, + "time_range": { + "$ref": "#/components/schemas/UsageTimeRange" + }, + "model_name": { + "type": "string", + "nullable": true, + "description": "Exact model name; omitted/null means all models." + }, + "page_no": { + "type": "integer", + "minimum": 1, + "default": 1, + "description": "1-based page number." + }, + "page_size": { + "type": "integer", + "minimum": 1, + "maximum": 100, + "default": 20, + "description": "Page size, 1..100." + }, + "sort_order": { + "type": "string", + "enum": ["asc", "desc"], + "default": "desc" + }, + "sort_by": { + "type": "string", + "enum": ["call_count", "failed_count", "input_tokens", "output_tokens"], + "default": "call_count" + } + }, + "required": ["scope"] + }, + "UsageScope": { + "oneOf": [ + { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": ["workspace"], + "description": "Aggregated usage across the listed workspaces." + }, + "workspace_ids": { + "type": "array", + "items": { + "type": "string" + }, + "minItems": 1, + "description": "Workspaces to aggregate; at least one is required." + }, + "agent_id": { + "type": "string", + "description": "Narrow the workspace aggregation to one Agent." + } + }, + "required": ["type", "workspace_ids"] + }, + { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": ["agent"], + "description": "Usage of one Agent (optionally a pinned version)." + }, + "agent_id": { + "type": "string" + }, + "workspace_ids": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional single-workspace pin; omit to use the caller's identity workspace." + }, + "agent_version": { + "type": "string" + } + }, + "required": ["type", "agent_id"] + }, + { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": ["session"], + "description": "Usage within one Session; its own window applies." + }, + "session_id": { + "type": "string" + } + }, + "required": ["type", "session_id"] + } + ] + }, + "UsageTimeRange": { + "type": "object", + "properties": { + "start_time": { + "type": "integer", + "description": "Window start, Unix epoch milliseconds." + }, + "end_time": { + "type": "integer", + "description": "Window end, Unix epoch milliseconds." + } + }, + "required": ["start_time", "end_time"] + }, + "ToolUsagePage": { + "type": "object", + "properties": { + "items": { + "type": "array", + "items": { + "$ref": "#/components/schemas/ToolUsageItem" + } + }, + "total": { + "type": "integer", + "description": "Total rows across all pages." + }, + "total_call_count": { + "type": "integer", + "description": "Total calls across all pages." + }, + "page_no": { + "type": "integer" + }, + "page_size": { + "type": "integer" + }, + "data_updated_at": { + "type": "integer", + "description": "Data freshness, Unix epoch milliseconds." + } + }, + "required": ["items", "total", "total_call_count", "page_no", "page_size", "data_updated_at"] + }, + "ToolUsageItem": { + "type": "object", + "properties": { + "workspace_id": { + "type": "string" + }, + "tool_name": { + "type": "string" + }, + "source": { + "type": "string", + "description": "builtin | mcp | custom; unknown future values are preserved verbatim." + }, + "call_count": { + "type": "integer" + }, + "failed_count": { + "type": "integer" + } + }, + "required": ["workspace_id", "tool_name", "source", "call_count", "failed_count"] + }, + "ListToolUsageRequest": { + "type": "object", + "properties": { + "scope": { + "$ref": "#/components/schemas/UsageScope" + }, + "time_range": { + "$ref": "#/components/schemas/UsageTimeRange" + }, + "source": { + "type": "string", + "nullable": true, + "enum": ["builtin", "mcp", "custom", null], + "description": "Exact tool source; omitted/null means all sources." + }, + "tool_name": { + "type": "string", + "nullable": true, + "description": "Exact tool name; omitted/null means all tools." + }, + "page_no": { + "type": "integer", + "minimum": 1, + "default": 1, + "description": "1-based page number." + }, + "page_size": { + "type": "integer", + "minimum": 1, + "maximum": 100, + "default": 20, + "description": "Page size, 1..100." + }, + "sort_order": { + "type": "string", + "enum": ["asc", "desc"], + "default": "desc" + }, + "sort_by": { + "type": "string", + "enum": ["call_count", "failed_count"], + "default": "call_count" + } + }, + "required": ["scope"] } }, "parameters": {} @@ -4719,6 +5018,180 @@ } } } + }, + "/api/usage/models": { + "post": { + "operationId": "listModelUsage", + "requestBody": { + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ListModelUsageRequest" + } + } + } + }, + "responses": { + "200": { + "description": "Paged aggregated model usage for the requested scope", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ModelUsagePage" + } + } + } + }, + "400": { + "description": "Bad request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "403": { + "description": "Forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "404": { + "description": "Not found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "409": { + "description": "Conflict", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "422": { + "description": "Unprocessable entity", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "500": { + "description": "Server error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + } + } + } + }, + "/api/usage/tools": { + "post": { + "operationId": "listToolUsage", + "requestBody": { + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ListToolUsageRequest" + } + } + } + }, + "responses": { + "200": { + "description": "Paged aggregated tool usage for the requested scope", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ToolUsagePage" + } + } + } + }, + "400": { + "description": "Bad request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "403": { + "description": "Forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "404": { + "description": "Not found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "409": { + "description": "Conflict", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "422": { + "description": "Unprocessable entity", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + }, + "500": { + "description": "Server error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + } + } + } } } } diff --git a/apps/server/package.json b/apps/server/package.json index 91953fd..7f895b0 100644 --- a/apps/server/package.json +++ b/apps/server/package.json @@ -18,7 +18,7 @@ "@hono/zod-openapi": "^1.4.0", "@openagentpack/sdk": "workspace:*", "chokidar": "^4.0.3", - "hono": "^4.13.5", + "hono": "^4.13.11", "yaml": "^2.9.0" }, "devDependencies": { diff --git a/apps/server/src/app.ts b/apps/server/src/app.ts index 0a9abd3..4d733c7 100644 --- a/apps/server/src/app.ts +++ b/apps/server/src/app.ts @@ -4,6 +4,7 @@ import { jsonError } from "@/lib/http-error"; import { operationsRoute } from "@/routes/operations"; import { projectRoute } from "@/routes/project"; import { projectSessionsRoute } from "@/routes/project-sessions"; +import { usageRoute } from "@/routes/usage"; import { projectRuntimeManager } from "@/services/project-manager"; export const app = new OpenAPIHono(); @@ -34,6 +35,7 @@ app.use("/api/*", async (context, next) => { app.route("/api", projectRoute); app.route("/api", projectSessionsRoute); app.route("/api", operationsRoute); +app.route("/api", usageRoute); // OpenAPI document app.doc("/openapi.json", { diff --git a/apps/server/src/routes/usage.ts b/apps/server/src/routes/usage.ts new file mode 100644 index 0000000..5b3c56a --- /dev/null +++ b/apps/server/src/routes/usage.ts @@ -0,0 +1,67 @@ +import { createRoute, OpenAPIHono } from "@hono/zod-openapi"; +import { listModelUsage, listToolUsage, readProjectRuntime } from "@openagentpack/sdk"; +import { errorResponses } from "@/schemas/common"; +import { + ListModelUsageRequestSchema, + ListToolUsageRequestSchema, + ModelUsagePageSchema, + ToolUsagePageSchema, +} from "@/schemas/usage"; +import { projectRuntimeManager } from "@/services/project-manager"; + +export const usageRoute = new OpenAPIHono(); + +// Usage analytics proxy the resolved provider's app-control usage.* endpoints. The +// scope/time_range cross rules are validated by the request schemas (session scope +// forbids time_range; workspace/agent require it). +const listModelUsageRoute = createRoute({ + method: "post", + path: "/usage/models", + operationId: "listModelUsage", + request: { + body: { required: true, content: { "application/json": { schema: ListModelUsageRequestSchema } } }, + }, + responses: { + 200: { + description: "Paged aggregated model usage for the requested scope", + content: { "application/json": { schema: ModelUsagePageSchema } }, + }, + ...errorResponses, + }, +}); + +usageRoute.openapi(listModelUsageRoute, async (c) => { + const request = c.req.valid("json"); + await projectRuntimeManager.ensureStarted(); + const page = await readProjectRuntime(projectRuntimeManager.requireRuntimeInput(), (ctx) => { + const provider = ctx.config.defaults?.provider; + return listModelUsage(ctx, request, { provider }); + }); + return c.json(page, 200); +}); + +const listToolUsageRoute = createRoute({ + method: "post", + path: "/usage/tools", + operationId: "listToolUsage", + request: { + body: { required: true, content: { "application/json": { schema: ListToolUsageRequestSchema } } }, + }, + responses: { + 200: { + description: "Paged aggregated tool usage for the requested scope", + content: { "application/json": { schema: ToolUsagePageSchema } }, + }, + ...errorResponses, + }, +}); + +usageRoute.openapi(listToolUsageRoute, async (c) => { + const request = c.req.valid("json"); + await projectRuntimeManager.ensureStarted(); + const page = await readProjectRuntime(projectRuntimeManager.requireRuntimeInput(), (ctx) => { + const provider = ctx.config.defaults?.provider; + return listToolUsage(ctx, request, { provider }); + }); + return c.json(page, 200); +}); diff --git a/apps/server/src/schemas/usage.ts b/apps/server/src/schemas/usage.ts new file mode 100644 index 0000000..cfad304 --- /dev/null +++ b/apps/server/src/schemas/usage.ts @@ -0,0 +1,145 @@ +import { z } from "@hono/zod-openapi"; + +// Usage analytics over app-control usage.* (model call details / tool call details). +// Wire shapes mirror the SDK's usage types; paging defaults follow the usage contract +// (page 1, size 20, sort call_count desc). + +export const UsageTimeRangeSchema = z + .object({ + start_time: z.number().int().describe("Window start, Unix epoch milliseconds."), + end_time: z.number().int().describe("Window end, Unix epoch milliseconds."), + }) + .openapi("UsageTimeRange"); + +export const UsageScopeSchema = z + .discriminatedUnion("type", [ + z.object({ + type: z.literal("workspace").describe("Aggregated usage across the listed workspaces."), + workspace_ids: z.array(z.string()).min(1).describe("Workspaces to aggregate; at least one is required."), + agent_id: z.string().optional().describe("Narrow the workspace aggregation to one Agent."), + }), + z.object({ + type: z.literal("agent").describe("Usage of one Agent (optionally a pinned version)."), + agent_id: z.string(), + workspace_ids: z + .array(z.string()) + .optional() + .describe("Optional single-workspace pin; omit to use the caller's identity workspace."), + agent_version: z.string().optional(), + }), + z.object({ + type: z.literal("session").describe("Usage within one Session; its own window applies."), + session_id: z.string(), + }), + ]) + .openapi("UsageScope"); + +const usagePagination = { + page_no: z.number().int().min(1).default(1).describe("1-based page number."), + page_size: z.number().int().min(1).max(100).default(20).describe("Page size, 1..100."), + sort_order: z.enum(["asc", "desc"]).default("desc"), +}; + +function refineUsageTimeRange< + T extends { scope: { type: string }; time_range?: { start_time: number; end_time: number } }, +>(value: T, ctx: z.RefinementCtx): void { + if (value.scope.type === "session") { + if (value.time_range) { + ctx.addIssue({ + code: z.ZodIssueCode.custom, + path: ["time_range"], + message: "time_range is forbidden for session scope; the Session's own window is used.", + }); + } + return; + } + if (!value.time_range) { + ctx.addIssue({ + code: z.ZodIssueCode.custom, + path: ["time_range"], + message: `time_range is required for ${value.scope.type} scope.`, + }); + } +} + +export const ListModelUsageRequestSchema = z + .object({ + scope: UsageScopeSchema, + time_range: UsageTimeRangeSchema.optional(), + model_name: z.string().nullish().describe("Exact model name; omitted/null means all models."), + ...usagePagination, + sort_by: z.enum(["call_count", "failed_count", "input_tokens", "output_tokens"]).default("call_count"), + }) + .superRefine(refineUsageTimeRange) + .openapi("ListModelUsageRequest"); + +export const ListToolUsageRequestSchema = z + .object({ + scope: UsageScopeSchema, + time_range: UsageTimeRangeSchema.optional(), + source: z + .enum(["builtin", "mcp", "custom"]) + .nullish() + .describe("Exact tool source; omitted/null means all sources."), + tool_name: z.string().nullish().describe("Exact tool name; omitted/null means all tools."), + ...usagePagination, + sort_by: z.enum(["call_count", "failed_count"]).default("call_count"), + }) + .superRefine(refineUsageTimeRange) + .openapi("ListToolUsageRequest"); + +export const UsageTokenStatsSchema = z + .object({ + input_tokens: z.number().int(), + output_tokens: z.number().int(), + cache_read_tokens: z.number().int(), + cache_creation_tokens: z.number().int(), + total_tokens: z.number().int(), + cache_hit_ratio: z.number(), + }) + .openapi("UsageTokenStats"); + +export const ModelUsageItemSchema = z + .object({ + workspace_id: z.string(), + model_name: z.string(), + call_count: z.number().int(), + failed_count: z.number().int(), + tokens: UsageTokenStatsSchema, + }) + .openapi("ModelUsageItem"); + +export const ToolUsageItemSchema = z + .object({ + workspace_id: z.string(), + tool_name: z.string(), + source: z.string().describe("builtin | mcp | custom; unknown future values are preserved verbatim."), + call_count: z.number().int(), + failed_count: z.number().int(), + }) + .openapi("ToolUsageItem"); + +// Header totals ride on the aggregates: token columns sum items[].tokens, the call +// total is total_call_count, and the paging count is total. No matches → empty items +// with zeroed totals. +export const ModelUsagePageSchema = z + .object({ + items: z.array(ModelUsageItemSchema), + total: z.number().int().describe("Total rows across all pages."), + total_call_count: z.number().int().describe("Total calls across all pages."), + page_no: z.number().int(), + page_size: z.number().int(), + data_updated_at: z.number().int().describe("Data freshness, Unix epoch milliseconds."), + }) + .openapi("ModelUsagePage"); + +export const ToolUsagePageSchema = z + .object({ + items: z.array(ToolUsageItemSchema), + total: z.number().int().describe("Total rows across all pages."), + total_call_count: z.number().int().describe("Total calls across all pages."), + page_no: z.number().int(), + page_size: z.number().int(), + data_updated_at: z.number().int().describe("Data freshness, Unix epoch milliseconds."), + }) + .openapi("ToolUsagePage"); diff --git a/apps/server/tests/usage-route.test.ts b/apps/server/tests/usage-route.test.ts new file mode 100644 index 0000000..25ba8d2 --- /dev/null +++ b/apps/server/tests/usage-route.test.ts @@ -0,0 +1,112 @@ +import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"; +import { mkdtemp, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { setDefaultFetch } from "@openagentpack/sdk"; +import { initializeDirectoryProject } from "@openagentpack/sdk/project-workspace"; +import { app } from "@/app"; +import { ProjectRuntimeManager, projectRuntimeManager } from "@/services/project-manager"; + +const environmentKeys = [ + "DASHSCOPE_API_KEY", + "BAILIAN_API_KEY", + "BAILIAN_BASE_URL", + "BAILIAN_WORKSPACE_ID", + "AGENTS_PROVIDER", + "AGENTS_PLAYGROUND_TOKEN", +] as const; +let originalEnvironment: Map; +let directory: string; +let manager: ProjectRuntimeManager; +const spies: Array<{ mockRestore(): void }> = []; +const page = { items: [], total: 0, total_call_count: 0, page_no: 1, page_size: 20, data_updated_at: 0 }; + +beforeEach(async () => { + originalEnvironment = new Map(environmentKeys.map((key) => [key, process.env[key]])); + for (const key of environmentKeys) delete process.env[key]; + directory = await mkdtemp(join(tmpdir(), "openagentpack-usage-route-")); + await initializeDirectoryProject({ projectRoot: directory }); + await writeFile( + join(directory, ".env"), + "DASHSCOPE_API_KEY=project-test-key\nBAILIAN_BASE_URL=https://project-provider.test/api/v1/agentstudio\n", + ); + manager = new ProjectRuntimeManager(directory); + await manager.ensureStarted(); + expect(manager.getSnapshot().status).toBe("valid"); + spies.push( + spyOn(projectRuntimeManager, "ensureStarted").mockImplementation(() => manager.ensureStarted()), + spyOn(projectRuntimeManager, "requireRuntimeInput").mockImplementation(() => manager.requireRuntimeInput()), + ); +}); + +afterEach(async () => { + for (const spy of spies.splice(0)) spy.mockRestore(); + manager?.close(); + setDefaultFetch(undefined); + for (const [key, value] of originalEnvironment) { + if (value === undefined) delete process.env[key]; + else process.env[key] = value; + } + if (directory) await rm(directory, { recursive: true, force: true }); +}); + +function usageRequest(path: string) { + return app.request(path, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ scope: { type: "session", session_id: "test-session" } }), + }); +} + +describe("Workbench usage Provider selection", () => { + for (const [resource, processCredentials] of [ + ["models", false], + ["tools", true], + ] as const) { + test(`${resource} uses project-local credentials when process credentials are ${processCredentials ? "different" : "absent"}`, async () => { + if (processCredentials) { + process.env.DASHSCOPE_API_KEY = "environment-test-key"; + process.env.BAILIAN_BASE_URL = "https://environment-provider.test/api/v1/agentstudio"; + process.env.AGENTS_PROVIDER = "claude"; + } + const calls: Array<{ url: string; authorization: string | null }> = []; + setDefaultFetch(async (input, init) => { + calls.push({ + url: input instanceof Request ? input.url : input.toString(), + authorization: new Headers(init?.headers).get("Authorization"), + }); + return Response.json({ data: page }); + }); + + const response = await usageRequest(`/api/usage/${resource}`); + + expect(response.status).toBe(200); + expect(await response.json()).toEqual(page); + expect(calls).toEqual([ + { + url: `https://project-provider.test/api/v1/agentstudio/usage/${resource}`, + authorization: "Bearer project-test-key", + }, + ]); + }); + } + + test("rejects a missing project instead of querying with process credentials", async () => { + await rm(join(directory, "project.json")); + await manager.refreshAfterSourceMutation(); + expect(manager.getSnapshot().status).toBe("missing"); + process.env.DASHSCOPE_API_KEY = "environment-test-key"; + process.env.BAILIAN_BASE_URL = "https://environment-provider.test/api/v1/agentstudio"; + let requests = 0; + setDefaultFetch(async () => { + requests += 1; + return Response.json({ data: page }); + }); + + const response = await usageRequest("/api/usage/models"); + + expect(response.status).toBe(422); + expect(await response.json()).toMatchObject({ error: { message: expect.stringContaining("missing") } }); + expect(requests).toBe(0); + }); +}); diff --git a/apps/webui/package.json b/apps/webui/package.json index c68a513..f8a52b4 100644 --- a/apps/webui/package.json +++ b/apps/webui/package.json @@ -41,6 +41,6 @@ "@vitejs/plugin-react": "^6.0.3", "openapi-typescript": "^7.13.0", "typescript": "^6.0.3", - "vite": "^8.1.4" + "vite": "^8.1.6" } } diff --git a/apps/webui/src/lib/api/generated/schema.d.ts b/apps/webui/src/lib/api/generated/schema.d.ts index 4623aa2..d1746ca 100644 --- a/apps/webui/src/lib/api/generated/schema.d.ts +++ b/apps/webui/src/lib/api/generated/schema.d.ts @@ -2765,6 +2765,38 @@ export interface paths { patch?: never; trace?: never; }; + "/api/usage/models": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["listModelUsage"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/usage/tools": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["listToolUsage"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; } export type webhooks = Record; export interface components { @@ -3461,6 +3493,145 @@ export interface components { result?: unknown; error?: string; }; + ModelUsagePage: { + items: components["schemas"]["ModelUsageItem"][]; + /** @description Total rows across all pages. */ + total: number; + /** @description Total calls across all pages. */ + total_call_count: number; + page_no: number; + page_size: number; + /** @description Data freshness, Unix epoch milliseconds. */ + data_updated_at: number; + }; + ModelUsageItem: { + workspace_id: string; + model_name: string; + call_count: number; + failed_count: number; + tokens: components["schemas"]["UsageTokenStats"]; + }; + UsageTokenStats: { + input_tokens: number; + output_tokens: number; + cache_read_tokens: number; + cache_creation_tokens: number; + total_tokens: number; + cache_hit_ratio: number; + }; + ListModelUsageRequest: { + scope: components["schemas"]["UsageScope"]; + time_range?: components["schemas"]["UsageTimeRange"]; + /** @description Exact model name; omitted/null means all models. */ + model_name?: string | null; + /** + * @description 1-based page number. + * @default 1 + */ + page_no: number; + /** + * @description Page size, 1..100. + * @default 20 + */ + page_size: number; + /** + * @default desc + * @enum {string} + */ + sort_order: "asc" | "desc"; + /** + * @default call_count + * @enum {string} + */ + sort_by: "call_count" | "failed_count" | "input_tokens" | "output_tokens"; + }; + UsageScope: + | { + /** + * @description Aggregated usage across the listed workspaces. + * @enum {string} + */ + type: "workspace"; + /** @description Workspaces to aggregate; at least one is required. */ + workspace_ids: string[]; + /** @description Narrow the workspace aggregation to one Agent. */ + agent_id?: string; + } + | { + /** + * @description Usage of one Agent (optionally a pinned version). + * @enum {string} + */ + type: "agent"; + agent_id: string; + /** @description Optional single-workspace pin; omit to use the caller's identity workspace. */ + workspace_ids?: string[]; + agent_version?: string; + } + | { + /** + * @description Usage within one Session; its own window applies. + * @enum {string} + */ + type: "session"; + session_id: string; + }; + UsageTimeRange: { + /** @description Window start, Unix epoch milliseconds. */ + start_time: number; + /** @description Window end, Unix epoch milliseconds. */ + end_time: number; + }; + ToolUsagePage: { + items: components["schemas"]["ToolUsageItem"][]; + /** @description Total rows across all pages. */ + total: number; + /** @description Total calls across all pages. */ + total_call_count: number; + page_no: number; + page_size: number; + /** @description Data freshness, Unix epoch milliseconds. */ + data_updated_at: number; + }; + ToolUsageItem: { + workspace_id: string; + tool_name: string; + /** @description builtin | mcp | custom; unknown future values are preserved verbatim. */ + source: string; + call_count: number; + failed_count: number; + }; + ListToolUsageRequest: { + scope: components["schemas"]["UsageScope"]; + time_range?: components["schemas"]["UsageTimeRange"]; + /** + * @description Exact tool source; omitted/null means all sources. + * @enum {string|null} + */ + source?: "builtin" | "mcp" | "custom" | null; + /** @description Exact tool name; omitted/null means all tools. */ + tool_name?: string | null; + /** + * @description 1-based page number. + * @default 1 + */ + page_no: number; + /** + * @description Page size, 1..100. + * @default 20 + */ + page_size: number; + /** + * @default desc + * @enum {string} + */ + sort_order: "asc" | "desc"; + /** + * @default call_count + * @enum {string} + */ + sort_by: "call_count" | "failed_count"; + }; }; responses: never; parameters: never; @@ -3469,4 +3640,161 @@ export interface components { pathItems: never; } export type $defs = Record; -export type operations = Record; +export interface operations { + listModelUsage: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["ListModelUsageRequest"]; + }; + }; + responses: { + /** @description Paged aggregated model usage for the requested scope */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelUsagePage"]; + }; + }; + /** @description Bad request */ + 400: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Forbidden */ + 403: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Not found */ + 404: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Conflict */ + 409: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Unprocessable entity */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Server error */ + 500: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + }; + }; + listToolUsage: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["ListToolUsageRequest"]; + }; + }; + responses: { + /** @description Paged aggregated tool usage for the requested scope */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ToolUsagePage"]; + }; + }; + /** @description Bad request */ + 400: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Forbidden */ + 403: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Not found */ + 404: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Conflict */ + 409: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Unprocessable entity */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + /** @description Server error */ + 500: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorResponse"]; + }; + }; + }; + }; +} diff --git a/apps/webui/tests/openapi-remote.test.ts b/apps/webui/tests/openapi-remote.test.ts new file mode 100644 index 0000000..88f25d2 --- /dev/null +++ b/apps/webui/tests/openapi-remote.test.ts @@ -0,0 +1,42 @@ +import { expect, test } from "bun:test"; +import { createRequire } from "node:module"; +import openapiTS, { astToString } from "openapi-typescript"; + +const require = createRequire(import.meta.url); +const requireOpenapi = createRequire(require.resolve("openapi-typescript")); +const { createConfig } = requireOpenapi("@redocly/openapi-core"); + +test("OpenAPI generation applies matching HTTP headers to a remote schema", async () => { + const calls: Array<{ url: string; headers: Headers }> = []; + const redocly = await createConfig({ + resolve: { + http: { + headers: [ + { matches: "https://schema.test/**", name: "Authorization", value: "Bearer schema-test-key" }, + { matches: "https://other.test/**", name: "X-Other-Key", value: "other-test-key" }, + ], + }, + }, + }); + redocly.resolve.http.customFetch = async (url: string, init?: RequestInit) => { + calls.push({ url, headers: new Headers(init?.headers) }); + return Response.json({ + openapi: "3.0.0", + info: { title: "Remote schema", version: "1.0.0" }, + paths: {}, + components: { + schemas: { + User: { type: "object", required: ["name"], properties: { name: { type: "string" } } }, + }, + }, + }); + }; + + const output = astToString(await openapiTS(new URL("https://schema.test/openapi.json"), { redocly })); + + expect(calls).toHaveLength(1); + expect(calls[0]?.url).toBe("https://schema.test/openapi.json"); + expect(calls[0]?.headers.get("Authorization")).toBe("Bearer schema-test-key"); + expect(calls[0]?.headers.has("X-Other-Key")).toBe(false); + expect(output).toContain("name: string"); +}); diff --git a/bun.lock b/bun.lock index 96f8474..a04271a 100644 --- a/bun.lock +++ b/bun.lock @@ -1,12 +1,12 @@ { - "lockfileVersion": 1, + "lockfileVersion": 2, "configVersion": 1, "workspaces": { "": { "name": "openagentpack-workspace", "devDependencies": { "@ast-grep/cli": "^0.44.1", - "@biomejs/biome": "^2.5.3", + "@biomejs/biome": "2.5.3", "@changesets/cli": "^2.31.0", "@types/bun": "^1.3.14", "braces": "file:vendor/braces", @@ -23,7 +23,7 @@ "@hono/zod-openapi": "^1.4.0", "@openagentpack/sdk": "workspace:*", "chokidar": "^4.0.3", - "hono": "^4.13.5", + "hono": "^4.13.11", "yaml": "^2.9.0", }, "devDependencies": { @@ -63,7 +63,7 @@ "@vitejs/plugin-react": "^6.0.3", "openapi-typescript": "^7.13.0", "typescript": "^6.0.3", - "vite": "^8.1.4", + "vite": "^8.1.6", }, }, "packages/cli": { @@ -100,13 +100,13 @@ "agents-playground": "dist/bin/playground.js", }, "dependencies": { - "@hono/node-server": "^2.0.5", + "@hono/node-server": "^2.1.6", "@hono/zod-openapi": "^1.4.0", "@openagentpack/sdk": "workspace:*", "chokidar": "^4.0.3", - "hono": "^4.13.5", + "hono": "^4.13.11", "yaml": "^2.9.0", - "zod": "^4.4.3", + "zod": "^4.6.6", }, "devDependencies": { "@openagentpack/server": "workspace:*", @@ -122,7 +122,7 @@ "dependencies": { "jszip": "^3.10.1", "yaml": "^2.9.0", - "zod": "^4.4.3", + "zod": "^4.6.6", }, "devDependencies": { "@types/bun": "^1.3.14", @@ -133,6 +133,9 @@ "trustedDependencies": [ "@ast-grep/cli", ], + "patchedDependencies": { + "@redocly/openapi-core@1.34.22": "patches/@redocly%2Fopenapi-core@1.34.22.patch", + }, "overrides": { "@tiptap/extension-bubble-menu": "3.30.5", "@tiptap/extension-floating-menu": "3.30.5", @@ -141,6 +144,7 @@ "esbuild": "0.28.1", "fast-equals": "5.3.3", "js-yaml": "4.3.2", + "minimatch": "11.0.3", "nanoid": "3.3.18", "postcss": "8.5.23", "prosemirror-model": "1.25.11", @@ -148,15 +152,15 @@ "source-map-js": "1.2.2", }, "packages": { - "@ast-grep/cli": ["@ast-grep/cli@0.44.1", "", { "dependencies": { "detect-libc": "2.1.2" }, "optionalDependencies": { "@ast-grep/cli-darwin-arm64": "0.44.1", "@ast-grep/cli-darwin-x64": "0.44.1", "@ast-grep/cli-linux-arm64-gnu": "0.44.1", "@ast-grep/cli-linux-x64-gnu": "0.44.1", "@ast-grep/cli-win32-arm64-msvc": "0.44.1", "@ast-grep/cli-win32-ia32-msvc": "0.44.1", "@ast-grep/cli-win32-x64-msvc": "0.44.1" }, "bin": { "sg": "sg", "ast-grep": "ast-grep" } }, "sha512-wSjtu0/9xSYzzo/EW31w5pf1qB33tejYKmKXb2nBAlZ5PpYtOqwFmk9H1nywhjzO913beugsKAZYxrwciqW9AQ=="], + "@ast-grep/cli": ["@ast-grep/cli@0.44.1", "", { "dependencies": { "detect-libc": "2.1.2" }, "optionalDependencies": { "@ast-grep/cli-darwin-arm64": "0.44.1", "@ast-grep/cli-darwin-x64": "0.44.1", "@ast-grep/cli-linux-arm64-gnu": "0.44.1", "@ast-grep/cli-linux-x64-gnu": "0.44.1", "@ast-grep/cli-win32-arm64-msvc": "0.44.1", "@ast-grep/cli-win32-ia32-msvc": "0.44.1", "@ast-grep/cli-win32-x64-msvc": "0.44.1" }, "hasInstallScript": true, "bin": { "sg": "sg", "ast-grep": "ast-grep" } }, "sha512-wSjtu0/9xSYzzo/EW31w5pf1qB33tejYKmKXb2nBAlZ5PpYtOqwFmk9H1nywhjzO913beugsKAZYxrwciqW9AQ=="], "@ast-grep/cli-darwin-arm64": ["@ast-grep/cli-darwin-arm64@0.44.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wOzb+IqFy4Pdhvs+PeaHdQJ1VemsI1SgoOGJf+x0J0KBSJ+s/hUg2n1fVJwfsrw/XDIbz9m7PGKTGCLxsgYa1g=="], "@ast-grep/cli-darwin-x64": ["@ast-grep/cli-darwin-x64@0.44.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-X3OzzsnO9Q3ISQ4qO3jasWk8EZhJA03xfmJHhuS9rGJZZCbNEuqjicrwrDMKK8EgEGJ7MG4oL0BE5qUcn3twLw=="], - "@ast-grep/cli-linux-arm64-gnu": ["@ast-grep/cli-linux-arm64-gnu@0.44.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-2F1YBRd9tQnfrGX+4BlkfXWLb2jqNgTmjp0ETLNRLMmSDinR905QsZn2A55qcAZxhQDU982mEzzgT4NduPXIGg=="], + "@ast-grep/cli-linux-arm64-gnu": ["@ast-grep/cli-linux-arm64-gnu@0.44.1", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-2F1YBRd9tQnfrGX+4BlkfXWLb2jqNgTmjp0ETLNRLMmSDinR905QsZn2A55qcAZxhQDU982mEzzgT4NduPXIGg=="], - "@ast-grep/cli-linux-x64-gnu": ["@ast-grep/cli-linux-x64-gnu@0.44.1", "", { "os": "linux", "cpu": "x64" }, "sha512-d5UNoDLT2i6xV4GGqcPnrAR6CB3H078+v3BiqjKxZdZMHFnDe46+i+DxfH1IK6yvJqViqv2F611+wiAAn/s7qw=="], + "@ast-grep/cli-linux-x64-gnu": ["@ast-grep/cli-linux-x64-gnu@0.44.1", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-d5UNoDLT2i6xV4GGqcPnrAR6CB3H078+v3BiqjKxZdZMHFnDe46+i+DxfH1IK6yvJqViqv2F611+wiAAn/s7qw=="], "@ast-grep/cli-win32-arm64-msvc": ["@ast-grep/cli-win32-arm64-msvc@0.44.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-r6K49Z14BLOeJdBSmaoK+TdgtPRqJfJ562F0n0KvRi0qH3o8is8N2dXtEMYKynYm/tdOd65i69Mc1WKSuIeWyA=="], @@ -164,13 +168,13 @@ "@ast-grep/cli-win32-x64-msvc": ["@ast-grep/cli-win32-x64-msvc@0.44.1", "", { "os": "win32", "cpu": "x64" }, "sha512-gDMHT17Edmp/tXTDdMSQHd9vJki2Y2WSXq9ycrvjziHwpmnsnc6xlCQ7SEOGA1987vepSpkOkqBCPliP2TVW0w=="], - "@asteasolutions/zod-to-openapi": ["@asteasolutions/zod-to-openapi@8.5.0", "", { "dependencies": { "openapi3-ts": "^4.1.2" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-SABbKiObg5dLRiTFnqiW1WWwGcg1BJfmHtT2asIBnBHg6Smy/Ms2KHc650+JI4Hw7lSkdiNebEGXpwoxfben8Q=="], + "@asteasolutions/zod-to-openapi": ["@asteasolutions/zod-to-openapi@9.1.0", "", { "dependencies": { "openapi3-ts": "^4.6.0" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-pLMeRgRYS7/vZIgAAkOe2P6+XGTifR1MT9pqDoxZ11EmcJJ+DPmdPqLN8ZZF4U8R9KHCCQCS9c2wtuE8wSrfkw=="], "@babel/code-frame": ["@babel/code-frame@7.29.7", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.29.7", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw=="], "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.29.7", "", {}, "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg=="], - "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="], + "@babel/runtime": ["@babel/runtime@7.29.10", "", {}, "sha512-NpugTzbKgGrNe45Ui32cN8vCFFMxVtP/9rtfwv0nP5FRDAjvYBxJcLVpYA9mr1jxP6cnIT7x9LUzuDTbWYYNRA=="], "@biomejs/biome": ["@biomejs/biome@2.5.3", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.3", "@biomejs/cli-darwin-x64": "2.5.3", "@biomejs/cli-linux-arm64": "2.5.3", "@biomejs/cli-linux-arm64-musl": "2.5.3", "@biomejs/cli-linux-x64": "2.5.3", "@biomejs/cli-linux-x64-musl": "2.5.3", "@biomejs/cli-win32-arm64": "2.5.3", "@biomejs/cli-win32-x64": "2.5.3" }, "bin": { "biome": "bin/biome" } }, "sha512-MrJswFdei9EfDwwUy2tQrPDpK0AO+RmMFvBoaaJ6ayBc3sUbHdCE+XG5N8vp+5So41ZupZJQm0roHFFhMGVD7A=="], @@ -178,13 +182,13 @@ "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-NC1Ss13UaW7QZX+y8j44bF7AP0jSJdBl6iRhe0MAkvaSqZy+mWg3GaXsrb+eSoHoGDBtaXWEbMVV0iVN2cZ7cQ=="], - "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-ksx1KWeyYW18ILL04msF/J4ZBtBDN33znYK8Z/aNv/vlBVxL9/g3mGP+omgHJKy4+KWbK87vcmmpmurfNjSgiA=="], + "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.3", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-ksx1KWeyYW18ILL04msF/J4ZBtBDN33znYK8Z/aNv/vlBVxL9/g3mGP+omgHJKy4+KWbK87vcmmpmurfNjSgiA=="], - "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-fccix0w6xp6csCXgxeC0dU/3ecgRQal0y+cv2SP9ajNlhe7Yrk2Ug7UDe2j9AT9ZDYitkXpvUKgZjjuoYeP4Vg=="], + "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.3", "", { "os": "linux", "cpu": "arm64", "libc": "musl" }, "sha512-fccix0w6xp6csCXgxeC0dU/3ecgRQal0y+cv2SP9ajNlhe7Yrk2Ug7UDe2j9AT9ZDYitkXpvUKgZjjuoYeP4Vg=="], - "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.3", "", { "os": "linux", "cpu": "x64" }, "sha512-yMkJtilsgvILDcVkh187aVLTb64xYsrxYajx5kym+r1ULkO5HUOfu9AYKLGQbOVLwJtT2utNw7hhFNg+17mUYA=="], + "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.3", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-yMkJtilsgvILDcVkh187aVLTb64xYsrxYajx5kym+r1ULkO5HUOfu9AYKLGQbOVLwJtT2utNw7hhFNg+17mUYA=="], - "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.3", "", { "os": "linux", "cpu": "x64" }, "sha512-O/yU9YKRUiHhmcjF2f38PSjseVk3G4VLWYc0G2HWpzdBVREV6G8IGWIVEFf7MFPfWIzNUIvPsEjeAZQIOgnLcQ=="], + "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.3", "", { "os": "linux", "cpu": "x64", "libc": "musl" }, "sha512-O/yU9YKRUiHhmcjF2f38PSjseVk3G4VLWYc0G2HWpzdBVREV6G8IGWIVEFf7MFPfWIzNUIvPsEjeAZQIOgnLcQ=="], "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.3", "", { "os": "win32", "cpu": "arm64" }, "sha512-cX5z+GYwRcqEok0AH3KSfQGgqYd0Nomfp6Fbe1uiTtELE38hdH2k842wQ9wLNaF/JJ7r4rjJQ4VR+ce+fRmQbw=="], @@ -196,7 +200,7 @@ "@changesets/changelog-git": ["@changesets/changelog-git@0.2.1", "", { "dependencies": { "@changesets/types": "^6.1.0" } }, "sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q=="], - "@changesets/cli": ["@changesets/cli@2.31.0", "", { "dependencies": { "@changesets/apply-release-plan": "^7.1.1", "@changesets/assemble-release-plan": "^6.0.10", "@changesets/changelog-git": "^0.2.1", "@changesets/config": "^3.1.4", "@changesets/errors": "^0.2.0", "@changesets/get-dependents-graph": "^2.1.4", "@changesets/get-release-plan": "^4.0.16", "@changesets/git": "^3.0.4", "@changesets/logger": "^0.1.1", "@changesets/pre": "^2.0.2", "@changesets/read": "^0.6.7", "@changesets/should-skip-package": "^0.1.2", "@changesets/types": "^6.1.0", "@changesets/write": "^0.4.0", "@inquirer/external-editor": "^1.0.2", "@manypkg/get-packages": "^1.1.3", "ansi-colors": "^4.1.3", "enquirer": "^2.4.1", "fs-extra": "^7.0.1", "mri": "^1.2.0", "package-manager-detector": "^0.2.0", "picocolors": "^1.1.0", "resolve-from": "^5.0.0", "semver": "^7.5.3", "spawndamnit": "^3.0.1", "term-size": "^2.1.0" }, "bin": { "changeset": "bin.js" } }, "sha512-AhI4enNTgHu2IZr6K4WZyf0EPch4XVMn1yOMFmCD9gsfBGqMYaHXls5HyDv6/CL5axVQABz68eG30eCtbr2wFg=="], + "@changesets/cli": ["@changesets/cli@2.31.1", "", { "dependencies": { "@changesets/apply-release-plan": "^7.1.1", "@changesets/assemble-release-plan": "^6.0.10", "@changesets/changelog-git": "^0.2.1", "@changesets/config": "^3.1.4", "@changesets/errors": "^0.2.0", "@changesets/get-dependents-graph": "^2.1.4", "@changesets/get-release-plan": "^4.0.16", "@changesets/git": "^3.0.4", "@changesets/logger": "^0.1.1", "@changesets/pre": "^2.0.2", "@changesets/read": "^0.6.7", "@changesets/should-skip-package": "^0.1.2", "@changesets/types": "^6.1.0", "@changesets/write": "^0.4.0", "@inquirer/external-editor": "^1.0.2", "@manypkg/get-packages": "^1.1.3", "ansi-colors": "^4.1.3", "enquirer": "^2.4.1", "fs-extra": "^7.0.1", "mri": "^1.2.0", "package-manager-detector": "^0.2.0", "picocolors": "^1.1.0", "resolve-from": "^5.0.0", "semver": "^7.5.3", "spawndamnit": "^3.0.1", "term-size": "^2.1.0" }, "bin": { "changeset": "bin.js" } }, "sha512-uO05WTcRBwuVOJVSW8Cmpqw6q0WDL53ajGCMyszutvOe5toOnunbpM4jZzf+qxBOz7i0AzopZ8diBuewjmF40w=="], "@changesets/config": ["@changesets/config@3.1.4", "", { "dependencies": { "@changesets/errors": "^0.2.0", "@changesets/get-dependents-graph": "^2.1.4", "@changesets/logger": "^0.1.1", "@changesets/should-skip-package": "^0.1.2", "@changesets/types": "^6.1.0", "@manypkg/get-packages": "^1.1.3", "fs-extra": "^7.0.1", "micromatch": "^4.0.8" } }, "sha512-pf0bvD/v6WI2cRlZ6hzpjtZdSlXDXMAJ+Iz7xfFzV4ZxJ8OGGAON+1qYc99ZPrijnt4xp3VGG7eNvAOGS24V1Q=="], @@ -224,15 +228,9 @@ "@changesets/write": ["@changesets/write@0.4.0", "", { "dependencies": { "@changesets/types": "^6.1.0", "fs-extra": "^7.0.1", "human-id": "^4.1.1", "prettier": "^2.7.1" } }, "sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q=="], - "@clack/core": ["@clack/core@1.4.3", "", { "dependencies": { "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-/kr3UWNtdJfxZtPgDqUOmG2pvwlmcLGheex5yiZKdwbzZJxhV+HMNR9QNmyY5cGwTNV6LrR7Jtp+KjhUAP1qBQ=="], - - "@clack/prompts": ["@clack/prompts@1.7.0", "", { "dependencies": { "@clack/core": "1.4.3", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-y7/yvZ2TPAnR9+jnc00klvNNLkJiXFFrQA/hlLCcxA9a2A4zQIOimyFQ9XfwYKiGD1fb5GY8vbKIIgO8d5Tb2A=="], - - "@emnapi/core": ["@emnapi/core@1.11.1", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.2", "tslib": "^2.4.0" } }, "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ=="], + "@clack/core": ["@clack/core@1.5.1", "", { "dependencies": { "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-iHTrHA8MtVuLl2TfZySmcKv1qO2PoyC9Z7pfSDozEuV5vtY3/wcOPKJXlqJ5Oq2Cx5DDGQGAMVx6HZfRRoVEbQ=="], - "@emnapi/runtime": ["@emnapi/runtime@1.11.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw=="], - - "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA=="], + "@clack/prompts": ["@clack/prompts@1.8.1", "", { "dependencies": { "@clack/core": "1.5.1", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-dlT1m5e/0yUL0kRNcQn7yGLVThkgbB0Ga/1AmfDDC/8ik6AIiSf2QLQO2zPYvefsHP0aFgxO93cVLCCfDp7kzQ=="], "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.28.1", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ=="], @@ -286,25 +284,27 @@ "@esbuild/win32-x64": ["@esbuild/win32-x64@0.28.1", "", { "os": "win32", "cpu": "x64" }, "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A=="], - "@floating-ui/core": ["@floating-ui/core@1.7.5", "", { "dependencies": { "@floating-ui/utils": "^0.2.11" } }, "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ=="], + "@floating-ui/core": ["@floating-ui/core@1.8.0", "", { "dependencies": { "@floating-ui/utils": "^0.2.12" } }, "sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ=="], - "@floating-ui/dom": ["@floating-ui/dom@1.7.6", "", { "dependencies": { "@floating-ui/core": "^1.7.5", "@floating-ui/utils": "^0.2.11" } }, "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ=="], + "@floating-ui/dom": ["@floating-ui/dom@1.8.0", "", { "dependencies": { "@floating-ui/core": "^1.8.0", "@floating-ui/utils": "^0.2.12" } }, "sha512-yXSrzeHZBTZadLOlfyhCkJHNeLJnHRnRInwdZ40L7ZiaAtrBwoYlsDrX3v5zB1Utk7CLfzcOVnVVWoXEky7Ceg=="], - "@floating-ui/utils": ["@floating-ui/utils@0.2.11", "", {}, "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg=="], + "@floating-ui/utils": ["@floating-ui/utils@0.2.12", "", {}, "sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww=="], - "@hono/node-server": ["@hono/node-server@2.0.11", "", { "peerDependencies": { "hono": "^4" } }, "sha512-bjD221KPLoJTWUwso1J6fGKiTXEUFedG/s0visavY4zakFPkeGURMRNly+FhBHs7T8Dz4qHaZIMX9ZoJHSJtKA=="], + "@hono/node-server": ["@hono/node-server@2.1.6", "", { "peerDependencies": { "hono": "^4 || ^5.0.0-0" } }, "sha512-p/KH9MnfNcsm3sR6x4lNgm5j+QN4Et8srKredl9DZfXiyZ1UQ3aQ2YVpFLbqktYN5JI+DB+VZFKM2PqE5hLKjQ=="], - "@hono/zod-openapi": ["@hono/zod-openapi@1.4.0", "", { "dependencies": { "@asteasolutions/zod-to-openapi": "^8.5.0", "@hono/zod-validator": "^0.8.0", "openapi3-ts": "^4.5.0" }, "peerDependencies": { "hono": ">=4.10.0", "zod": "^4.0.0" } }, "sha512-AFchqR1N/NxfI4hUOSGI2/g8zLROxA1OE7Oh5JJFlTaGxhrdRyH+93gd0tIBpb0z8s9r8hUoNnaOBfHbdb4NMw=="], + "@hono/zod-openapi": ["@hono/zod-openapi@1.6.3", "", { "dependencies": { "@asteasolutions/zod-to-openapi": "^9.1.0", "@hono/zod-validator": "^0.9.1", "openapi3-ts": "^4.5.0" }, "peerDependencies": { "hono": ">=4.10.0", "zod": "^4.0.0" } }, "sha512-VYR82Y60plu8g3pN60OUXMVKpmxh3R04Qs++3DY9vtwZ9/sA/BRY0PcRIR+Z37/3itWtM7pYwT9bKiH9JhqV6Q=="], - "@hono/zod-validator": ["@hono/zod-validator@0.8.0", "", { "peerDependencies": { "hono": ">=4.10.0", "zod": "^3.25.0 || ^4.0.0" } }, "sha512-5uS4S1/LKtZQYvD4BtpPUFkOv8d1wNxHHrChm26buMiEYc1FrHWvDUaKVBwkiVtvSExHSpLGDvcnpI2Copyj9w=="], + "@hono/zod-validator": ["@hono/zod-validator@0.9.1", "", { "peerDependencies": { "hono": ">=4.11.2", "zod": "^3.25.0 || ^4.0.0" } }, "sha512-iiv6w0qrIc0arfvCtUqBWsvl4fXjzaTcQcCJTTtCnkawF9HHGE+KjEl0ox3gQJ6rKZEgE3mLExlQCF72M+mNuw=="], "@inquirer/external-editor": ["@inquirer/external-editor@1.0.3", "", { "dependencies": { "chardet": "^2.1.1", "iconv-lite": "^0.7.0" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA=="], + "@isaacs/nonrecursive-glob-match": ["@isaacs/nonrecursive-glob-match@1.0.3", "", {}, "sha512-SI7kyKHq4XXDRozw+r9GlRZkia1ZkFrpLW98r2IC2Bpr8YkFGE3fvjzmxCG0x78A++69HmDNrDvSMYBZmHGpKA=="], + "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="], "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="], - "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="], + "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.6.0", "", {}, "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw=="], "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], @@ -312,7 +312,7 @@ "@manypkg/get-packages": ["@manypkg/get-packages@1.1.3", "", { "dependencies": { "@babel/runtime": "^7.5.5", "@changesets/types": "^4.0.1", "@manypkg/find-root": "^1.1.0", "fs-extra": "^8.1.0", "globby": "^11.0.0", "read-yaml-file": "^1.1.0" } }, "sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A=="], - "@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.6", "", { "dependencies": { "@tybys/wasm-util": "^0.10.3" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" } }, "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg=="], + "@napi-rs/lzma-linux-x64-gnu": ["@napi-rs/lzma-linux-x64-gnu@1.5.1", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ=="], "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="], @@ -330,95 +330,97 @@ "@openagentpack/server": ["@openagentpack/server@workspace:apps/server"], - "@oxc-project/types": ["@oxc-project/types@0.139.0", "", {}, "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw=="], + "@oxc-project/types": ["@oxc-project/types@0.156.0", "", {}, "sha512-1Duyg48TdJNdyhEB8Xn1L36bT9Pv6GUtlKjHxOys8xkaF/rQq3XJE+bAurSK/AgIz5mGFsb77cn9Pb20+WCScw=="], "@redocly/ajv": ["@redocly/ajv@8.11.2", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2", "uri-js-replace": "^1.0.1" } }, "sha512-io1JpnwtIcvojV7QKDUSIuMN/ikdOUd1ReEnUnMKGfDVridQZ31J0MmIuqwuRjWDZfmvr+Q0MqCcfHM2gTivOg=="], "@redocly/config": ["@redocly/config@0.22.0", "", {}, "sha512-gAy93Ddo01Z3bHuVdPWfCwzgfaYgMdaZPcfL7JZ7hWJoK9V0lXDbigTWkhiPFAaLWzbOJ+kbUQG1+XwIm0KRGQ=="], - "@redocly/openapi-core": ["@redocly/openapi-core@1.34.17", "", { "dependencies": { "@redocly/ajv": "8.11.2", "@redocly/config": "0.22.0", "colorette": "1.4.0", "https-proxy-agent": "7.0.6", "js-levenshtein": "1.1.6", "js-yaml": "4.2.0", "minimatch": "5.1.9", "pluralize": "8.0.0", "yaml-ast-parser": "0.0.43" } }, "sha512-wsV2keCt6B806XpSdezbWZ9aFJYf14YVh+XQf0ESt7M90yqVuxH9//PxvtC70sgj9OCkRM3nRaLfu4MsGQZRig=="], + "@redocly/openapi-core": ["@redocly/openapi-core@1.34.22", "", { "dependencies": { "@redocly/ajv": "8.11.2", "@redocly/config": "0.22.0", "colorette": "1.4.0", "https-proxy-agent": "7.0.6", "js-levenshtein": "1.1.6", "js-yaml": "4.3.2", "minimatch": "5.1.9", "pluralize": "8.0.0", "yaml-ast-parser": "0.0.43" } }, "sha512-dEyx4uHh6Pc6ZkdU9Xe8rA4h12Odq6QKU/fqseBn07xwVwskhHiF3KHhqmw5BR+jAiFTvKTmwCafFql/k1pSzA=="], - "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.1.5", "", { "os": "android", "cpu": "arm64" }, "sha512-lZg8fqIv2v7FF237bwMgzGZEJvGL79/s5knJ/i6FmsGF4XXlzccZ4jb+TrFIxtSSxFtIpdsgrPZeMk1I9AFcyQ=="], + "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.16", "", { "os": "android", "cpu": "arm" }, "sha512-ia3DwAs0OsMGS7+IConptSiyk9pEXkOx/AbJ2n/lAGxH3QkWQus1t8d7gnAT38FCU2sQu8lUbeR6AiZFv4JxaA=="], - "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.1.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-51Bnx9pNiMRKSUNtBfySkNJ9vMU9Hh3I1ozDd6gyPPYzaXCfnptUcEZxXGYFn+ul2dtcMUiqGR1Yai2K10uoTw=="], + "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.2.16", "", { "os": "android", "cpu": "arm64" }, "sha512-kx5wBiMB6E7TEvpl2B9gjLU004BkvEm2Dr941BFjx/SontPwSzNuQUIoVKxHHoSjpFIfHMmcguyLOtyn0hObRg=="], - "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.1.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-Tm+gbfC0aHu1tBA/JvKQh32S0K6YgCHkiAF4/W6xX0K0RmNuc94VeK419dJoE65R5aRxmo+noZQSWrAMF6yb6g=="], + "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.2.16", "", { "os": "darwin", "cpu": "arm64" }, "sha512-qslZrXnKJU4cUpjoAmtAo/KQM9e2IRMlmpig6Zpwj+8KWxW8v+nkAf9216Bsek9lOC1jvg2yCjygCFo2f83msQ=="], - "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.1.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-JMzDKCCXq93YccG5gz3hvOs1oXRKAf0XYpfOS88e+wZrC8Iugj6j68867vrYZkvpDDpKn/KoKORThmchMpF6TA=="], + "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.2.16", "", { "os": "darwin", "cpu": "x64" }, "sha512-FdF+y48ND13eAyM2mQn+85kvAqNlvRWROy2rhgA463X/0Gv4vGtazZtfaF1mRBLscYvtOlh4QnLjOWiFzX69OQ=="], - "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.1.5", "", { "os": "linux", "cpu": "arm" }, "sha512-uML21j2K5TfPGutKxub+M+nLjZIrWjXQ5Grx4lCe/nimTj9B4L63zHpjXLl4y0L3mcm2htEQIb06oCG/szerNw=="], + "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.2.16", "", { "os": "freebsd", "cpu": "x64" }, "sha512-ddjqFM5e95AgLbUPtKIS7V1KTVlA0RUgCVr5mn+/IEhsdy3pr+Vuj/HZ7nlMN2FyxIwUktOH1LEPIQXO1v9y1Q=="], - "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.1.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-navSiuTMogvnQoZoM/v+l3ZWo50/NTwSHSzheABx/RCnmUPaKwq9qSo4Br2OYRs21+Fz8uFqITZM3H4opOB0/Q=="], + "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.2.16", "", { "os": "linux", "cpu": "arm" }, "sha512-tHdKWbFkFBI687iim3LIyIvyL7j66VvQYkDPss5Stn/qyE2tWkR1YD0dXmXPFKKqT/o5ZEJVsaRsWS2meQwGOA=="], - "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.1.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-lAryqH7IteztmCXQXk0etKj4wBQ7Gx5S6LjKhsgp9zb8I5bsuvU/2llH1hDQcjsFeqIsovMVN339/8pUDDBXxA=="], + "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.2.16", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-FJiLGAblPBMlBEdbOqw6kW6QcXDWAf/oJu7gYs9ZJZwmg+K+/zjFLxPTIY9izJUzxzc24FHvmseyA0IvJSl17w=="], - "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.1.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-fsK/sNBnxzBlL4O1JNrZakVQxPspqpED5dLtNsZS9oOKmtSpdNIzxH2kkol5HYTWJN47sE20ztMJPxfZ89qGOg=="], + "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.2.16", "", { "os": "linux", "cpu": "arm64", "libc": "musl" }, "sha512-hrJpblMsrQ58U9veWpbXzkhV5zStunds6HWLprqq1qauvgBr1E6P+24kLj6lSLI9vjRn/RYpjprhkHQPKGWpNg=="], - "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.1.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-gLYb4BIadlfTOYT5gO503n8zQjXflgzpD0FcyKh0Mzx3rqCZKnHoJWV9xe1KXUJ5lx2JfcSHr/mhzS0PC/McAA=="], + "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.2.16", "", { "os": "linux", "cpu": "ppc64", "libc": "glibc" }, "sha512-qJd/dC6j6CwLG9/s/RP2nb1RZ0GIgj7Ioj7x/SYa3RzjVrlzrmH0fhIOpfvqQDeIsdP0loi+kHaMhJzY1PBIaA=="], - "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.1.5", "", { "os": "linux", "cpu": "x64" }, "sha512-FjcpEKUyJygHgs1o50VYNvkt5+7Le/VEdYt0AkRpkL33MnyQfwr8l5mXwMmfmTbyMPr5vJLC+8/Gd9gXnwU1QQ=="], + "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.2.16", "", { "os": "linux", "cpu": "s390x", "libc": "glibc" }, "sha512-Vx7Xg5uUJuNcujJjI70OICaH0EYj80BtOLZTSN7uOYg8QOLlyKnaG0IW7Fn/J0IpJsaKzmDKMhOQv1JBM9m9vg=="], - "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.1.5", "", { "os": "linux", "cpu": "x64" }, "sha512-Me+PfPI2TMeOQk0gYWfLQZtTktrmzbr8cDboqX83XKc7UrgAi55gF+2dUkWdxd19n55Essp2yeca+O9N5rBxHg=="], + "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.2.16", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-TNKhgE3uJTsTzatUSSYt0Kgo+Oa2uSlSjz4r1aEIea7HX6ULBym4fAlYUhG1i6pjNf2njfCUAfKwr6C3E9Xg1w=="], - "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.1.5", "", { "os": "none", "cpu": "arm64" }, "sha512-yc5WrLzXks6zCQfn9Oxr8pORKyl/pF+QjHmW/Qx3qu0oyrrNC+y2JLTU1E2rcWYAmzlnqngWXHQjy51VzW70Vw=="], + "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.2.16", "", { "os": "linux", "cpu": "x64", "libc": "musl" }, "sha512-7chXdpjXZ8qG0+mIxECN3cT9kvhZ3/oZhMX6Pp876P7CDrIy8nJswva6Mq357JR7eYXfuskwZxMeV1SzoZdHrA=="], - "@rolldown/binding-wasm32-wasi": ["@rolldown/binding-wasm32-wasi@1.1.5", "", { "dependencies": { "@emnapi/core": "1.11.1", "@emnapi/runtime": "1.11.1", "@napi-rs/wasm-runtime": "^1.1.6" }, "cpu": "none" }, "sha512-VbQGPX2b4r48TAMIM2cjgluIM1HYutm4pcTEJsle7iEP7sB1dFqtPLBVbdLAZCxy1txCcPxf4QFf4v8uvltPqA=="], + "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.2.16", "", { "os": "none", "cpu": "arm64" }, "sha512-Kwjt+7uNTJK5/MDkGWGVO2KQPnj8yAV75dMpfwyHZrJSXWHrniOB0aUEWlVYf3H1hOqFLIStLdM5QXq6bnKmOQ=="], - "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.1.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-gHv82k63z4qpV5+Q1y/12KrK0ltWBukVDI8nZcbT7Tt/ZlOIVwppazneq0F93oDxTo3IgAMEDIoQh3E2n6mVsw=="], + "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.2.16", "", { "os": "win32", "cpu": "arm64" }, "sha512-/LH6WfjDRXXJz/p5xl4TmU+jpcnwcxbKEQBW/GZE0JHfN0lGIyTtsUEGaQ/q/GikkGJ2yLKe6pwm7AnEWO8pdw=="], - "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.1.5", "", { "os": "win32", "cpu": "x64" }, "sha512-tTZuDBPw85tEN5PQi1pnEBzDy0Z49HtScLAbD5t6hyeU92A95pRWaSMw1GZZi/RwgSgUIl0xrSlXIT/9QzvYSA=="], + "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.2.16", "", { "os": "win32", "cpu": "x64" }, "sha512-1lv1KvX0Z871zfk7vw+dnXMMnHNyDwMzWG8Kv3HxDXMOhzCX4SHc7HK319fInP0i+0p9D8brkfzL7pJOaGl+tw=="], "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="], - "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.62.2", "", { "os": "android", "cpu": "arm" }, "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg=="], + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.67.4", "", { "os": "android", "cpu": "arm" }, "sha512-/v/pUAPOcwp+r1Hjjdg0cBV1TE89CzGKrKh2FgkIQw2QBcIMmVPOCSfuOZStCn4Xh/98HXfo/ht6ztcssctPNg=="], + + "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.67.4", "", { "os": "android", "cpu": "arm64" }, "sha512-6tmmB/P52Vt167FXXEw5auiEUgTtZz7aqUgWHqYXToIUE0HFDY6fTdAyeekjjsNk6O/8dtpSKtClxSj1mMneKQ=="], - "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.62.2", "", { "os": "android", "cpu": "arm64" }, "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw=="], + "@rollup/rollup-android-x64": ["@rollup/rollup-android-x64@4.67.4", "", { "os": "android", "cpu": "x64" }, "sha512-8Z9Q4RmotVmuL4llOvqX814JNiOK1oqoBv+glG5KbpRfUiypqzz2/fxIzK4Pq129l4dT5a8Gszmpc0/XPYoFuQ=="], - "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.62.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A=="], + "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.67.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-pnq6hssxTtwuRAl6Kdi/+IDY+b1IhkUetjhUkdLAAJCssjfqtL2Oqy/FXJVJFtAWOu1oRlArIvf0Yk1O92x2HQ=="], - "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.62.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA=="], + "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.67.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-BeIrGZvHMVdJg/N+ohZfFywG/gF41684YhDj2wBvouj7m9ziP1tZDUNwzXRiDY+3WIKngaC4hiUBqVtBPGP5og=="], - "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.62.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw=="], + "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.67.4", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-fRFX/oqNg/g780DKoS8RIfYcZD59Ru5O/bSeK1N7gQljBFrTxJY/q5EX4eMs5SrJf32VgVBVVYCdfPpzAwPPnQ=="], - "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.62.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg=="], + "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.67.4", "", { "os": "freebsd", "cpu": "x64" }, "sha512-bSrBRopG1q+0RuOsW0NtYTtIODlvNA3T3ebx5WnQVdSxWIoXFmj+rZdHUHdSLgFdZ5M6VGmekYE7r4RMGQXjfg=="], - "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.62.2", "", { "os": "linux", "cpu": "arm" }, "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg=="], + "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.67.4", "", { "os": "linux", "cpu": "arm", "libc": "glibc" }, "sha512-L8IvdrJVtl65g1ozwDSyjGPG+FmibhCdFUwmqTItJLw0S3+Oj4QzFs7rfgTUiK7rsPjkCLdG1/GApFxoynXFJQ=="], - "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.62.2", "", { "os": "linux", "cpu": "arm" }, "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA=="], + "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.67.4", "", { "os": "linux", "cpu": "arm", "libc": "musl" }, "sha512-h7PcoQOzC31jshNpQ48J0akB9tsghjkSjSl5AZ6XsVGTxVsln7t7C4SQyw62tNVSaz2SeHgk4VT2ELbL17BSHQ=="], - "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.62.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA=="], + "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.67.4", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-KSPuOBNHoOl7AsVjeY1KZci8+0up0U4TFAHU5IzBYN8P+Z6cB9DZq28+JQycZW7f6WLLa/tSzhV7Rdy95bVi+g=="], - "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.62.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ=="], + "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.67.4", "", { "os": "linux", "cpu": "arm64", "libc": "musl" }, "sha512-0E/mKmVk1PlQeQYygIwQm0jlwjANTzGSiNBMPrFx+rdFGFj/2Axh4p6XwcrystQIqXZVudTaGsdbDpzYgJ4wSA=="], - "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg=="], + "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.67.4", "", { "os": "linux", "cpu": "none", "libc": "glibc" }, "sha512-Fvw7dOSc2Sa9UOipRZVI0zOgdLCzsjVyD/6JuHXzUHTXFu7mMgmeX/0/bCVBIut1dz+nWz3pV4WpS/Qg0XVnxw=="], - "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ=="], + "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.67.4", "", { "os": "linux", "cpu": "none", "libc": "musl" }, "sha512-jzxbVHaE7V3F+P0wEK7UydQtvv7Twfdtx58jI5/3VRx1jJxyrn+qFwfXmqjVFxPhBl+zjaRs+ZJMFJw7vdHaQA=="], - "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.62.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A=="], + "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.67.4", "", { "os": "linux", "cpu": "ppc64", "libc": "glibc" }, "sha512-fhtrzp9p4GjEJVaigaap9g6X9nP6xgJtKiLLXSDgpE18HXufA5aqfltGn+KAqMtVZReJZfOrXm//y5YSA9BWbA=="], - "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.62.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w=="], + "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.67.4", "", { "os": "linux", "cpu": "ppc64", "libc": "musl" }, "sha512-uynaF7IUHwAckV0S+yC1f5esy9gB+aqCBsPH5BOck32TYdCuAn2lVG5tvUcFnEsrviGEmRZxE1NHSOieUPYJEg=="], - "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg=="], + "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.67.4", "", { "os": "linux", "cpu": "none", "libc": "glibc" }, "sha512-uaqRFdfb8eIa2bVHN/FE3ndCvR0zV2xv0AwjCfxrqSu6l6fp/54VhjfhslKlf2RIik9L1jwlt4E56PeVX6tQtQ=="], - "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.62.2", "", { "os": "linux", "cpu": "none" }, "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q=="], + "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.67.4", "", { "os": "linux", "cpu": "none", "libc": "musl" }, "sha512-JZRow7kmxUDEASnxHuVG5itTm+nTXi9BQUABcVUnUEngC+OPwMrpx1uJ9hIA/v+IcAEBL52ktCSPXk5OJn9Jqg=="], - "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.62.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg=="], + "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.67.4", "", { "os": "linux", "cpu": "s390x", "libc": "glibc" }, "sha512-rdrh4e+Lq9fCNKoDPaCqeHXbQCe7yl77Ukl45tlSClwYdZ1gpFGZz1XLJdYtY++FRlfL5aHvb6/0n3GDW/Nxsw=="], - "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.62.2", "", { "os": "linux", "cpu": "x64" }, "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A=="], + "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.67.4", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-wL7MS4r0fYcxluF3ne2plofHZiB/LsqNCnyaUlyiKpAJLb6agPSFz7DEFCfkonWAZXMrLwCmC08b2ZEnEdJkog=="], - "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.62.2", "", { "os": "linux", "cpu": "x64" }, "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg=="], + "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.67.4", "", { "os": "linux", "cpu": "x64", "libc": "musl" }, "sha512-4H0XHfd2VufGjX7NjUyeue78sD0bRIoKSGjGqO+F5nSvL6jN48NAU7esdmtFEYxZXwObLtt3MJ/kHS0jASMW3g=="], - "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.62.2", "", { "os": "openbsd", "cpu": "x64" }, "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg=="], + "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.67.4", "", { "os": "openbsd", "cpu": "x64" }, "sha512-osRHQbE55pZpCLetpMsFmhkapyZnAUH73qRKMh+npi3boUom6u6hdaTTPSxlInXxwJHsn9r2uDhdz0V7Yoxx2A=="], - "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.62.2", "", { "os": "none", "cpu": "arm64" }, "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA=="], + "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.67.4", "", { "os": "none", "cpu": "arm64" }, "sha512-95+exYEyOwrZePsE0czi4q7X5lxKPa21+lmyAZlwbYENITQ0Unk4HAQAFp/p+KhXBHBx9mUABXRYjOC5A1wY3Q=="], - "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.62.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg=="], + "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.67.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-FOXOcKhNQpO4Po+Ynan6IbtM67SrXZbgpRJWVYwz53CT5veI7sVzDwVBmWS65N5Imv+wK3SVhIPAl+C5DXXNCg=="], - "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.62.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q=="], + "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.67.4", "", { "os": "win32", "cpu": "ia32" }, "sha512-cklKh0gJOkAZQcWziQa3hrjxZKN+PCHZ7SPTyGJDAiBVr05ZXlEjGFCG7zFJMaVibxsmzAe1FimN4u/HBns9+Q=="], - "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.62.2", "", { "os": "win32", "cpu": "x64" }, "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg=="], + "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.67.4", "", { "os": "win32", "cpu": "x64" }, "sha512-AegwxJPc9bvUp8fQtlsUHkFMOMkGylWU7glyL+YD4vwG+QaYoGXYLSsQoeTD7kvoLZrVlMWNVhTg1dedY5C1VQ=="], - "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.62.2", "", { "os": "win32", "cpu": "x64" }, "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA=="], + "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.67.4", "", { "os": "win32", "cpu": "x64" }, "sha512-RJZnrwTWj7Iq2ooBwoGbDdC65tDwYawneGcAfFMJqVUrRZMcskka6nTkBpXR/47G7kzn3EW2qupExnaBy11vwg=="], "@tiptap/core": ["@tiptap/core@3.30.5", "", { "peerDependencies": { "@tiptap/pm": "3.30.5" } }, "sha512-3O7N0FyKIfuLV+xrdWyDM3V5eUY/q2CgLjhhMwOAbM1Pu7VPp9VP+TpEYOdH8aRyB+h1vj5hX5A747D8ZrPfHA=="], @@ -440,13 +442,11 @@ "@tiptap/suggestion": ["@tiptap/suggestion@3.30.5", "", { "peerDependencies": { "@floating-ui/dom": "^1.0.0", "@tiptap/core": "3.30.5", "@tiptap/pm": "3.30.5" } }, "sha512-kXlsY2GyXlVpYKp6uSedvvfACC4Phd0I8/Gp1/7ts8fYLlkVfGco6kgqOKHxT6HcUF1pGshxkDh9lfRCakkQEA=="], - "@tybys/wasm-util": ["@tybys/wasm-util@0.10.3", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg=="], - - "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="], + "@types/bun": ["@types/bun@1.4.4", "", { "dependencies": { "bun-types": "1.4.4" } }, "sha512-9wkRDXUXK124pEnAutE6n/l18j+i9GC5IAHK8TmX/2nlySETmky0OU6yL5U8pW1AoKh++AN9auDCr647BfurjQ=="], "@types/debug": ["@types/debug@4.1.13", "", { "dependencies": { "@types/ms": "*" } }, "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw=="], - "@types/estree": ["@types/estree@1.0.9", "", {}, "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg=="], + "@types/estree": ["@types/estree@1.0.10", "", {}, "sha512-lTyOMnOcmRBzdCv6/4zUZCrEhV0xrqQiUZBZtVcbmLHBXKLnN8q89v/wKRF/Q0HbwVsqbIG3o5HDoFl9sduM+g=="], "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="], @@ -456,19 +456,19 @@ "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="], - "@types/node": ["@types/node@25.9.5", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-OScDchr2fwuUmWdf4kZ9h7PcJiYDVInhJizG/biAq3cAvqwYktuy/TYGGdZNMtNTFUP7rnb0NU4TUdm82kt4Rg=="], + "@types/node": ["@types/node@25.9.9", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-b4e2xxj/yMeT2hNlD6x7zNFiQK2Dlmkb9CQ6v3/1G2RezKN4YS2lcEv8lzGm1mhs4f2lM4yNAMI/zUDBZBBt7w=="], - "@types/react": ["@types/react@19.2.17", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw=="], + "@types/react": ["@types/react@19.3.0", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg=="], - "@types/react-dom": ["@types/react-dom@19.2.3", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="], + "@types/react-dom": ["@types/react-dom@19.3.0", "", { "peerDependencies": { "@types/react": "^19.3.0" } }, "sha512-ZI7bU42mZXXKHn/qNLEw2IrbiINU7X5+vfgdixBHkCNpYWXjKgfQ/P+uyGb5CjOLB9UcnTeg3rylQtV2hym44Q=="], "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="], "@types/use-sync-external-store": ["@types/use-sync-external-store@0.0.6", "", {}, "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg=="], - "@ungap/structured-clone": ["@ungap/structured-clone@1.3.3", "", {}, "sha512-60YRaenCQcVjYEKOcG824+DRGGIQ3VKErcBoAEDJZz5bKIs2ZG+X/H9Nk+Q6EVkwJk5QNApxbrc5QtBSwtrXAg=="], + "@ungap/structured-clone": ["@ungap/structured-clone@1.4.0", "", {}, "sha512-1mEZtMKPM09vDmQt5y7YvmN2+DFTP7Tg0EWXdic8/C6VRnpb33e4ghisCIE3WZjsE2N8mf+QV1Zqh7ZFYLWInQ=="], - "@vitejs/plugin-react": ["@vitejs/plugin-react@6.0.3", "", { "dependencies": { "@rolldown/pluginutils": "^1.0.1" }, "peerDependencies": { "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0", "babel-plugin-react-compiler": "^1.0.0", "vite": "^8.0.0" }, "optionalPeers": ["@rolldown/plugin-babel", "babel-plugin-react-compiler"] }, "sha512-vmFvco5/QuC2f9Oj+wTk0+9XeDFkHxSamwZKYc7MxYwKICfvUvlMhqKI0VuICPltGqh1neqBKDvO4kes1ya8vg=="], + "@vitejs/plugin-react": ["@vitejs/plugin-react@6.1.2", "", { "dependencies": { "@rolldown/pluginutils": "^1.0.1" }, "peerDependencies": { "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0", "babel-plugin-react-compiler": "^1.0.0", "oxc-transform-react": "^0.152.0", "vite": "^8.0.0" }, "optionalPeers": ["@rolldown/plugin-babel", "babel-plugin-react-compiler", "oxc-transform-react"] }, "sha512-fhJNGUdscQa4HkI0xFxwonWyhnVReCPDbXI7FH7jmzpnVCrFQI7PRrhWecO263610vOrs9tr2Y4xcf8uAdFxbw=="], "acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="], @@ -504,7 +504,7 @@ "braces": ["@openagentpack/braces@file:vendor/braces", { "dependencies": { "fill-range": "^7.1.1" } }], - "bun-types": ["bun-types@1.3.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="], + "bun-types": ["bun-types@1.4.4", "", { "dependencies": { "@types/node": "*", "undici-types": "*" } }, "sha512-yjrJh5oGX7mMPKGd19YXyIjmEuj4G4zNC30bs7PM9Az7NQ3ndF3j6hbeRdvJTRQEhJ/FYQwW0a2moweEi2hMxQ=="], "bundle-require": ["bundle-require@5.1.0", "", { "dependencies": { "load-tsconfig": "^0.2.3" }, "peerDependencies": { "esbuild": ">=0.18" } }, "sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA=="], @@ -548,7 +548,7 @@ "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="], - "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], + "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" }, "peerDependencies": { "supports-color": "*" }, "optionalPeers": ["supports-color"] }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], "decode-named-character-reference": ["decode-named-character-reference@1.3.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q=="], @@ -570,7 +570,7 @@ "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], - "esbuild": ["esbuild@0.28.1", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.28.1", "@esbuild/android-arm": "0.28.1", "@esbuild/android-arm64": "0.28.1", "@esbuild/android-x64": "0.28.1", "@esbuild/darwin-arm64": "0.28.1", "@esbuild/darwin-x64": "0.28.1", "@esbuild/freebsd-arm64": "0.28.1", "@esbuild/freebsd-x64": "0.28.1", "@esbuild/linux-arm": "0.28.1", "@esbuild/linux-arm64": "0.28.1", "@esbuild/linux-ia32": "0.28.1", "@esbuild/linux-loong64": "0.28.1", "@esbuild/linux-mips64el": "0.28.1", "@esbuild/linux-ppc64": "0.28.1", "@esbuild/linux-riscv64": "0.28.1", "@esbuild/linux-s390x": "0.28.1", "@esbuild/linux-x64": "0.28.1", "@esbuild/netbsd-arm64": "0.28.1", "@esbuild/netbsd-x64": "0.28.1", "@esbuild/openbsd-arm64": "0.28.1", "@esbuild/openbsd-x64": "0.28.1", "@esbuild/openharmony-arm64": "0.28.1", "@esbuild/sunos-x64": "0.28.1", "@esbuild/win32-arm64": "0.28.1", "@esbuild/win32-ia32": "0.28.1", "@esbuild/win32-x64": "0.28.1" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw=="], + "esbuild": ["esbuild@0.28.1", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.28.1", "@esbuild/android-arm": "0.28.1", "@esbuild/android-arm64": "0.28.1", "@esbuild/android-x64": "0.28.1", "@esbuild/darwin-arm64": "0.28.1", "@esbuild/darwin-x64": "0.28.1", "@esbuild/freebsd-arm64": "0.28.1", "@esbuild/freebsd-x64": "0.28.1", "@esbuild/linux-arm": "0.28.1", "@esbuild/linux-arm64": "0.28.1", "@esbuild/linux-ia32": "0.28.1", "@esbuild/linux-loong64": "0.28.1", "@esbuild/linux-mips64el": "0.28.1", "@esbuild/linux-ppc64": "0.28.1", "@esbuild/linux-riscv64": "0.28.1", "@esbuild/linux-s390x": "0.28.1", "@esbuild/linux-x64": "0.28.1", "@esbuild/netbsd-arm64": "0.28.1", "@esbuild/netbsd-x64": "0.28.1", "@esbuild/openbsd-arm64": "0.28.1", "@esbuild/openbsd-x64": "0.28.1", "@esbuild/openharmony-arm64": "0.28.1", "@esbuild/sunos-x64": "0.28.1", "@esbuild/win32-arm64": "0.28.1", "@esbuild/win32-ia32": "0.28.1", "@esbuild/win32-x64": "0.28.1" }, "hasInstallScript": true, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw=="], "escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="], @@ -592,7 +592,7 @@ "fast-wrap-ansi": ["fast-wrap-ansi@0.2.2", "", { "dependencies": { "fast-string-width": "^3.0.2" } }, "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q=="], - "fastq": ["fastq@1.20.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw=="], + "fastq": ["fastq@1.20.3", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-XKv5nnLs6nLF71NgiKJLIZFLkPyIEuOselLG7ujZnGrRfQK8HpvY+WqKhAJUAdLomwVHErVS4LfxFlPq0/FTAw=="], "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="], @@ -604,7 +604,7 @@ "fs-extra": ["fs-extra@7.0.1", "", { "dependencies": { "graceful-fs": "^4.1.2", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw=="], - "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], + "fsevents": ["fsevents@2.3.3", "", { "os": "darwin", "hasInstallScript": true }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], @@ -622,11 +622,11 @@ "hast-util-sanitize": ["hast-util-sanitize@5.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "unist-util-position": "^5.0.0" } }, "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg=="], - "hast-util-to-jsx-runtime": ["hast-util-to-jsx-runtime@2.3.6", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-js": "^1.0.0", "unist-util-position": "^5.0.0", "vfile-message": "^4.0.0" } }, "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg=="], + "hast-util-to-jsx-runtime": ["hast-util-to-jsx-runtime@2.3.7", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-object": "^2.0.0", "unist-util-position": "^5.0.0", "vfile-message": "^4.0.0" } }, "sha512-F7DNV2NMcTxA4GqPVHnXzX+mpoPHAIY9rJAVH3CZ1FdBZOcBUEjUuvMkMpHVs/sicEtznh9tMGj5WUR9S4E2rg=="], "hast-util-whitespace": ["hast-util-whitespace@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw=="], - "hono": ["hono@4.13.7", "", {}, "sha512-c8/gF9ac8Y78/agExVocyLevgR+JlpNB444Py0FSX8pJoPdYUfUzRcXtYEYGwt6l19qIlVZPN5Mfsw9jFShmQQ=="], + "hono": ["hono@4.13.16", "", {}, "sha512-AOLOEhvrV+iH92xXCnFr/5+3KjPKcI3xP63XJtX5spAnkznPdHijlIsUTpi7/9EhWqrTCekw5c5zh1K+YsVw7A=="], "html-parse-stringify": ["html-parse-stringify@3.1.0", "", { "dependencies": { "void-elements": "3.1.0" } }, "sha512-E0oAXcELOtsXe+BmpJ2EZyedbldPpriV5vICzEuo6xjC/D1lDukOI7KrpfQGF2Qc4wWEy0nk3bFORS2K5ZAhFQ=="], @@ -634,7 +634,7 @@ "https-proxy-agent": ["https-proxy-agent@7.0.6", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "4" } }, "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw=="], - "human-id": ["human-id@4.2.0", "", { "bin": { "human-id": "dist/cli.js" } }, "sha512-K3GbkIWqyvvlpfhBPlbEvD97TtqBpAYA4kt+cn2lD2x2HuohzZCibcA2nOlnJT6exqvJLggoB5nv2dNf192nEA=="], + "human-id": ["human-id@4.2.2", "", { "bin": { "human-id": "dist/cli.js" } }, "sha512-Z+8unD6em/MJwyrkWQ2M3wygRGI1+MztbutiNwk1DCuEPXOZRWGjtcMPZYP1exY9iNZMhd7ZOSMQSo9WYtiQRw=="], "i18next": ["i18next@25.10.10", "", { "dependencies": { "@babel/runtime": "^7.29.2" }, "peerDependencies": { "typescript": "^5 || ^6" }, "optionalPeers": ["typescript"] }, "sha512-cqUW2Z3EkRx7NqSyywjkgCLK7KLCL6IFVFcONG7nVYIJ3ekZ1/N5jUsihHV6Bq37NfhgtczxJcxduELtjTwkuQ=="], @@ -650,7 +650,7 @@ "ini": ["ini@4.1.1", "", {}, "sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g=="], - "inline-style-parser": ["inline-style-parser@0.2.7", "", {}, "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA=="], + "inline-style-parser": ["inline-style-parser@0.2.9", "", {}, "sha512-IttN8BqKLxzUrnTqHI+/hwAJQItBAUjdoHERCDv+oOuX48VP6bzW8+QjOXSfoevzq3YrYAwX1uLHp8TqO9yIeg=="], "interpret": ["interpret@3.1.1", "", {}, "sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ=="], @@ -658,7 +658,7 @@ "is-alphanumerical": ["is-alphanumerical@2.0.1", "", { "dependencies": { "is-alphabetical": "^2.0.0", "is-decimal": "^2.0.0" } }, "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw=="], - "is-core-module": ["is-core-module@2.16.2", "", { "dependencies": { "hasown": "^2.0.3" } }, "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA=="], + "is-core-module": ["is-core-module@2.17.0", "", { "dependencies": { "hasown": "^2.0.4" } }, "sha512-J/vG0zBCbIKOQFfufSwyXdMrsohyJIUNkrnmo6WZGzoM7tr/lsbfW5b2BvisL6zsyMzK9UxV9L6c7AoFbyXHOA=="], "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="], @@ -698,37 +698,37 @@ "jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], - "jszip": ["jszip@3.10.1", "", { "dependencies": { "lie": "~3.3.0", "pako": "~1.0.2", "readable-stream": "~2.3.6", "setimmediate": "^1.0.5" } }, "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g=="], + "jszip": ["jszip@3.10.2", "", { "dependencies": { "lie": "~3.3.0", "pako": "~1.0.2", "readable-stream": "~2.3.6", "setimmediate": "^1.0.5" } }, "sha512-3l+rb15IOWtUhU0H5MFqES/T6Kh7abYwjosBey/vD6hDt8zoEffkSC5Ws5SGtgVw3gBx2NEbhTeSW1+kWkpyTQ=="], "kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="], "lie": ["lie@3.3.0", "", { "dependencies": { "immediate": "~3.0.5" } }, "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ=="], - "lightningcss": ["lightningcss@1.32.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.32.0", "lightningcss-darwin-arm64": "1.32.0", "lightningcss-darwin-x64": "1.32.0", "lightningcss-freebsd-x64": "1.32.0", "lightningcss-linux-arm-gnueabihf": "1.32.0", "lightningcss-linux-arm64-gnu": "1.32.0", "lightningcss-linux-arm64-musl": "1.32.0", "lightningcss-linux-x64-gnu": "1.32.0", "lightningcss-linux-x64-musl": "1.32.0", "lightningcss-win32-arm64-msvc": "1.32.0", "lightningcss-win32-x64-msvc": "1.32.0" } }, "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ=="], + "lightningcss": ["lightningcss@1.33.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.33.0", "lightningcss-darwin-arm64": "1.33.0", "lightningcss-darwin-x64": "1.33.0", "lightningcss-freebsd-x64": "1.33.0", "lightningcss-linux-arm-gnueabihf": "1.33.0", "lightningcss-linux-arm64-gnu": "1.33.0", "lightningcss-linux-arm64-musl": "1.33.0", "lightningcss-linux-x64-gnu": "1.33.0", "lightningcss-linux-x64-musl": "1.33.0", "lightningcss-win32-arm64-msvc": "1.33.0", "lightningcss-win32-x64-msvc": "1.33.0" } }, "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA=="], - "lightningcss-android-arm64": ["lightningcss-android-arm64@1.32.0", "", { "os": "android", "cpu": "arm64" }, "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg=="], + "lightningcss-android-arm64": ["lightningcss-android-arm64@1.33.0", "", { "os": "android", "cpu": "arm64" }, "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg=="], - "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.32.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ=="], + "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.33.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg=="], - "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.32.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w=="], + "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.33.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ=="], - "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.32.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig=="], + "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.33.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg=="], - "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.32.0", "", { "os": "linux", "cpu": "arm" }, "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw=="], + "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.33.0", "", { "os": "linux", "cpu": "arm" }, "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ=="], - "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ=="], + "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.33.0", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg=="], - "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.32.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg=="], + "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.33.0", "", { "os": "linux", "cpu": "arm64", "libc": "musl" }, "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ=="], - "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA=="], + "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.33.0", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg=="], - "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.32.0", "", { "os": "linux", "cpu": "x64" }, "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg=="], + "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.33.0", "", { "os": "linux", "cpu": "x64", "libc": "musl" }, "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw=="], - "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.32.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw=="], + "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.33.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA=="], - "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.32.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q=="], + "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.33.0", "", { "os": "win32", "cpu": "x64" }, "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA=="], - "lilconfig": ["lilconfig@3.1.3", "", {}, "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="], + "lilconfig": ["lilconfig@3.1.4", "", {}, "sha512-zJZyBmQhArDRefuWTypZxwDpFDIYmrj8ypSBvwGD5P13Y95s6DjzKgu4DVdGbeQa5PDEsAOCAPNk4X+QOR006w=="], "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="], @@ -740,15 +740,15 @@ "longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="], - "lucide-react": ["lucide-react@1.24.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-YT6mBD8lGKkg4nM39enlm94/sfJIiW0YKUT60fBy4YK8tai31ylg1VhGNWxkpSKHo9UagfnZqwIff3HTDQwXeA=="], + "lucide-react": ["lucide-react@1.66.0", "", { "peerDependencies": { "@types/react": "*", "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" }, "optionalPeers": ["@types/react"] }, "sha512-8zjbi/Us+ETXqfBwmXF/FHrWGIqOdE6zT1yUdRJLQVoptomSkB0zdFWVIM667t9K8djWDaXdkBkqi2qVTuDNiw=="], "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="], "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="], - "mdast-util-find-and-replace": ["mdast-util-find-and-replace@3.0.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "escape-string-regexp": "^5.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg=="], + "mdast-util-find-and-replace": ["mdast-util-find-and-replace@3.0.4", "", { "dependencies": { "@types/mdast": "^4.0.0", "escape-string-regexp": "^5.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.1.0" } }, "sha512-z4B5c6jrnJ1ltOQemhWYPBSAo6y42Z8Gt2yEgfgNTMcLSU59B8bfj8Z8AnAlJrBGLnqkdAUZ7jdDEqQw3KuipQ=="], - "mdast-util-from-markdown": ["mdast-util-from-markdown@2.0.3", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "mdast-util-to-string": "^4.0.0", "micromark": "^4.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q=="], + "mdast-util-from-markdown": ["mdast-util-from-markdown@2.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "mdast-util-to-string": "^4.0.0", "micromark": "^4.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-KRLgmPaP2H1ul2bpoJkOS+9pAcDAAj9Nu1mqLnh8NLeJG5tlvj42TH80PIGBpROWlRXLk0lDrWNuZCFy/tsB4A=="], "mdast-util-gfm": ["mdast-util-gfm@3.1.0", "", { "dependencies": { "mdast-util-from-markdown": "^2.0.0", "mdast-util-gfm-autolink-literal": "^2.0.0", "mdast-util-gfm-footnote": "^2.0.0", "mdast-util-gfm-strikethrough": "^2.0.0", "mdast-util-gfm-table": "^2.0.0", "mdast-util-gfm-task-list-item": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ=="], @@ -756,7 +756,7 @@ "mdast-util-gfm-footnote": ["mdast-util-gfm-footnote@2.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.1.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0" } }, "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ=="], - "mdast-util-gfm-strikethrough": ["mdast-util-gfm-strikethrough@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg=="], + "mdast-util-gfm-strikethrough": ["mdast-util-gfm-strikethrough@2.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-OuJHqvr455pwu2OaOrir7dbzqs4jlWKOtlu9L6GjcIjjQwNyw02VntQsr/Ek6/A13vgnXfUhBekWRUP1OkNivw=="], "mdast-util-gfm-table": ["mdast-util-gfm-table@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "markdown-table": "^3.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg=="], @@ -772,15 +772,15 @@ "mdast-util-to-hast": ["mdast-util-to-hast@13.2.1", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA=="], - "mdast-util-to-markdown": ["mdast-util-to-markdown@2.1.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "longest-streak": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-string": "^4.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA=="], + "mdast-util-to-markdown": ["mdast-util-to-markdown@2.2.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "longest-streak": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-string": "^4.0.0", "micromark-util-character": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-ThatlCBxG2GE+mljhNSfZPv56d3QrGiRh97jjYgIk80IzS4uU6d7cHAaexCYSAmUCCcOs3grJ07kX3oTGsFUOw=="], "mdast-util-to-string": ["mdast-util-to-string@4.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0" } }, "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg=="], "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="], - "micromark": ["micromark@4.0.2", "", { "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA=="], + "micromark": ["micromark@4.0.3", "", { "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-edit-map": "^1.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-oGYfQzHSG5dOMovQcJ3fyTmZlWAWpi0XA0sJwJs+i6OT88o1+Jtw/8z0CmdowSLxGhhFK89rQ/oXph/wN02PNw=="], - "micromark-core-commonmark": ["micromark-core-commonmark@2.0.3", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg=="], + "micromark-core-commonmark": ["micromark-core-commonmark@2.0.4", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.1.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-edit-map": "^1.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.3" } }, "sha512-wxEeE8v8XVvOrxn1TZj74qYhAtTQsSqufHVS3uNVyT1MupXxhyaHk8/9xDNPh9BmL77QNDgWTkZ3RsYHB2ry7w=="], "micromark-extension-gfm": ["micromark-extension-gfm@3.0.0", "", { "dependencies": { "micromark-extension-gfm-autolink-literal": "^2.0.0", "micromark-extension-gfm-footnote": "^2.0.0", "micromark-extension-gfm-strikethrough": "^2.0.0", "micromark-extension-gfm-table": "^2.0.0", "micromark-extension-gfm-tagfilter": "^2.0.0", "micromark-extension-gfm-task-list-item": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w=="], @@ -790,7 +790,7 @@ "micromark-extension-gfm-strikethrough": ["micromark-extension-gfm-strikethrough@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw=="], - "micromark-extension-gfm-table": ["micromark-extension-gfm-table@2.1.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg=="], + "micromark-extension-gfm-table": ["micromark-extension-gfm-table@2.1.2", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-pRzm4kDTu0MjlmBkxmS9yYhw60nncfcEwu9NNdPFSQEFXS95ZKyIIyTSHu/o3ReBUrLKYEq+7YaXCRn/bPB4MA=="], "micromark-extension-gfm-tagfilter": ["micromark-extension-gfm-tagfilter@2.0.0", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg=="], @@ -800,7 +800,7 @@ "micromark-factory-label": ["micromark-factory-label@2.0.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg=="], - "micromark-factory-space": ["micromark-factory-space@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg=="], + "micromark-factory-space": ["micromark-factory-space@2.1.0", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-fS8hnLIjnjvdQIj39Geug8wWsR0HrYZ43KShKxNfwT7t2LOHo/LbWZEzEaSOjwtjdCsjoE6syHhonEzW0zv0+Q=="], "micromark-factory-title": ["micromark-factory-title@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw=="], @@ -818,6 +818,8 @@ "micromark-util-decode-string": ["micromark-util-decode-string@2.0.1", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ=="], + "micromark-util-edit-map": ["micromark-util-edit-map@1.0.0", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-Pa2ljlsEL6sVwFaYeyrOLSYbQt73JvGbPOYFq+9AElXiSnfI5Q4465RRZ1sHv7lDjDOnGRDDaqPXqClqWK/q1Q=="], + "micromark-util-encode": ["micromark-util-encode@2.0.1", "", {}, "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw=="], "micromark-util-html-tag-name": ["micromark-util-html-tag-name@2.0.1", "", {}, "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA=="], @@ -832,11 +834,11 @@ "micromark-util-symbol": ["micromark-util-symbol@2.0.1", "", {}, "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q=="], - "micromark-util-types": ["micromark-util-types@2.0.2", "", {}, "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="], + "micromark-util-types": ["micromark-util-types@2.0.3", "", {}, "sha512-oxB2Ik03hI0gv+VNn9tnh1t1YEe9MDPptViAEgfdf3YQHsn0pzGTgCdlSCJXcwhqm8phaEuM7zeEu3QQzVBrPg=="], "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="], - "minimatch": ["minimatch@5.1.9", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw=="], + "minimatch": ["minimatch@11.0.3", "", { "dependencies": { "@isaacs/nonrecursive-glob-match": "^1.0.3", "brace-expansion": "^5.0.12" } }, "sha512-iny/40PEGkNJQ5/Pv6z3nm6FbRAby32GeZRjCUJk2WnNDbgPSTcdI+DDvLqsgBdD4cD5sMtMheqPPnehCCa8Nw=="], "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="], @@ -854,7 +856,7 @@ "openapi-typescript": ["openapi-typescript@7.13.0", "", { "dependencies": { "@redocly/openapi-core": "^1.34.6", "ansi-colors": "^4.1.3", "change-case": "^5.4.4", "parse-json": "^8.3.0", "supports-color": "^10.2.2", "yargs-parser": "^21.1.1" }, "peerDependencies": { "typescript": "^5.x" }, "bin": { "openapi-typescript": "bin/cli.js" } }, "sha512-EFP392gcqXS7ntPvbhBzbF8TyBA+baIYEm791Hy5YkjDYKTnk/Tn5OQeKm5BIZvJihpp8Zzr4hzx0Irde1LNGQ=="], - "openapi3-ts": ["openapi3-ts@4.6.0", "", { "dependencies": { "yaml": "^2.9.0" } }, "sha512-a4sfn6L2sIShhtzJqmjGrARvxAW/3F2BJDdyRVvNF9VhAsZSh5hSyI3a9TNvmzBxXmq66nY5LNT5bQcBxYAZZg=="], + "openapi3-ts": ["openapi3-ts@4.6.2", "", { "dependencies": { "yaml": "^2.9.1" } }, "sha512-gyyil3DweqhXiEhTqtAs9wwRLfWHmetwhI4kmM5Rn0d6gtmK863Ki7qqbQnp9+Wwlqoe3B1LFWj7kMp5ctE4rQ=="], "orderedmap": ["orderedmap@2.1.1", "", {}, "sha512-TvAWxi0nDe1j/rtMcWcIj94+Ffe6n7zhow33h40SKxmsmozs6dz/e+EajymfoFcHd7sxNn8yHM8839uixMOV6g=="], @@ -912,15 +914,15 @@ "property-information": ["property-information@7.2.0", "", {}, "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg=="], - "prosemirror-changeset": ["prosemirror-changeset@2.4.1", "", { "dependencies": { "prosemirror-transform": "^1.0.0" } }, "sha512-96WBLhOaYhJ+kPhLg3uW359Tz6I/MfcrQfL4EGv4SrcqKEMC1gmoGrXHecPE8eOwTVCJ4IwgfzM8fFad25wNfw=="], + "prosemirror-changeset": ["prosemirror-changeset@2.4.5", "", { "dependencies": { "prosemirror-transform": "^1.0.0" } }, "sha512-hv3Qhsn5GyoferiBqL8euGvj3Y8Z+2Ef75NnPLChr5DTWArpPAjK6F96Yc0iM7SBYNDPQbQaA+xEtAR8NuWo9A=="], - "prosemirror-commands": ["prosemirror-commands@1.7.1", "", { "dependencies": { "prosemirror-model": "^1.0.0", "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.10.2" } }, "sha512-rT7qZnQtx5c0/y/KlYaGvtG411S97UaL6gdp6RIZ23DLHanMYLyfGBV5DtSnZdthQql7W+lEVbpSfwtO8T+L2w=="], + "prosemirror-commands": ["prosemirror-commands@1.7.2", "", { "dependencies": { "prosemirror-model": "^1.0.0", "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.10.2" } }, "sha512-q6Q6szxqdu9Xd6EcdKsqXghu5nQdZTpB4Q9yd04WRc7/jt763e/rT60Owh0L1GYY+T46o5rD+9lEN36dZS43tw=="], - "prosemirror-dropcursor": ["prosemirror-dropcursor@1.8.3", "", { "dependencies": { "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.1.0", "prosemirror-view": "^1.1.0" } }, "sha512-FoYbsJR8gK+DGlqhNoE29Loa38eIZPzQRIb1VMaDNBoo4OLP6vVof/jR8qFY/6XvUd6Dhug8MDCHl2a/h8RTfQ=="], + "prosemirror-dropcursor": ["prosemirror-dropcursor@1.8.4", "", { "dependencies": { "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.1.0", "prosemirror-view": "^1.1.0" } }, "sha512-VmKxhcA6a+h5oPSYmfF1ZNeQqPbyYaIxqZsKqeYCyTlPtrjUgNaHL3P8vVaO19oqAV0zuaM/axkowZHrB1P3Tg=="], "prosemirror-gapcursor": ["prosemirror-gapcursor@1.4.1", "", { "dependencies": { "prosemirror-keymap": "^1.0.0", "prosemirror-model": "^1.0.0", "prosemirror-state": "^1.0.0", "prosemirror-view": "^1.0.0" } }, "sha512-pMdYaEnjNMSwl11yjEGtgTmLkR08m/Vl+Jj443167p9eB3HVQKhYCc4gmHVDsLPODfZfjr/MmirsdyZziXbQKw=="], - "prosemirror-history": ["prosemirror-history@1.5.0", "", { "dependencies": { "prosemirror-state": "^1.2.2", "prosemirror-transform": "^1.0.0", "prosemirror-view": "^1.31.0", "rope-sequence": "^1.3.0" } }, "sha512-zlzTiH01eKA55UAf1MEjtssJeHnGxO0j4K4Dpx+gnmX9n+SHNlDqI2oO1Kv1iPN5B1dm5fsljCfqKF9nFL6HRg=="], + "prosemirror-history": ["prosemirror-history@1.5.1", "", { "dependencies": { "prosemirror-state": "^1.2.2", "prosemirror-transform": "^1.0.0", "prosemirror-view": "^1.31.0", "rope-sequence": "^1.3.0" } }, "sha512-onlwnqKvgtFg6srZOmDOAhlAy1FIHQpOExORybX0S+DvJepE5tPALrB9iGet/2sqqqrelSnB10OoiOJqAvu2DA=="], "prosemirror-inputrules": ["prosemirror-inputrules@1.5.1", "", { "dependencies": { "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.0.0" } }, "sha512-7wj4uMjKaXWAQ1CDgxNzNtR9AlsuwzHfdFH1ygEHA2KHF2DOEaXl1CJfNPAKCg9qNEh4rum975QLaCiQPyY6Fw=="], @@ -928,13 +930,13 @@ "prosemirror-model": ["prosemirror-model@1.25.11", "", { "dependencies": { "orderedmap": "^2.0.0" } }, "sha512-QWg9RhnpLlogAmp3p96uEFrE5txQpFynd4vhBAELkwgOCWQs/X0yCzB3/hrHqiPwf91RG5KyWq6553zs9JqIOQ=="], - "prosemirror-schema-list": ["prosemirror-schema-list@1.5.1", "", { "dependencies": { "prosemirror-model": "^1.0.0", "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.7.3" } }, "sha512-927lFx/uwyQaGwJxLWCZRkjXG0p48KpMj6ueoYiu4JX05GGuGcgzAy62dfiV8eFZftgyBUvLx76RsMe20fJl+Q=="], + "prosemirror-schema-list": ["prosemirror-schema-list@1.6.0", "", { "dependencies": { "prosemirror-model": "^1.0.0", "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.7.3" } }, "sha512-G1srDtan+VqWn+qpmWFj/6j0YsZ5zMU+ZIlGVIW41a5JF2jAI3jzfMRWmSABmEH2Qoq1PmAG/o2mucMMdLOsLg=="], "prosemirror-state": ["prosemirror-state@1.4.4", "", { "dependencies": { "prosemirror-model": "^1.0.0", "prosemirror-transform": "^1.0.0", "prosemirror-view": "^1.27.0" } }, "sha512-6jiYHH2CIGbCfnxdHbXZ12gySFY/fz/ulZE333G6bPqIZ4F+TXo9ifiR86nAHpWnfoNjOb3o5ESi7J8Uz1jXHw=="], "prosemirror-tables": ["prosemirror-tables@1.8.5", "", { "dependencies": { "prosemirror-keymap": "^1.2.3", "prosemirror-model": "^1.25.4", "prosemirror-state": "^1.4.4", "prosemirror-transform": "^1.10.5", "prosemirror-view": "^1.41.4" } }, "sha512-V/0cDCsHKHe/tfWkeCmthNUcEp1IVO3p6vwN8XtwE9PZQLAZJigbw3QoraAdfJPir4NKJtNvOB8oYGKRl+t0Dw=="], - "prosemirror-transform": ["prosemirror-transform@1.12.0", "", { "dependencies": { "prosemirror-model": "^1.21.0" } }, "sha512-GxboyN4AMIsoHNtz5uf2r2Ru551i5hWeCMD6E2Ib4Eogqoub0NflniaBPVQ4MrGE5yZ8JV9tUHg9qcZTTrcN4w=="], + "prosemirror-transform": ["prosemirror-transform@1.12.4", "", { "dependencies": { "prosemirror-model": "^1.21.0" } }, "sha512-2/WuPum3pn+O/Vi2vzpi8210ICUe2kIPXdLYjQ09Pv5DtT5bcKWMJhAKPBwvpPjpp5iOYUVwVEr0gOM1BY1Mgw=="], "prosemirror-view": ["prosemirror-view@1.42.3", "", { "dependencies": { "prosemirror-model": "^1.25.8", "prosemirror-state": "^1.0.0", "prosemirror-transform": "^1.1.0" } }, "sha512-oTN7EtH+CpwxU9NrwEYWd0UZ4JUx7l048l5A2Xppm4p/60isZYLnth9QVQmC3VRIvdrIWCxwZSd+Uz791G31/w=="], @@ -942,9 +944,9 @@ "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], - "react": ["react@19.2.7", "", {}, "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ=="], + "react": ["react@19.3.1", "", {}, "sha512-QNhWdt7nrgVWWQG58QuGsAR3jv3Hbe4mb4vz7w2csnHavciZJgda1CPNaldF6eVxv90ud3jUXpKlHL69gO38yw=="], - "react-dom": ["react-dom@19.2.7", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.7" } }, "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ=="], + "react-dom": ["react-dom@19.3.1", "", { "dependencies": { "scheduler": "^0.28.0" }, "peerDependencies": { "react": "^19.3.1" } }, "sha512-Y0bARz53lhEC1NMCASs0/j+faB/zqt3R8hpvg1e8+61ZVJ4UL0UdC4cBbXfZMcIuhrfgeILTLe+ZeBCavQPtKQ=="], "react-i18next": ["react-i18next@16.6.6", "", { "dependencies": { "@babel/runtime": "^7.29.2", "html-parse-stringify": "^3.0.1", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "i18next": ">= 25.10.9", "react": ">= 16.8.0", "react-dom": "*", "react-native": "*", "typescript": "^5 || ^6" }, "optionalPeers": ["react-dom", "react-native", "typescript"] }, "sha512-ZgL2HUoW34UKUkOV7uSQFE1CDnRPD+tCR3ywSuWH7u2iapnz86U8Bi3Vrs620qNDzCf1F47NxglCEkchCTDOHw=="], @@ -972,15 +974,15 @@ "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="], - "resolve": ["resolve@1.22.12", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA=="], + "resolve": ["resolve@1.22.13", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.17.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-Dj/cW9zBV2aRj6XzCxuGIs3ESZKv02jixne3q6jFZYZ3/Tg09gHHviSMDL4kObh9pqSahdRHEnDoaP2gn8YLhA=="], "resolve-from": ["resolve-from@5.0.0", "", {}, "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw=="], "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="], - "rolldown": ["rolldown@1.1.5", "", { "dependencies": { "@oxc-project/types": "=0.139.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm64": "1.1.5", "@rolldown/binding-darwin-arm64": "1.1.5", "@rolldown/binding-darwin-x64": "1.1.5", "@rolldown/binding-freebsd-x64": "1.1.5", "@rolldown/binding-linux-arm-gnueabihf": "1.1.5", "@rolldown/binding-linux-arm64-gnu": "1.1.5", "@rolldown/binding-linux-arm64-musl": "1.1.5", "@rolldown/binding-linux-ppc64-gnu": "1.1.5", "@rolldown/binding-linux-s390x-gnu": "1.1.5", "@rolldown/binding-linux-x64-gnu": "1.1.5", "@rolldown/binding-linux-x64-musl": "1.1.5", "@rolldown/binding-openharmony-arm64": "1.1.5", "@rolldown/binding-wasm32-wasi": "1.1.5", "@rolldown/binding-win32-arm64-msvc": "1.1.5", "@rolldown/binding-win32-x64-msvc": "1.1.5" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-t9z29cJjXf/vxQ8dyhCSpt6H6aSwHTk8cT5I3iy6SMXuFpk5mB6PL6XfC8PCwrPTx93udwKUm9HRteAlTGBLiA=="], + "rolldown": ["rolldown@1.2.16", "", { "dependencies": { "@oxc-project/types": "=0.156.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm-eabi": "1.2.16", "@rolldown/binding-android-arm64": "1.2.16", "@rolldown/binding-darwin-arm64": "1.2.16", "@rolldown/binding-darwin-x64": "1.2.16", "@rolldown/binding-freebsd-x64": "1.2.16", "@rolldown/binding-linux-arm-gnueabihf": "1.2.16", "@rolldown/binding-linux-arm64-gnu": "1.2.16", "@rolldown/binding-linux-arm64-musl": "1.2.16", "@rolldown/binding-linux-ppc64-gnu": "1.2.16", "@rolldown/binding-linux-s390x-gnu": "1.2.16", "@rolldown/binding-linux-x64-gnu": "1.2.16", "@rolldown/binding-linux-x64-musl": "1.2.16", "@rolldown/binding-openharmony-arm64": "1.2.16", "@rolldown/binding-win32-arm64-msvc": "1.2.16", "@rolldown/binding-win32-x64-msvc": "1.2.16" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-bWvlMpFKiTfDKfnK7FC2MPgPeWCf/Kpwsq49ApdW+FQaBZb6O6dZ4MAPbPUjp7hYQrw/RobqCzn64BRrQecGHw=="], - "rollup": ["rollup@4.62.2", "", { "dependencies": { "@types/estree": "1.0.9" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.62.2", "@rollup/rollup-android-arm64": "4.62.2", "@rollup/rollup-darwin-arm64": "4.62.2", "@rollup/rollup-darwin-x64": "4.62.2", "@rollup/rollup-freebsd-arm64": "4.62.2", "@rollup/rollup-freebsd-x64": "4.62.2", "@rollup/rollup-linux-arm-gnueabihf": "4.62.2", "@rollup/rollup-linux-arm-musleabihf": "4.62.2", "@rollup/rollup-linux-arm64-gnu": "4.62.2", "@rollup/rollup-linux-arm64-musl": "4.62.2", "@rollup/rollup-linux-loong64-gnu": "4.62.2", "@rollup/rollup-linux-loong64-musl": "4.62.2", "@rollup/rollup-linux-ppc64-gnu": "4.62.2", "@rollup/rollup-linux-ppc64-musl": "4.62.2", "@rollup/rollup-linux-riscv64-gnu": "4.62.2", "@rollup/rollup-linux-riscv64-musl": "4.62.2", "@rollup/rollup-linux-s390x-gnu": "4.62.2", "@rollup/rollup-linux-x64-gnu": "4.62.2", "@rollup/rollup-linux-x64-musl": "4.62.2", "@rollup/rollup-openbsd-x64": "4.62.2", "@rollup/rollup-openharmony-arm64": "4.62.2", "@rollup/rollup-win32-arm64-msvc": "4.62.2", "@rollup/rollup-win32-ia32-msvc": "4.62.2", "@rollup/rollup-win32-x64-gnu": "4.62.2", "@rollup/rollup-win32-x64-msvc": "4.62.2", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA=="], + "rollup": ["rollup@4.67.4", "", { "dependencies": { "@types/estree": "^1.0.10" }, "optionalDependencies": { "@napi-rs/lzma-linux-x64-gnu": "1.5.1", "@rollup/rollup-android-arm-eabi": "4.67.4", "@rollup/rollup-android-arm64": "4.67.4", "@rollup/rollup-android-x64": "4.67.4", "@rollup/rollup-darwin-arm64": "4.67.4", "@rollup/rollup-darwin-x64": "4.67.4", "@rollup/rollup-freebsd-arm64": "4.67.4", "@rollup/rollup-freebsd-x64": "4.67.4", "@rollup/rollup-linux-arm-gnueabihf": "4.67.4", "@rollup/rollup-linux-arm-musleabihf": "4.67.4", "@rollup/rollup-linux-arm64-gnu": "4.67.4", "@rollup/rollup-linux-arm64-musl": "4.67.4", "@rollup/rollup-linux-loong64-gnu": "4.67.4", "@rollup/rollup-linux-loong64-musl": "4.67.4", "@rollup/rollup-linux-ppc64-gnu": "4.67.4", "@rollup/rollup-linux-ppc64-musl": "4.67.4", "@rollup/rollup-linux-riscv64-gnu": "4.67.4", "@rollup/rollup-linux-riscv64-musl": "4.67.4", "@rollup/rollup-linux-s390x-gnu": "4.67.4", "@rollup/rollup-linux-x64-gnu": "4.67.4", "@rollup/rollup-linux-x64-musl": "4.67.4", "@rollup/rollup-openbsd-x64": "4.67.4", "@rollup/rollup-openharmony-arm64": "4.67.4", "@rollup/rollup-win32-arm64-msvc": "4.67.4", "@rollup/rollup-win32-ia32-msvc": "4.67.4", "@rollup/rollup-win32-x64-gnu": "4.67.4", "@rollup/rollup-win32-x64-msvc": "4.67.4", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-Lsv3oKcz5jgOQJej/p7nfwbVEdAbDT+z6OPf/SCdI+nF+q2ENp0pTKT35ZwXAmH8g45mfrIiJeEyAqKYSYoL9Q=="], "rope-sequence": ["rope-sequence@1.3.4", "", {}, "sha512-UT5EDe2cu2E/6O4igUr5PSFs23nvvukicWHx6GnOPlHAiiYbzNuCRQCuiUdHJQcqKalLKlrYJnjY0ySGsXNQXQ=="], @@ -992,9 +994,9 @@ "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="], - "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="], + "scheduler": ["scheduler@0.28.0", "", {}, "sha512-juorfCmIkIw8tT+p5BXSm6PJjQF/ycEYmKyzURCIt/RaZIhL+PulbQ9Yu2z1HdOJDdqDTlxA1+xKBmHXJsczAw=="], - "semver": ["semver@7.8.5", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="], + "semver": ["semver@7.8.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg=="], "setimmediate": ["setimmediate@1.0.5", "", {}, "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA=="], @@ -1024,9 +1026,7 @@ "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="], - "style-to-js": ["style-to-js@1.1.21", "", { "dependencies": { "style-to-object": "1.0.14" } }, "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ=="], - - "style-to-object": ["style-to-object@1.0.14", "", { "dependencies": { "inline-style-parser": "0.2.7" } }, "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw=="], + "style-to-object": ["style-to-object@2.0.2", "", { "dependencies": { "inline-style-parser": "0.2.9" } }, "sha512-QmbXPUylqU80HAgTOJeEOdbA40W9KtxmjMhQy+tq+b8F2aoh3aQLuy82hh2jm2qsC9hR9eI0+eQidTMydKcqRA=="], "sucrase": ["sucrase@3.35.1", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", "lines-and-columns": "^1.1.6", "mz": "^2.7.0", "pirates": "^4.0.1", "tinyglobby": "^0.2.11", "ts-interface-checker": "^0.1.9" }, "bin": { "sucrase": "bin/sucrase", "sucrase-node": "bin/sucrase-node" } }, "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw=="], @@ -1060,8 +1060,6 @@ "tsconfig-paths-webpack-plugin": ["tsconfig-paths-webpack-plugin@4.2.0", "", { "dependencies": { "chalk": "^4.1.0", "enhanced-resolve": "^5.7.0", "tapable": "^2.2.1", "tsconfig-paths": "^4.1.2" } }, "sha512-zbem3rfRS8BgeNK50Zz5SIQgXzLafiHjOwUAvk/38/o1jHn/V5QAgVUcz884or7WYcPaH3N2CIfUc2u0ul7UcA=="], - "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="], - "tsup": ["tsup@8.5.1", "", { "dependencies": { "bundle-require": "^5.1.0", "cac": "^6.7.14", "chokidar": "^4.0.3", "consola": "^3.4.0", "debug": "^4.4.0", "esbuild": "^0.27.0", "fix-dts-default-cjs-exports": "^1.0.0", "joycon": "^3.1.1", "picocolors": "^1.1.1", "postcss-load-config": "^6.0.1", "resolve-from": "^5.0.0", "rollup": "^4.34.8", "source-map": "^0.7.6", "sucrase": "^3.35.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.11", "tree-kill": "^1.2.2" }, "peerDependencies": { "@microsoft/api-extractor": "^7.36.0", "@swc/core": "^1", "postcss": "^8.4.12", "typescript": ">=4.5.0" }, "optionalPeers": ["@microsoft/api-extractor", "@swc/core", "postcss", "typescript"], "bin": { "tsup": "dist/cli-default.js", "tsup-node": "dist/cli-node.js" } }, "sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing=="], "type-fest": ["type-fest@4.41.0", "", {}, "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA=="], @@ -1080,15 +1078,15 @@ "unist-util-stringify-position": ["unist-util-stringify-position@4.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ=="], - "unist-util-visit": ["unist-util-visit@5.1.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg=="], + "unist-util-visit": ["unist-util-visit@5.2.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.1.0" } }, "sha512-fpsYs/VVoZxfGY9/j3FQpZmN8wdLJaV1Pt38AaJNZu9uKIHcFU3halCdBveEq1HGKO1OEfJY65w1zvoFV1b3qQ=="], - "unist-util-visit-parents": ["unist-util-visit-parents@6.0.2", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ=="], + "unist-util-visit-parents": ["unist-util-visit-parents@6.1.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-vKXxz6O38sKDj1mtx/k2cWvkkFBuYGx6uGrlzBkVeWCRF/F8sdI0j3Wbkz/5rVNRRuVc8UrgRdbCxNhmYXgP3w=="], "universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], - "uri-js-replace": ["uri-js-replace@1.0.1", "", {}, "sha512-W+C9NWNLFOoBI2QWDp4UT9pv65r2w5Cx+3sTYFvtMdDBxkKt1syCqsUdSFAChbEe1uK5TfS04wt/nGwmaeIQ0g=="], + "uri-js-replace": ["uri-js-replace@1.0.2", "", {}, "sha512-VeBBt/nMxedczht3KDL2yBBMJqIxpCQLMZp3UJ1otcWwUHdQW4IiyHpJivExzSK+FdxTowRfGL4FmwDqH9+S8Q=="], - "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="], + "use-sync-external-store": ["use-sync-external-store@1.7.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-6L+EeigHMQhdaIPNIFUKwfWJSwWFQ8gJbJ2DLOs5sDIegTwR9fRxvnM3uciHKjIZhFz+KAv2emhWMRvDmMcY8A=="], "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], @@ -1096,7 +1094,7 @@ "vfile-message": ["vfile-message@4.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw=="], - "vite": ["vite@8.1.4", "", { "dependencies": { "lightningcss": "^1.32.0", "picomatch": "^4.0.5", "postcss": "^8.5.16", "rolldown": "~1.1.4", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.3.0", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-bTT9PsdWO+MQMNG9ZXIP/qM9wGh37DFxTV/sPq9cFpHr3w4jkgef032PkAL9jAqhk3Nz8NQw3O8n6/xFkqO4QQ=="], + "vite": ["vite@8.3.5", "", { "dependencies": { "lightningcss": "^1.33.0", "picomatch": "^4.0.7", "postcss": "^8.5.30", "rolldown": "~1.2.14", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.7.1 || ^0.8.0", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-z1YpjieJ9g0ebTmQpLBv/oq9E3F9EIlOe+7LahW8SrE3LTiG3udBRUXQOlYXP9b+IC2q2phHeVxj9xGlw34OEQ=="], "void-elements": ["void-elements@3.1.0", "", {}, "sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w=="], @@ -1108,13 +1106,13 @@ "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], - "yaml": ["yaml@2.9.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="], + "yaml": ["yaml@2.9.1", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-3NxN8+78OdzbT7C/WjGsyfPAtJaN3FNDsWxv7Y7mcDsT/oOmgW8BpyQQFFBnvZE3j9Y2Sdz1ULFLezL7Eb2yFw=="], "yaml-ast-parser": ["yaml-ast-parser@0.0.43", "", {}, "sha512-2PTINUwsRqSd+s8XxKaJWQlUuEMHJQyEuh2edBbW8KNJz0SJPwUSD2zRWqezFEdN7IzAgeuYHFUCF7o8zRdZ0A=="], "yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="], - "zod": ["zod@4.4.3", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="], + "zod": ["zod@4.6.7", "", {}, "sha512-g8W2D2kU6a8untc053fX1uVBKzM7yqAxW/3zwk83+6RyF2+SKOuV+c0wBDhUwzV1PaGapmZH+rmcUzPf+3CGwg=="], "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="], @@ -1126,11 +1124,9 @@ "@manypkg/get-packages/fs-extra": ["fs-extra@8.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g=="], - "dependency-cruiser/semver": ["semver@7.8.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg=="], - "globby/ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="], - "micromatch/braces": ["braces@file:vendor/braces", {}], + "micromatch/braces": ["@openagentpack/braces@file:vendor/braces", { "dependencies": { "fill-range": "^7.1.1" } }], "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="], @@ -1138,11 +1134,11 @@ "sucrase/commander": ["commander@4.1.1", "", {}, "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA=="], - "tinyglobby/picomatch": ["picomatch@4.0.5", "", {}, "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A=="], + "tinyglobby/picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="], "tsconfig-paths-webpack-plugin/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="], - "vite/picomatch": ["picomatch@4.0.5", "", {}, "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A=="], + "vite/picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="], "tsconfig-paths-webpack-plugin/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], } diff --git a/docs/contributing/development.md b/docs/contributing/development.md index 7c6b07f..35cdb80 100644 --- a/docs/contributing/development.md +++ b/docs/contributing/development.md @@ -4,7 +4,9 @@ How to set up the repo, run the CLI/WebUI from source, run verification, and res ## Prerequisites -- [Bun](https://bun.sh) `1.3.5` — the pinned workspace runtime and package manager. +- [Bun](https://bun.sh) `1.4.4` — the pinned workspace runtime and package manager, matching CI. + +Upgrade Bun before installing dependencies: the committed v2 lockfile cannot be read by Bun 1.3. ## Setup @@ -15,6 +17,12 @@ git remote add upstream https://github.com/modelstudioai/OpenAgentPack.git bun install ``` +`minimatch` stays pinned to the security-fixed 11.x release. The Bun patch for +`@redocly/openapi-core@1.34.22` adapts its CommonJS import to the named `minimatch` +export, preserving remote OpenAPI header matching without downgrading to a vulnerable +5.x release. When upgrading Redocly, verify `apps/webui/tests/openapi-remote.test.ts` +and remove the patch once the upstream import is compatible. + Run the CLI from source without a global install: ```sh @@ -88,4 +96,4 @@ OpenAgentPack is a Bun workspace. Packages resolve each other's TypeScript sourc - Changing the `@openagentpack/sdk` / `@openagentpack/cli` publish model (compiled `dist/` published to public npm) without a proposal. - New runtime dependencies without justification. -See the top-level [CONTRIBUTING.md](../../CONTRIBUTING.md) for the merge requirements, and [Provider development](./provider-development.md) and [Release](./release.md) for the deeper workflows. \ No newline at end of file +See the top-level [CONTRIBUTING.md](../../CONTRIBUTING.md) for the merge requirements, and [Provider development](./provider-development.md) and [Release](./release.md) for the deeper workflows. diff --git a/docs/getting-started.md b/docs/getting-started.md index bd30883..b4a1efb 100644 --- a/docs/getting-started.md +++ b/docs/getting-started.md @@ -9,7 +9,7 @@ This guide takes you from zero to a running agent session in a few minutes. It u - Qoder — `QODER_PAT` - Bailian (Aliyun AgentStudio) — `DASHSCOPE_API_KEY` and `BAILIAN_WORKSPACE_ID` - Volcengine Ark (Managed Agents) — `ARK_API_KEY` -- To run the project from source: [Bun](https://bun.sh) `1.3.5` (see [Development](./contributing/development.md)). To use the published CLI, Node.js or Bun is enough. +- To run the project from source: [Bun](https://bun.sh) `1.4.4` (see [Development](./contributing/development.md)). To use the published CLI, Node.js or Bun is enough. ## Install diff --git a/docs/getting-started.zh-CN.md b/docs/getting-started.zh-CN.md index fb7b91e..12e722c 100644 --- a/docs/getting-started.zh-CN.md +++ b/docs/getting-started.zh-CN.md @@ -9,7 +9,7 @@ - Qoder — `QODER_PAT` - 百炼(阿里云百炼 AgentStudio)— `DASHSCOPE_API_KEY` 与 `BAILIAN_WORKSPACE_ID` - 火山方舟(火山引擎方舟 Managed Agents)— `ARK_API_KEY` -- 从源码运行需要 [Bun](https://bun.sh) `1.3.5`(见 [开发环境](./contributing/development.md));使用发布的 CLI 只需 Node.js 或 Bun。 +- 从源码运行需要 [Bun](https://bun.sh) `1.4.4`(见 [开发环境](./contributing/development.md));使用发布的 CLI 只需 Node.js 或 Bun。 ## 安装 diff --git a/docs/reference/configuration.md b/docs/reference/configuration.md index 514687f..ac05c0c 100644 --- a/docs/reference/configuration.md +++ b/docs/reference/configuration.md @@ -423,7 +423,7 @@ If the preflight cannot resolve the Identity, Template, or Store lookup, destroy | `delivery..type` | `"managed"` \| `"forward"` | no | Per-provider remote materialization. Omitted means the managed Agent resource. `forward` (Qoder only) materializes the agent as a Forward Template; Qoder multi-agent members must use the same delivery type as their coordinator. | | `resources` | SessionResource[] | no | Resources attached to every managed Session created for the Agent. | | `multiagent.type` | `"coordinator"` | no | Declare a coordinator agent. | -| `multiagent.agents` | (string \| `{ agent_id: string }`)[] | yes (with multiagent) | Project logical names and, for Managed delivery, explicitly referenced external Agent ids. | +| `multiagent.agents` | (string \| `{ agent_id: string }` \| `{ type: "self" }`)[] | yes (with multiagent) | Project logical names, external Managed Agent ids, and Bailian's native Self member. | | `metadata` | map | no | Free-form metadata. | For Qoder Forward delivery, a locally declared Environment is created only through the Forward Environment API. An @@ -458,6 +458,8 @@ Phase 1 rules, enforced at plan time on every provider: - A string member is a project logical name. OpenAgentPack resolves it to the materialized remote resource and manages its lifecycle. - `{ agent_id: ... }` explicitly references an external Managed Agent. It does not need a local `agents` declaration or state entry and OpenAgentPack never creates, updates, or destroys it. +- **Bailian Managed only:** `{ type: self }` delegates to the current coordinator as a native Self member. It can be used alone or alongside other members, counts toward the 20-member limit, and may appear only once. It carries no id, version, or extra fields, creates no additional resource or dependency, and remains Self when exported or copied. Other providers reject it. +- Bailian tool approval is main-Agent only. Project-declared roster members and delegated Self must not have effective builtin `ask` policies; remove those policies or run the member as a main Agent. Explicit `allow` overrides may cancel a default `ask`. External `{ agent_id }` policies cannot be inspected by offline validation. - Qoder Forward does not accept `{ agent_id }`, because its roster requires Template ids. External Forward Templates are not exposed by the common schema yet. - For project logical-name members, self references, nested coordinators, and any direct or indirect cycle are rejected. External members are non-owned leaves in the topology. - A roster carries at most 20 members (Qoder and Bailian platform limits). @@ -473,7 +475,7 @@ Update and clear semantics are hidden by the provider adapters: removing `multia Bailian child agents run in **parallel over a shared file system**: files written by one member are visible to the others. Declare file/directory ownership in the coordinator's `instructions` (and in each member's) to keep parallel members from writing the same path. -`self` references, Qoder Advisors, explicit member versions, external Forward Templates, and Thread management are not exposed by the common schema yet. +Qoder Self and Advisors, explicit member versions, external Forward Templates, and Thread management are not exposed by the common schema yet. `agents sync` reverse-maps project-owned members to logical names via the `agents.project`/`agents.resource` metadata OpenAgentPack injects, and preserves non-owned members as `{ agent_id }`. The sync fails closed — without touching your existing file — when a project-owned roster member is archived, missing from the account listing, lacks a logical name, or when two remote agents claim the same logical name. diff --git a/docs/reference/openapi.md b/docs/reference/openapi.md index 2df096a..cf3859e 100644 --- a/docs/reference/openapi.md +++ b/docs/reference/openapi.md @@ -29,6 +29,7 @@ | Files | `routes/files.ts` | | Skills | `routes/skills.ts` | | Models | `routes/models.ts` | +| Usage | `routes/usage.ts` | Routes are defined with `@hono/zod-openapi`'s `createRoute`, so request validation, typed responses, and OpenAPI generation share the same Zod schemas. Multipart files and skill uploads use the same @@ -55,3 +56,7 @@ bun run dev # server + webui together ``` The server reads the same provider credentials as the CLI (`.env` and `~/.agents/config.json`); see [Provider reference](./providers.md). + +用量接口使用当前目录项目解析后的 Provider 配置和项目本地 `.env`,与项目 Session 使用相同的配置来源。 +通过 `AGENTS_PROJECT_ROOT` 指定项目目录时,无需另行设置进程级 `AGENTS_PROVIDER` 或复制凭据。 +缺失或无效的项目返回 `422`,不会回退到进程环境中的其他 Provider。 diff --git a/docs/reference/providers.md b/docs/reference/providers.md index 5224258..3f35761 100644 --- a/docs/reference/providers.md +++ b/docs/reference/providers.md @@ -28,6 +28,15 @@ This matrix is verified against the SDK capability declarations in `packages/sdk The resource matrix above answers whether a declaration can be applied. The table below answers a different question: which optional workflows the **current OpenAgentPack adapter** actually implements. It is intentionally scoped to this repository, rather than every feature a provider may advertise. +Bailian supports builtin-tool approval through `tools.default_permission` and per-tool `tools.permissions` (`allow` / `ask`). +The adapter maps them to `permission_policy: {type: "always_allow" | "always_ask"}`; omitted tool overrides inherit the toolkit default. +Effective policy changes participate in Agent drift comparison, while equivalent inherited and explicit policies compare equally. +Approval applies to the main Agent only; existing Sessions retain the Agent version used at creation. +Validation rejects effective `ask` policies on project-declared roster members and delegated Self; defaults fully overridden by `allow` remain valid. +Export preserves toolkit defaults and enabled-tool overrides. A default-enabled toolkit with approval policies cannot be represented losslessly by an explicit tool list, so export stops with a diagnostic; explicitly select its tools first. +See the official [Agent tools](https://help.aliyun.com/zh/model-studio/managed-agents-builtin-tools) and +[Create Agent API](https://help.aliyun.com/zh/model-studio/agent-create) contracts. + | Adapter workflow | Bailian | Qoder | Claude | Volcengine Ark | Implementation notes | |------------------|:-------:|:-----:|:------:|:--------------:|----------------------| | List agents, environments, and vaults | yes | yes | yes | yes | Powers resource discovery in the Web UI. | @@ -46,6 +55,8 @@ The resource matrix above answers whether a declaration can be applied. The tabl ### Notable provider-specific behavior +- **Bailian Self:** `multiagent.agents` accepts a single `{ type: self }` entry, alone or mixed with other members. It delegates as the current coordinator, counts toward the roster limit, and survives export and drift comparison without creating another managed Agent. Other providers reject this declaration until their Self contract is implemented. + - **Bailian:** skill upload uses the Files API and supports scan-status polling; agent updates create provider-side versions. Official MCP servers are referenced by name. Deployments are native, with server-side cron schedules, manual runs, and pause/unpause. Multi-agent members run in parallel and share the coordinator's file system; the coordinator roster omits versions so each child Thread resolves the latest member and pins it for its lifetime. - **Qoder:** tool names are translated from the lowercase config vocabulary to PascalCase. Session sends return a cursor, enabling resumable event consumption. Deployments are native and support manual or scheduled runs. Multi-agent coordinators work in both delivery modes — Managed Agents reference members by `id`, Forward Templates by `template_id`, and members must share the coordinator's delivery type. - **Claude:** deployments are native, including their server-side lifecycle. It is currently the only adapter that downloads remote skill packages during `sync`. diff --git a/docs/reference/providers.zh-CN.md b/docs/reference/providers.zh-CN.md index e71a44a..4b0dd11 100644 --- a/docs/reference/providers.zh-CN.md +++ b/docs/reference/providers.zh-CN.md @@ -39,8 +39,21 @@ OpenAgentPack 通过 Provider 适配器与不同的 AI Agent 平台交互。每 ### Adapter 实现能力对照表 +百炼 Managed Agent 支持原生 Self 成员 `{type: self}`,可单独使用或与其他成员混选,并计入 20 项名册上限。 +Self 指代当前协调 Agent,不创建额外受管资源;导出和漂移比较会完整保留。其他 Provider 的 Self 合同尚未接入,声明时明确拒绝。 + 上表回答“某类资源能否声明和 apply”;下表回答“**当前 OpenAgentPack Adapter** 具体实现了哪些可选工作流”。表格描述的是本仓库代码,而不是 Provider 宣传的全部平台能力。 +百炼内置工具支持 `tools.default_permission` 与单工具 `tools.permissions`(`allow` / `ask`), +分别映射为默认与单工具的 `permission_policy` 对象;未设置的单工具策略继承工具组默认值。 +有效权限变化参与 Agent 漂移比较,等价的继承与显式配置不会重复产生差异;普通允许配置保留原比较基线。 +审批仅对主智能体生效,既有 Session 保持创建时的 Agent 版本。校验会拒绝项目内被引用成员和委派 Self 的有效 `ask` 策略; +若默认 `ask` 已被所有启用工具的 `allow` 覆盖,则仍可通过。外部 `{ agent_id }` 没有本地工具声明,离线校验不推断其远端策略。 +导出会保留工具组默认策略与启用工具的覆盖;默认启用全部工具且带审批策略的远端工具组无法无损表示为显式工具列表, +导出会明确拒绝,请先关闭工具组默认启用并逐项启用所需工具。详见官方 +[Agent 工具配置](https://help.aliyun.com/zh/model-studio/managed-agents-builtin-tools)与 +[创建 Agent API](https://help.aliyun.com/zh/model-studio/agent-create)。 + | Adapter 工作流 | 百炼 | Qoder | Claude | 火山方舟 | 实现说明 | |----------------|:----:|:-----:|:------:|:--------:|----------| | 枚举 Agent、Environment、Vault | yes | yes | yes | yes | 用于 Web UI 的云端资源发现 | diff --git a/docs/reference/sdk.md b/docs/reference/sdk.md index 51e0729..d4b6404 100644 --- a/docs/reference/sdk.md +++ b/docs/reference/sdk.md @@ -28,6 +28,325 @@ The package entry is `.`. It also exposes three narrow, browser-safe subpath con Everything re-exported from these entries is public SDK surface. The engine itself lives under `src/internal/` and is deliberately not reachable from outside the package — there is no `exports` condition that resolves into it. +## Session 事件内容策略 + +`@openagentpack/sdk/session-events` 导出的 `sanitizeSessionEvent()` 和 +`sanitizeSessionEvents()` 接受同一个 `SessionEventSanitizerOptions` 配置。 +SDK 保持默认脱敏、默认截断;完整 SSE 的调用方可以显式关闭这两种处理: + +```ts +import { + sanitizeSessionEvent, + sanitizeSessionEvents, + type SessionEventSanitizerOptions, +} from "@openagentpack/sdk/session-events"; + +sanitizeSessionEvent(event); // 保持默认脱敏和截断 +sanitizeSessionEvent(event, { redact: false }); // 仅关闭脱敏 +sanitizeSessionEvent(event, { truncate: false }); // 仅关闭截断 +const completeContent: SessionEventSanitizerOptions = { redact: false, truncate: false }; +sanitizeSessionEvent(event, completeContent); // 完整 SSE 内容的显式策略 +sanitizeSessionEvents(events, { ...completeContent, includeRaw: true }); +``` + +- `redact` 默认 `true`,控制正文、错误文本、`metadata.tool_input` 和可选 + `metadata.raw` 中的敏感文本替换;仅影响本次调用,不改变全局配置。 +- `truncate` 默认 `true`,保留原有上限:普通正文 4000 字符、工具正文 8000 字符、 + 检出的 HTML/SVG/Mermaid 文档 32000 字符、可选 raw 16000 字符。 + 只有显式传入 `false` 才取消这些长度限制。旧 `legacy` 投影中的 + `metadata.tool_input` 保持原有长度;新 `snapshot` 模式中的工具参数按工具文本上限处理。 +- 两个开关互相独立,同时开启时先脱敏再截断。`metadata.redacted` 和 + `metadata.truncated` 仅在对应处理实际改变数据时设置为 `true`。 +- `includeRaw` 默认 `false`,独立控制是否包含 Provider 原始数据;开启后同样遵循 + 两个策略。关闭脱敏和截断不会自动返回 raw。 +- 脱敏沿用关键词和 URL 参数匹配规则,Markdown 媒体及下载链接的保留规则不变。 + 新 `snapshot` 路径还识别结构化对象中的 `api_key`、`authorization`、`secret`、 + `token` 等敏感字段,但不承诺识别任意业务敏感信息。 +- 存在 `ProviderSessionEvent.snapshot` 时,sanitizer 优先深拷贝该结构,递归处理文本叶子, + 保留对象、数组、身份、状态和内容块索引。截断不会把整个对象变成残缺的 JSON 字符串。 + 显式 `content: []` 不会被旧的正文便利字段重新填充。 + 身份字段的豁免只适用于协议中的明确位置;工具参数、输出及未知业务数据内同名的 + `code`、`id`、`status` 等字段仍按所选策略脱敏和截断,包括 `metadata.tool_input` 与可选 raw。 +- 仅关闭内容策略不会开启增量或补齐旧 `legacy` 投影;需要结构化内容时同时选择 + 下文的 `snapshot` 模式。 +- `streamSessionEvents()`、`listSessionEvents()` 和 `listSessionThreadEvents()` 返回 `ProviderSessionEvent`; + 内容策略在转换为契约 `SessionEvent` 时传入,不是 Provider 请求参数。 + +## 百炼 Session SSE 与累计快照 + +此能力针对百炼 BMA Session 的 `/sessions/{session_id}/events/stream` 协议。 +SSE 是传输方式;`event_deltas` 决定是否订阅消息生成期间的正文和推理分片。 +2026-10-28 的 BMA 实测流使用混合 envelope:生成期间发送 `event_start/event_delta`, +完成时仍发送完整 `object: "message", status: "completed"` 事件,最后由独立的 +`session_status` 表示会话状态。SDK 同时兼容既有 `object: "content" / msg_id / delta` 分片。 +这里只覆盖该 BMA 合同,不表示支持任意 CMA envelope 或 Responses API 流式格式。 + +### 默认行为与显式选项 + +旧调用不传新选项时仍使用 `event_format: "legacy"`:不请求增量,不新增累计快照, +`ProviderSessionEvent` 的原有便利字段与 sanitizer 默认策略保持不变。 +`event_format: "snapshot"` 可用于完整事件流或历史查询,不要求同时开启增量。 + +| 选项 | 适用入口 | 默认与含义 | +| --- | --- | --- | +| `event_format` | 历史、流式 | `"legacy"`;设置 `"snapshot"` 保留结构化事件 | +| `event_deltas` | 流式 | 不传;非空 `("message" \| "reasoning")[]` 请求相应内容分片,自动选择 `snapshot` | +| `signal` | 历史、流式 | 不传;取消请求、流读取及恢复等待 | +| `onReady` | 流式 | 不传;每次 HTTP 连接成功且 reader 建立后调用 | +| `reconnect` | 流式 | `false`;仅百炼 `snapshot` 模式支持自动恢复 | +| `connectTimeoutMs` | 流式 | `snapshot` 默认 30000 毫秒;连接就绪前超时 | +| `idleTimeoutMs` | 流式 | `snapshot` 默认 180000 毫秒;任何网络数据、注释和心跳均计为活动 | + +显式 `event_format: "legacy"` 与非空 `event_deltas` 冲突时直接报错。 +非百炼 Provider 请求快照、增量或这些流生命周期配置时明确报不支持,不会静默忽略。 +超时必须是正的有限数值。`event_deltas` 才会编码为百炼的 `event_deltas[]` 查询参数, +其余新选项由 SDK 本地处理。 + +`streamSessionEvents()` 的流选项直接放在第三个参数中; +`startSessionRun()` 和 `sendSessionMessageStreaming()` 则放在 `options.stream` 中: + +```ts +import { + sendSessionMessageStreaming, + streamSessionEvents, + type ProjectRuntimeContext, + type SessionEvent, +} from "@openagentpack/sdk"; +import { sanitizeSessionEvent } from "@openagentpack/sdk/session-events"; + +// ctx 使用调用方已经配置好的百炼 runtime;本函数只订阅,不发送用户消息。 +async function watchSession( + ctx: ProjectRuntimeContext, + sessionId: string, + signal: AbortSignal, + onEvent: (event: SessionEvent) => void, +) { + for await (const event of streamSessionEvents(ctx, sessionId, { + provider: "bailian", + event_deltas: ["message", "reasoning"], // 自动选择 snapshot + signal, + reconnect: true, // 默认关闭;此例显式开启 + onReady: () => console.info("SSE connection established"), + })) { + onEvent(sanitizeSessionEvent(event, { redact: false, truncate: false })); + } +} + +// 高层发送入口负责先建立订阅,再发送一次消息。 +async function sendMessage(ctx: ProjectRuntimeContext, sessionId: string, signal: AbortSignal) { + return sendSessionMessageStreaming(ctx, sessionId, "请介绍一下这个项目", { + provider: "bailian", + stream: { event_deltas: ["message", "reasoning"], signal }, + }); +} +``` + +高层发送返回的事件迭代器也需要使用 `for await` 消费,才能驱动订阅和发送。 +`onReady` 表示客户端 HTTP 连接及 reader 已建立,不代表首个业务事件已到达, +也不额外保证服务端已将订阅登记到它的执行系统。 + +### 快照内容与消费方式 + +新模式每次输出的 `ProviderSessionEvent.snapshot` 都使用现有 `SessionEvent` 契约。 +分片累计后的正文可能依次为 `你`、`你好`、`你好!`,它们沿用同一个 `event_id`。 +调用方应按 ID **替换同一条消息的快照**,不能把每次快照当作新消息追加,也不能按 ID +只保留第一次结果。无 ID 的状态事件仍应独立处理。 + +- `content[]` 保留正文、推理、工具数据、多模态和未知内容块;`delta: true` 追加到 + 对应索引,`delta: false` 替换该块。最终消息显式携带的 `content` 具有权威性。 + 空字符串或 `content: []` 表示清空,字段缺失表示保留已有值。 +- BMA `event_start.event` 提供业务事件的 `id/type`,可选角色、线程与时间字段原样保留; + 缺失字段不猜测,待完整事件补齐。`event_delta.event_id` 关联同一事件: + `reasoning_delta.reasoning` 累积推理文本,`content_delta.content` 按 `index` 累积文本内容。 + 这些 envelope 不作为独立业务事件输出,也不推进完成游标;先到的分片有界暂存,直到身份到达。 + 实测结束帧是完整消息,不据此定义 `event_end` 行为,更不把消息完成当作会话结束。 +- `metadata.event_status` 是消息生命周期,如 `in_progress/completed`; + `metadata.status` 是会话运行状态,如 `running/idle`,两者不能互相替代。 +- 工具调用通过 `call_id` 关联,保留参数和输出的字符串或对象形态、错误标记、MCP 信息; + 线程路由、结构化停止原因与审批字段保留到内容或元数据中。 + SDK 不会自动批准工具调用,也不会把不同审批字段改写成同一种协议。 +- **`metadata.artifacts[]` 是 SDK 派生字段,不是 SSE 原生字段**:SDK 仅在工具名或 + `call_id` 关联确认是 `mark_artifacts` 结果后,从 `output.marked[]` 提取有效文件。 + 原始 `marked/failed` 结果仍保留在内容里;首个文件同时提供 `metadata.artifact`。 + SDK 不从普通文本猜测产物,也不自动获取下载 URL。 +- 每次快照都是独立对象,后续分片不会修改已交付的快照。 + `ProviderSessionEvent.raw` 始终是实际触发该次输出的上游帧,不是伪造的累计帧。 + sanitizer 仅在 `includeRaw: true` 时将它放进 `metadata.raw`。 + +历史查询同样显式选择 `snapshot`,分页继续使用 Provider 返回的不透明 `next_page`: + +```ts +import { listSessionEvents } from "@openagentpack/sdk"; +import { sanitizeSessionEvents, toBailianSessionEvent } from "@openagentpack/sdk/session-events"; + +const page = await listSessionEvents(ctx, sessionId, { + provider: "bailian", + event_format: "snapshot", + order: "asc", + limit: 100, + page_token: previousNextPage, +}); +const events = sanitizeSessionEvents(page.events, { redact: false, truncate: false }); + +// 纯映射函数用于完整消息/历史事件;content 分片必须经过订阅内的有状态归并器。 +const mapped = toBailianSessionEvent(rawCompleteEvent, { event_format: "snapshot" }); +``` + +其中 `ctx`、`sessionId`、上一页的 `previousNextPage` 和原始完整事件由调用方提供。 +`./session-events` 子路径保持浏览器安全,提供纯映射、累计转换与 sanitizer; +网络订阅和高层 Session 工作流使用 SDK 主入口,不应导入 `internal/*`。 + +### 子 Agent 线程与历史查询 + +百炼 Multi-Agent 的子 Agent 执行使用独立的 `sthr_*` Thread;主 Agent 的 `thrd_*` +不是线程列表中的子资源。同一 Agent 可以对应多条 Thread,调用方应按 Thread ID 区分执行实例。 +两个 SDK 查询入口使用百炼的 Session Threads REST 路径: + +| SDK 方法 | 百炼路径 | 结果 | +| --- | --- | --- | +| `listSessionThreads(ctx, sessionId, options)` | `GET /sessions/{session_id}/threads` | `SessionThreadPage`,即 `CursorPage` | +| `listSessionThreadEvents(ctx, sessionId, threadId, options)` | `GET /sessions/{session_id}/threads/{thread_id}/events` | `ProviderSessionEventList` | + +这些路径由百炼 [Multi-Agent 教程](https://docs.agent.bailian.aliyun.com/zh/managed-agents/best-practices/multiagent-proposal) +说明,尚未纳入正式公开 API 参考;不能据此假设其他 Provider 也支持。当前 SDK 仅百炼实现, +其他 Provider 返回明确的 unsupported 错误。`ctx` 可用现有 `ProjectRuntimeContext`, +也可用只包含 Provider 配置的 `ManagedApiContext`。 + +```ts +import { listSessionThreads, listSessionThreadEvents } from "@openagentpack/sdk"; +import { sanitizeSessionEvents } from "@openagentpack/sdk/session-events"; + +const threads = await listSessionThreads(ctx, sessionId, { + provider: "bailian", limit: 100, page: previousThreadPage, signal, +}); +const history = await listSessionThreadEvents(ctx, sessionId, selectedThreadId, { + provider: "bailian", event_format: "snapshot", order: "desc", + limit: 50, page_token: previousEventPage, signal, +}); +const events = sanitizeSessionEvents(history.events, { redact: false, truncate: false }); +``` + +`SessionThread` 保留 `id/session_id/parent_thread_id`、绑定的 `agent.id/version`、状态和时间, +Provider 有名称时也保留 `agent.name` 或 `agent_name`。列表按 `limit/page` 分页;历史查询 +复用 `EventListOptions`,`page_token` 优先于兼容别名 `page`,请求时均映射为 `page`。 +两者下一页都回传不透明的 `next_page`。历史 `types` 在 SDK 内本地过滤,保留原页游标; +过滤后空页不等于查询结束。两者都支持 `AbortSignal`。 + +需要补齐线程绑定 Agent 的名称时,可调用 +`getRemoteAgent(ctx, thread.agent.id, { version: thread.agent.version, signal })`。 +百炼实现会把 `signal` 传入实际 GET 请求,取消线程列表时应一并取消这些补充查询。 + +历史默认仍为 `legacy`;选择 `snapshot` 后复用完整事件转换、工具关联和 sanitizer。 +子线程历史页不要求包含 `session_status`。事件的 `metadata.thread_id` 是实际所属线程, +`metadata.session_thread_id`、`to_session_thread_id/from_session_thread_id` 可能是被引用的子线程, +不能直接用引用字段替换实际归属。 + +此处只提供列表与历史读取,不新增 Thread 创建、归档、发送或独立 SSE。实时事件继续从 +Session 的单一事件流获取;子线程状态不表示主会话执行结束。`SessionThread`、 +`SessionThreadListOptions` 和 `SessionThreadPage` 也通过 `./session-events` 导出类型, +浏览器可复用合同而无需加载 SDK 主入口或 Provider 凭据。 + +### 资源用量查询 + +资源用量(模型调用明细 / 工具调用明细)对接百炼 app-control 的 +`usage.listModelUsage` 与 `usage.listToolUsage`,按 scope 维度返回聚合行。REST 映射 +与百炼侧约定为 AgentStudio 资源风格(`POST /usage/models`、`POST /usage/tools`, +顶层请求体);公网 AgentStudio 环境尚未启用这两个端点(网关 404),启用后无需改动 +即可调通: + +| SDK 方法 | 百炼路径 | 结果 | +| --- | --- | --- | +| `listModelUsage(ctx, request, options)` | `POST /usage/models` | `ModelUsagePage` | +| `listToolUsage(ctx, request, options)` | `POST /usage/tools` | `ToolUsagePage` | + +`scope` 按 `type` 区分三种形态:`workspace`(必传非空 `workspace_ids`,可加 `agent_id`)、 +`agent`(必传 `agent_id`,可加 `workspace_ids` 与 `agent_version`)、`session`(必传 +`session_id`)。`time_range` 为毫秒级 Unix 区间:workspace/agent 必传,session 禁止 +(复用 Session 自身窗口);校验在发起请求前完成。模型明细支持 +`model_name` 过滤与 `call_count/failed_count/input_tokens/output_tokens` 排序;工具明细 +支持 `source`(`builtin/mcp/custom`)与 `tool_name` 过滤,排序仅限调用次数相关字段。 +分页 `page_no` 从 1 开始,`page_size` 限 1..100;表头总数取 `total_call_count`,分页总数取 +`total`,无匹配时 `items` 为空、总数为 0。两者均支持 `AbortSignal`。当前仅百炼实现, +其他 Provider 返回明确的 unsupported 错误。 + +```ts +import { listModelUsage, listToolUsage } from "@openagentpack/sdk"; + +const models = await listModelUsage(ctx, { + scope: { type: "workspace", workspace_ids: [workspaceId] }, + time_range: { start_time, end_time }, + page_no: 1, page_size: 20, sort_by: "call_count", sort_order: "desc", +}); +const tools = await listToolUsage(ctx, { + scope: { type: "agent", agent_id }, + time_range: { start_time, end_time }, + source: "mcp", tool_name: "file-parser", +}); +``` + +### 自建后端原始事件的浏览器转换 + +自建后端透传百炼 SSE 时,调用方负责 HTTP、SSE 解帧、订阅就绪、历史分页与重试。 +纯转换入口只接受已经解析的百炼业务 JSON,不接受心跳、SSE `event/data/id` 文本或 Kit 控制帧: + +```ts +import { createBailianSessionEventNormalizer } from "@openagentpack/sdk/session-events"; + +const normalizer = createBailianSessionEventNormalizer({ + redact: false, + truncate: false, + maxEntries: 1024, +}); + +// 按顺序输入历史;然后输入已缓冲的实时业务帧。 +const historySnapshot = normalizer.seed(rawHistoricalEvent); +const liveSnapshot = normalizer.push(rawLiveFrame); +// 输出可能为 undefined;有输出时按 event_id 替换累计快照。 +// 重连重建或更换 Session 前清空,不能沿用未完成正文当新 delta 基线。 +normalizer.clear(); +``` + +`rawHistoricalEvent` 和 `rawLiveFrame` 均由调用方提供。每个逻辑订阅独立创建实例; +两个方法都直接返回 `SessionEvent | undefined`,无需再次调用 sanitizer。选项沿用 +`SessionEventSanitizerOptions`:默认脱敏、截断,默认不附加 `metadata.raw`。 + +- `seed` 区分 `in_progress` 和完成历史。未完成快照保留正文、消息身份、线程及运行状态供展示, + 但正文不成为后续 delta 的追加基线;后续局部分片及进行中快照被抑制,直到完成消息显式给出 + 整体 `content`。单个 `delta: false` 内容块不足以证明其他块完整。缺少最终正文会报协议错误。 +- 已完成的历史 message/reasoning 在本次重建中保护同 ID 正文,避免旧缓冲帧覆盖; + session_status 和工具事件仍允许同 ID 的完整状态更新。转换器不能推断跨事件的新旧顺序, + 调用方必须对历史与缓冲流建立可验证的交接边界。 +- `maxEntries` 默认 1024,限制保留的事件身份、孤立分片数量及单条消息的内容块数量。已输入的历史身份保留到 + `clear()`;超过限制明确报错,不静默丢弃历史保护。调用方还应限制输入字节数、历史总量、 + 建连/空闲时间并在失败或取消后清理实例。不同连接的去重和重试不属于该纯转换接口。 +- 浏览器只访问业务后端,不需要也不应取得百炼凭据。这个入口不改变 SDK 主入口的 + `legacy/snapshot` 默认行为,也不自动打开网络、发送消息或执行审批。 + +### 断流恢复、结束与取消 + +`reconnect: true` 在意外 EOF、网络故障、429 或 5xx 后最多重试 3 次,等待时间依次为 +250、500、1000 毫秒。鉴权、参数和协议错误直接失败。主动取消不会重连。 +`snapshot` 模式将意外 EOF 作为断流错误,不把它合成为业务完成事件;旧模式保留原有行为。 + +恢复时先建立新订阅并缓冲实时帧,再按升序分页查询历史,归并完成事件后继续处理实时数据。 +它只恢复订阅,**不会重新发送用户消息或启动新的 Agent 执行**。 +已交付事件的同 ID 变化快照仍会更新调用方,不因位于恢复标记或其之前而丢弃; +恢复得到的本轮结束状态在历史消息修复完成后交付,避免提前结束而遗漏最终答案。 +百炼没有在本 SDK 中确认的原生逐分片续传合同,`after_id` 在快照模式中作为本地历史核对 +标记,不作为原生游标发送给百炼;旧模式的历史轮询回退保持不变。 +在旧模式同时传入 `after_id` 和 `signal`、`onReady` 或超时配置会明确报错;需要这些控制时使用快照模式。 + +恢复目标是最终消息收敛,无法保证断开期间每个 token 都恰好重放一次。SDK 不会盲目把 +重连后的分片追加到断开前的半截内容;缺少可靠基线时等待最终快照或历史完成事件。 +缺失历史标记、重复分页游标、耗尽重试或缓冲超过 1024 帧/8 MiB 会明确报错,不静默丢内容。 + +单条消息完成不等于整个 Session 流结束。直接订阅保持持续接收;单轮发送入口根据会话状态 +结束本轮消费。调用对应的 `AbortController.abort()` 会取消读取及恢复工作,退出迭代器也会释放连接。 +发送请求尚未返回时取消会停止 SDK 的等待,但不表示 Provider 已取消执行,也不会重新发送消息。 + +此接口描述不表示已发布到 npm。协议 fixture、字节分块及模拟 HTTP 测试验证 SDK 行为, +不构成真实 Cloud SSE 或已安装下游版本的验证结果。 + ## Service APIs The public entry exposes domain workflows that return structured domain results (sessions, plans, diagnostics, resources, provider-neutral metadata). It does **not** return terminal rows, React view models, HTTP envelopes, SSE wrappers, or localized strings. @@ -39,10 +358,11 @@ The public entry exposes domain workflows that return structured domain results | Sync & migrate | `resolveSyncProvider`, `syncProviderResourcesFromContext`, `syncProviderResourcesFromEnv`, `migrateConfig` | | Destroy | `planDestroyProjectContext`, `destroyPlannedProjectResources` | | Agent | `buildAgentDecl`, `getAgent`, `listAgentsWithReadiness`, `listCloudAgents`, `archiveCloudAgent`, `syncAgentResourcesWithStateBackend`, `createCloudEnvironment`, `deleteCloudEnvironment`, `listCloudEnvironments`, `createCloudVault`, `deleteCloudVault`, `listCloudVaults` | -| Session | `createSessionForAgent`, `startSessionRun`, `startSessionRunPolling`, `sendSessionMessageStreaming`, `sendSessionMessagePolling`, `streamSessionEvents`, `getSession`, `listSessionSummaries`, `listSessionEvents`, `deleteSession`, `isTerminalSessionStatus`, `resolveSessionProvider` | +| Session | `createSessionForAgent`, `startSessionRun`, `startSessionRunPolling`, `sendSessionMessageStreaming`, `sendSessionMessagePolling`, `streamSessionEvents`, `getSession`, `listSessionSummaries`, `listSessionEvents`, `listSessionThreads`, `listSessionThreadEvents`, `deleteSession`, `isTerminalSessionStatus`, `resolveSessionProvider` | | Files & skills | `uploadFile`, `listFiles`, `getFileInfo`, `getFileDownloadUrl`, `deleteFile`, `createSkillFromFileId`, `listSkills`, `getSkillInfo`, `deleteSkill` | | Deployment | `listDeploymentsForContext`, `getDeploymentDetailsForContext`, `getDeploymentRuntimeProviderForContext`, `runDeploymentForContext` | | Models | `listProviderModelsForContext`, `listProviderNames` | +| Usage | `listModelUsage`, `listToolUsage` | | State | `StateManager`, `LocalFileStateBackend`, `parseStateAddress` | | Runtime context | `createProjectRuntime`, `readProjectRuntime`, `writeProjectRuntime` | | Provider config | `resolveProviderConfigFromEnv`, `applyProviderConfigToEnv`, `loadDotEnv`, `bootstrapRuntimeCredentials` (and sync variants), `resolveActiveProvider`, `AGENTS_CONFIG_PROVIDERS`, `AGENTS_PROVIDER_FIELDS` | diff --git a/package.json b/package.json index 8c848cc..b8ba32d 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,7 @@ "bugs": { "url": "https://github.com/modelstudioai/OpenAgentPack/issues" }, - "packageManager": "bun@1.3.5", + "packageManager": "bun@1.4.4", "workspaces": [ "apps/*", "packages/*" @@ -63,7 +63,7 @@ }, "devDependencies": { "@ast-grep/cli": "^0.44.1", - "@biomejs/biome": "^2.5.3", + "@biomejs/biome": "2.5.3", "@changesets/cli": "^2.31.0", "@types/bun": "^1.3.14", "braces": "file:vendor/braces", @@ -80,12 +80,16 @@ "esbuild": "0.28.1", "fast-equals": "5.3.3", "js-yaml": "4.3.2", + "minimatch": "11.0.3", "nanoid": "3.3.18", "postcss": "8.5.23", "prosemirror-model": "1.25.11", "prosemirror-view": "1.42.3", "source-map-js": "1.2.2" }, + "patchedDependencies": { + "@redocly/openapi-core@1.34.22": "patches/@redocly%2Fopenapi-core@1.34.22.patch" + }, "trustedDependencies": [ "@ast-grep/cli" ] diff --git a/packages/cli/src/commands/init.ts b/packages/cli/src/commands/init.ts index 56c711c..21cfb0b 100644 --- a/packages/cli/src/commands/init.ts +++ b/packages/cli/src/commands/init.ts @@ -110,7 +110,8 @@ async function promptForProjectOptions( } const normalizedAgentName = agentName.trim(); if (!normalizedAgentName) throw new UserError("Agent name cannot be empty."); - return { provider: parseProvider(provider), agentName: normalizedAgentName }; + // @clack/prompts 1.8 的 isCancel 谓词不再收窄 string | symbol;取消分支已提前退出,此处必为 string。 + return { provider: parseProvider(provider as string), agentName: normalizedAgentName }; } export async function initCommand(options: InitCommandOptions): Promise { diff --git a/packages/playground/package.json b/packages/playground/package.json index 00ddc3a..24363f2 100644 --- a/packages/playground/package.json +++ b/packages/playground/package.json @@ -40,13 +40,13 @@ "typecheck": "tsc --noEmit" }, "dependencies": { - "@hono/node-server": "^2.0.5", + "@hono/node-server": "^2.1.6", "@hono/zod-openapi": "^1.4.0", "@openagentpack/sdk": "workspace:*", "chokidar": "^4.0.3", - "hono": "^4.13.5", + "hono": "^4.13.11", "yaml": "^2.9.0", - "zod": "^4.4.3" + "zod": "^4.6.6" }, "devDependencies": { "@types/bun": "^1.3.14", diff --git a/packages/sdk/README.md b/packages/sdk/README.md index b881332..72349f0 100644 --- a/packages/sdk/README.md +++ b/packages/sdk/README.md @@ -37,6 +37,66 @@ default entry point. See the [configuration guide](https://github.com/modelstudioai/OpenAgentPack/blob/main/docs/configuration.md), [provider reference](https://github.com/modelstudioai/OpenAgentPack/blob/main/docs/providers.md), and [SDK documentation](https://github.com/modelstudioai/OpenAgentPack/tree/main/packages/sdk/docs). +## 百炼 Session 流恢复 + +旧调用默认仍使用 `legacy`,不启用快照、增量或自动重连;sanitizer 默认脱敏和截断保持开启。 +显式使用 `snapshot` 的单轮发送在恢复时,以本次 POST 返回的事件 ID 限定历史回放, +避免上一轮的回复或结束状态提前结束本轮。缺少发送事件 ID 或历史中找不到该边界时,恢复会明确报错; +正常实时消费不要求发送响应带 ID,也不要求 SSE 回显用户消息。 + +恢复历史中仍有未完成消息时,SDK 先等待完整实时快照,再依据其后的实时会话状态决定 +单轮结束,避免历史 `idle` 抢先截断回复。等待仍受恢复超时与取消控制;无法确认完成时 +明确失败,不将半截回复作为正常完成,也不会重发用户消息。 +等待完整快照及其后实时状态时,每次读取受 `connectTimeoutMs`(默认 30 秒)限制; +历史已经完整的恢复保持原有事件顺序。 + +取消订阅后停止交付实时缓冲和历史回放事件,并释放连接;取消观察不表示取消 Provider 执行。 + +## 浏览器中的百炼原始事件转换 + +自建后端透传原始 SSE 时,可从 `@openagentpack/sdk/session-events` 导入 +`createBailianSessionEventNormalizer()`。`seed(raw)` 输入历史,`push(raw)` 输入已经解帧的 +实时 JSON,均返回累计 `SessionEvent | undefined`;`clear()` 释放订阅状态。 +每个订阅使用独立实例。默认脱敏、截断保持开启,完整正文显式传 +`{ redact: false, truncate: false }`,不默认返回 raw。 + +进行中历史只供展示,不能成为新 delta 的追加基线;恢复需等待完整消息快照。 +已输入历史的身份受 `maxEntries`(默认 1024)限制,溢出明确失败。 +网络、凭据、就绪保证及重试仍由调用方后端和接入层负责。 +详见 [SDK 参考](../../docs/reference/sdk.md#自建后端原始事件的浏览器转换)。 + +## 资源 Plan、执行结果与错误合同 + +目录项目与对象/YAML 入口共用资源执行器。服务端集成可在计划与执行时分别显式选择 +`resultDetail: "structured"`: + +```ts +const planned = await planProjectContext(context, { resultDetail: "structured" }); +// 将 planned.fingerprint 与调用方的声明修订、上传内容一起绑定到显式确认。 +const result = await executePlannedProject(planned, { + resultDetail: "structured", + policy: "force", // 仅在调用方已经核验用户确认后使用。 +}); +``` + +计划新增 `resource-plan-v1:` 前缀的语义指纹,不包含展示文案、时间戳、凭据或远端原始快照。 +执行新增 `outcome`(succeeded/failed/partial/unknown)、`mutationStarted`,以及每项的 +`resource.remoteId/version`、安全 `errorInfo`(code/phase/message/retryable/mutationStarted/httpStatus)。 +抛出的 `ResourceRuntimeError` 携带安全 `info` 与已取得的 `execution`,原异常保留在 cause。 +通过 `syncProjectResourcesWithStateBackend` 执行时,Backend 在工作流返回后的最终保存失败 +同样报告 `persist_state`,保留已完成的逐资源结果与 ID;发生过远端写入时整体结果为 `unknown`。 +原有 `error` 字符串、异常 message/cause 可能含 Provider 原文,服务端不得直接传给浏览器或写入日志。 + +`mutationStarted=false` 才能证明本次执行未调用 Provider 写方法;调用后报错保守标记 unknown。 +`retryable` 只描述临时性错误,不代表可以重发写请求。partial/unknown 不自动重试或回滚。 +已取得的资源身份不是完整发布成功证明,调用方仍须负责状态、回执与恢复策略。 +结构化报告保留 Provider 已返回的资源身份,包括 Vault 创建成功但后续凭据创建失败、 +删除完成后 State 中已移除的身份。多步创建尚未完成时不把该资源写成已收敛的 State; +报告中的已知 ID 不代表可以自动重发、回滚或生成成功证明。 + +省略 `resultDetail`(或选择 `legacy`)保留原返回字段、partial 语义、异常类型与消息; +现有 CLI 无须接入新字段,不改变退出码、JSON 输出或确认策略。 + ## License Apache-2.0. See the [repository license](https://github.com/modelstudioai/OpenAgentPack/blob/main/LICENSE). diff --git a/packages/sdk/docs/public-api-layers.md b/packages/sdk/docs/public-api-layers.md index 50e9f70..cb3b984 100644 --- a/packages/sdk/docs/public-api-layers.md +++ b/packages/sdk/docs/public-api-layers.md @@ -19,6 +19,13 @@ Interface packages such as `@openagentpack/cli` and `@openagentpack/webui` shoul SDK as a domain service layer, not as a bag of parser, state, provider, planner, or executor primitives. +## 浏览器事件转换边界 + +`./session-events` 提供 `createBailianSessionEventNormalizer` 这一纯领域转换服务, +将已经解帧的百炼业务 JSON 归并为现有 `SessionEvent`。公开面仅有 +`push`、`seed`、`clear`,不暴露内部累加器或 Provider 类型,不包含 HTTP、凭据和重试策略。 +已有单事件 mapper 与 sanitizer 继续保留;SDK 主入口和调用方默认行为不变。 + ## Service APIs The public entry exposes domain workflows that return structured domain results. @@ -29,10 +36,16 @@ New CLI and WebUI behavior should start here. planning, and sync. - Managed-resource reads: environment, skill/version/download, vault, and file metadata/content APIs with opaque cursor preservation. +- Usage analytics: 百炼的 `listModelUsage` 与 `listToolUsage` 提供 workspace/agent/session + scope 的模型调用与工具调用聚合(调用/失败次数、Token 明细、来源与名称过滤、分页排序)。 + REST 映射与百炼侧约定为 `POST /usage/models`、`POST /usage/tools`(顶层请求体); + 公网 AgentStudio 环境尚未启用(网关 404),启用后调用即通。仅百炼实现,其他 + Provider 返回明确的 unsupported 错误。 - Session workflows: creation, list/get/update/archive/delete, runs, follow-up - messages, raw event send/list/stream, and summaries. Managed Agents child - threads remain event metadata (`session_thread_id`); there is no independent - public Thread resource API. + messages, raw event send/list/stream, and summaries. 百炼子 Agent 的 + `listSessionThreads` 与 `listSessionThreadEvents` 提供 Thread 列表和分页历史; + 主 Agent 不在子线程列表中,实时事件仍通过 Session 流获取。SDK 不提供 Thread + 创建、归档或独立流。事件与线程类型复用公开合同,浏览器只从 `./session-events` 导入。 - Deployment workflows: list/get/search, run history, run, pause, and unpause. - Operation capabilities: provider-scoped support/auth/reason metadata for API-oriented command hosts. diff --git a/packages/sdk/docs/state-backends.md b/packages/sdk/docs/state-backends.md index f6adaca..6a79bc9 100644 --- a/packages/sdk/docs/state-backends.md +++ b/packages/sdk/docs/state-backends.md @@ -63,3 +63,15 @@ For WebUI or multi-tenant hosts, derive `StateScope` from authenticated tenant/p For OSS-like object storage, treat the object store as durable blob storage and history, not as a complete state coordination system. Use an external lock backend for multi-writer deployments unless the object-store adapter can prove safe conditional writes for the exact update flow. OpenAgentPack infrastructure state must remain infrastructure-only. Provider Sessions, WebUI tasks, event history, artifacts, and task-to-session mappings belong in host-owned product storage, not in OpenAgentPack state. + +## 宿主数据库中的检查点 + +公开的 `InMemoryStateManager.fromJSON(snapshot, onSave?)` 接收已有 SDK state 和可选保存回调; +`empty(onSave?)` 创建空账本。`toJSON()` 返回隔离副本。`save()` 按调用顺序将当时的快照交给 +回调,存储失败向调用方报告;没有回调时继续保持原有的纯内存行为。宿主通过 `StateBackend` +实现数据库读取、作用域隔离及写互斥,网络调用期间不要持有数据库事务。只读运行时使用无保存 +回调的隔离副本,不能将规划过程中刷新出的 state 自动提交。 + +表单宿主可以通过 `resolveProjectConfigFromObject` 的 `textFileReferences: "literal"` +将提示词和记忆条目按正文解析;默认 `"resolve"` 保留原有文件读取行为。此选项不改变 File、 +Skill 的来源语义,也不绕过 SDK 声明校验。凭据仍由宿主仅在服务端运行时传入。 diff --git a/packages/sdk/package.json b/packages/sdk/package.json index 076d81e..8ed27e5 100644 --- a/packages/sdk/package.json +++ b/packages/sdk/package.json @@ -78,7 +78,7 @@ "dependencies": { "jszip": "^3.10.1", "yaml": "^2.9.0", - "zod": "^4.4.3" + "zod": "^4.6.6" }, "devDependencies": { "@types/bun": "^1.3.14", diff --git a/packages/sdk/src/index.ts b/packages/sdk/src/index.ts index 510fab8..485e21a 100644 --- a/packages/sdk/src/index.ts +++ b/packages/sdk/src/index.ts @@ -3,6 +3,13 @@ // ./internal and are deliberately not exported — do not add internal-only symbols here. export { UserError } from "./internal/errors.ts"; +export { ResourceRuntimeError } from "./internal/resource-runtime-error.ts"; +export type { + ResourceErrorInfo, + ResourceErrorPhase, + ResourceExecutionOutcome, + ResourceResultDetail, +} from "./internal/types/resource-result.ts"; // Server-side HTTP errors thrown by provider clients. Exported so hosts (CLIs, // servers) can branch on them and surface statusCode/responseBody structurally // instead of parsing the message string. @@ -92,6 +99,7 @@ export type { DestructivePolicy, ResourceActionResult, ResourceExecutionResult, + ResourceExecutionOptions, ResourcePlanResult, ResourcePlanScope, ResourceRefreshResult, @@ -151,6 +159,7 @@ export { getRemoteDeployment, getRemoteDeploymentRun, getRemoteEnvironment, + getRemoteSessionResource, getRemoteSkill, getRemoteSkillDownloadInfo, getRemoteSkillVersion, @@ -161,12 +170,15 @@ export { listRemoteDeployments, listRemoteEnvironments, listRemoteFiles, + listRemoteSessionResources, listRemoteSkills, listRemoteSkillVersions, listRemoteVaults, + mountRemoteSessionResource, runRemoteDeployment, sendRemoteSessionEvents, setRemoteDeploymentPaused, + unmountRemoteSessionResource, updateRemoteSession, } from "./internal/core/managed-api-runtime.ts"; export type { ManagedApiTarget } from "./internal/core/managed-api-runtime.ts"; @@ -187,6 +199,9 @@ export type { ManagedAgentProviderCapabilities, SessionEventInput, SessionEventSendResult, + SessionResourceListOptions, + SessionResourceMountInput, + SessionResourcePage, SessionUpdateInput, SkillDownloadInfo, SkillListOptions, @@ -354,10 +369,32 @@ export type { export type { EventListOptions, EventStreamOptions, + SessionEventFormat, ProviderSessionEvent, ProviderSessionEventList, } from "./internal/types/session-event.ts"; export type { ProviderFileInfo } from "./internal/types/file.ts"; +export { listSessionThreadEvents, listSessionThreads } from "./internal/core/session-thread-runtime.ts"; +export type { SessionThread, SessionThreadListOptions, SessionThreadPage } from "./internal/types/session-thread.ts"; +export { listModelUsage, listToolUsage } from "./internal/core/usage-runtime.ts"; +export type { UsageRuntimeOptions } from "./internal/core/usage-runtime.ts"; +export type { + ModelUsageItem, + ModelUsagePage, + ModelUsageRequest, + ModelUsageSortBy, + ToolUsageItem, + ToolUsagePage, + ToolUsageRequest, + ToolUsageSortBy, + UsagePage, + UsageQueryOptions, + UsageScope, + UsageSortOrder, + UsageTimeRange, + UsageTokenStats, + UsageToolSource, +} from "./internal/types/usage.ts"; export type { ProviderSkillInfo } from "./internal/types/skill-info.ts"; export { parseStateAddress } from "./internal/core/state-runtime.ts"; @@ -366,7 +403,9 @@ export type { ResourceState } from "./internal/types/state.ts"; export type { IStateManager } from "./internal/state/state-manager.ts"; export { StateManager } from "./internal/state/state-manager.ts"; export { LocalFileStateBackend } from "./internal/state/local-file-state-backend.ts"; -export type { StateScope } from "./internal/state/backend.ts"; +export { InMemoryStateManager } from "./internal/state/in-memory-state-manager.ts"; +export type { StateFile } from "./internal/types/state.ts"; +export type { StateScope, StateBackend } from "./internal/state/backend.ts"; export { extractSkillZipFiles } from "./internal/utils/normalize-skill-zip.ts"; export { inspectSkillSource } from "./internal/core/skill-source.ts"; diff --git a/packages/sdk/src/internal/core/managed-api-runtime.ts b/packages/sdk/src/internal/core/managed-api-runtime.ts index 04ddb6b..e740a00 100644 --- a/packages/sdk/src/internal/core/managed-api-runtime.ts +++ b/packages/sdk/src/internal/core/managed-api-runtime.ts @@ -20,6 +20,9 @@ import type { ManagedAgentProviderCapabilities, SessionEventInput, SessionEventSendResult, + SessionResourceListOptions, + SessionResourceMountInput, + SessionResourcePage, SessionUpdateInput, SkillDownloadInfo, SkillListOptions, @@ -30,9 +33,10 @@ import type { VaultListOptions, VaultPage, } from "../types/managed-api.ts"; -import type { ProviderSessionInfo } from "../types/session.ts"; +import type { ProviderSessionInfo, SessionResourceInfo } from "../types/session.ts"; import type { ProviderSkillInfo } from "../types/skill-info.ts"; import { + type ManagedApiContext, requireManagedApiMethod as requiredMethod, resolveManagedApiAdapter as resolveAdapter, } from "./managed-api-context.ts"; @@ -54,11 +58,14 @@ export async function listRemoteAgents( export async function getRemoteAgent( ctx: ProjectRuntimeContext, id: string, - options: ManagedApiTarget & { version?: number } = {}, + options: ManagedApiTarget & { version?: number; signal?: AbortSignal } = {}, ) { const adapter = resolveAdapter(ctx, options.provider); const method = requiredMethod(adapter.getRemoteAgent, adapter.name, "agent lookup"); - return method.call(adapter, id, options.version); + options.signal?.throwIfAborted(); + const result = await method.call(adapter, id, options.version, { signal: options.signal }); + options.signal?.throwIfAborted(); + return result; } export async function listRemoteAgentVersions( @@ -206,6 +213,49 @@ export async function archiveRemoteSession( return method.call(adapter, id); } +export async function mountRemoteSessionResource( + ctx: ManagedApiContext, + sessionId: string, + input: SessionResourceMountInput, + options: ManagedApiTarget = {}, +): Promise { + const adapter = resolveAdapter(ctx, options.provider); + const method = requiredMethod(adapter.mountSessionResource, adapter.name, "session resource mounting"); + return method.call(adapter, sessionId, input); +} + +export async function listRemoteSessionResources( + ctx: ManagedApiContext, + sessionId: string, + options: ManagedApiTarget & SessionResourceListOptions = {}, +): Promise { + const adapter = resolveAdapter(ctx, options.provider); + const method = requiredMethod(adapter.listSessionResources, adapter.name, "session resource listing"); + return method.call(adapter, sessionId, options); +} + +export async function getRemoteSessionResource( + ctx: ManagedApiContext, + sessionId: string, + resourceId: string, + options: ManagedApiTarget = {}, +): Promise { + const adapter = resolveAdapter(ctx, options.provider); + const method = requiredMethod(adapter.getSessionResource, adapter.name, "session resource lookup"); + return method.call(adapter, sessionId, resourceId); +} + +export async function unmountRemoteSessionResource( + ctx: ManagedApiContext, + sessionId: string, + resourceId: string, + options: ManagedApiTarget = {}, +): Promise { + const adapter = resolveAdapter(ctx, options.provider); + const method = requiredMethod(adapter.unmountSessionResource, adapter.name, "session resource unmounting"); + return method.call(adapter, sessionId, resourceId); +} + export async function sendRemoteSessionEvents( ctx: ProjectRuntimeContext, id: string, @@ -292,7 +342,7 @@ const UNSUPPORTED_THREAD: ManagedAgentOperationCapability = { supported: false, auth: null, reason: - "Managed Agents exposes child-thread ids and lifecycle events through Session Events, but no independent Thread resource API.", + "This SDK currently supports child-thread listing and event history; thread lookup and archive are not implemented.", }; const UNSUPPORTED_OAUTH: ManagedAgentOperationCapability = { supported: false, @@ -364,10 +414,10 @@ const BAILIAN_OPERATIONS: Record = { "file.delete": API_KEY, "model.list": UNSUPPORTED_MODEL, "model.search": UNSUPPORTED_MODEL, - "session_thread.list": UNSUPPORTED_THREAD, + "session_thread.list": API_KEY, "session_thread.get": UNSUPPORTED_THREAD, "session_thread.archive": UNSUPPORTED_THREAD, - "session_thread.events": UNSUPPORTED_THREAD, + "session_thread.events": API_KEY, "mcp.oauth_login": UNSUPPORTED_OAUTH, }; diff --git a/packages/sdk/src/internal/core/resource-runtime.ts b/packages/sdk/src/internal/core/resource-runtime.ts index 50717c2..9e49e59 100644 --- a/packages/sdk/src/internal/core/resource-runtime.ts +++ b/packages/sdk/src/internal/core/resource-runtime.ts @@ -1,4 +1,11 @@ import { UserError } from "../errors.ts"; +import { ExecutionReportTracker } from "../executor/execution-report.ts"; +import { resourcePlanFingerprint } from "../planner/plan-fingerprint.ts"; +import { resourceErrorInfo, resourceRuntimeError } from "../resource-runtime-error.ts"; +import type { ResourceExecutionResult, ResourceResultDetail } from "../types/resource-result.ts"; + +export type { ResourceActionResult, ResourceExecutionResult } from "../types/resource-result.ts"; + import { type ExecutionResult, executePlan } from "../executor/executor.ts"; import { buildDependencyGraph, collectDependencyClosure } from "../graph/dependency.ts"; import { getResourceDeclaration } from "../planner/declaration.ts"; @@ -24,6 +31,7 @@ export interface ResourceRuntimeOptions extends DestructiveDecisionOptions { quiet?: boolean; onFeedback?: RuntimeFeedbackSink; concurrency?: number; + resultDetail?: ResourceResultDetail; } export type ResourceSyncMode = "reconcile" | "create-only"; @@ -35,21 +43,16 @@ export interface ResourcePlanScope { export interface ResourceRefreshResult { removed: ResourceState[]; - errors: Array<{ resource: ResourceState; error: string }>; -} - -export interface ResourceActionResult { - action: PlannedAction; - status: "success" | "failed" | "skipped"; - error?: string; -} - -export interface ResourceExecutionResult { - results: ResourceActionResult[]; - partial: boolean; + errors: Array<{ + resource: ResourceState; + error: string; + errorInfo?: import("../types/resource-result.ts").ResourceErrorInfo; + }>; } export interface ResourcePlanResult { + /** Only present when resultDetail is structured. */ + fingerprint?: string; executionContext: ProjectRuntimeContext; plan: ExecutionPlan; refreshResult?: ResourceRefreshResult; @@ -82,25 +85,47 @@ export async function syncProjectResourcesWithStateBackend( input: BackendRuntimeInput, options: ResourceRuntimeOptions = {}, ): Promise { - return writeProjectRuntime(input, async (ctx) => { - const planned = await planProjectContext(ctx, options); - if (options.refreshOnly) { - return { planned }; - } - if (options.mode === "create-only") { - const errorDiagnostic = planned.plan.diagnostics.find((diagnostic) => diagnostic.severity === "error"); - if (errorDiagnostic) throw new UserError(errorDiagnostic.message); - } - return { - planned, - execution: await executePlannedProject(planned, { - onFeedback: options.onFeedback, - policy: options.policy, - confirm: options.confirm, - concurrency: options.concurrency, - }), - }; - }); + let completed: ResourceSyncRun | undefined; + try { + return await writeProjectRuntime(input, async (ctx) => { + const planned = await planProjectContext(ctx, options); + if (options.refreshOnly) { + completed = { planned }; + return completed; + } + if (options.mode === "create-only") { + const errorDiagnostic = planned.plan.diagnostics.find((diagnostic) => diagnostic.severity === "error"); + if (errorDiagnostic) { + const error = new UserError(errorDiagnostic.message); + if (options.resultDetail === "structured") + throw resourceRuntimeError(error, { code: errorDiagnostic.code, phase: "plan", mutationStarted: false }); + throw error; + } + } + completed = { + planned, + execution: await executePlannedProject(planned, { + onFeedback: options.onFeedback, + policy: options.policy, + confirm: options.confirm, + concurrency: options.concurrency, + resultDetail: options.resultDetail, + }), + }; + return completed; + }); + } catch (error) { + if (options.resultDetail !== "structured" || !completed) throw error; + // A backend may commit after the workflow returns; retain its execution + // facts until that final persistence step has also succeeded. + const execution = completed.execution; + const mutationStarted = execution?.mutationStarted ?? false; + throw resourceRuntimeError( + error, + { code: "resource.state_persist_failed", phase: "persist_state", mutationStarted }, + execution ? { ...execution, outcome: mutationStarted ? "unknown" : "failed" } : undefined, + ); + } } const IMPORTABLE_RESOURCE_TYPES = new Set([ @@ -222,6 +247,21 @@ export async function importResource( export async function planProjectContext( ctx: ProjectRuntimeContext, options: ResourceRuntimeOptions = {}, +): Promise { + try { + const planned = await planProjectContextInner(ctx, options); + if (options.resultDetail === "structured") planned.fingerprint = resourcePlanFingerprint(planned); + return planned; + } catch (error) { + if (options.resultDetail === "structured") + throw resourceRuntimeError(error, { phase: "plan", mutationStarted: false }); + throw error; + } +} + +async function planProjectContextInner( + ctx: ProjectRuntimeContext, + options: ResourceRuntimeOptions = {}, ): Promise { if (options.mode === "create-only" && !options.scope) { throw new UserError("Resource create-only mode requires an explicit resource scope."); @@ -249,13 +289,18 @@ export async function planProjectContext( resourceAddresses: selectedAddresses, }); if (options.mode === "create-only" && options.scope) { - plan = enforceCreateOnlyPlan(plan, options.scope, toResourceRefreshResult(refreshResult), ctx.state); + plan = enforceCreateOnlyPlan( + plan, + options.scope, + toResourceRefreshResult(refreshResult, options.resultDetail === "structured"), + ctx.state, + ); } return { executionContext: ctx, plan, - refreshResult: toResourceRefreshResult(refreshResult), + refreshResult: toResourceRefreshResult(refreshResult, options.resultDetail === "structured"), targetProviders, destructiveActions: selectDestructive(plan.actions), selectedAddresses, @@ -342,16 +387,46 @@ function resolvePlanScope( return scope.includeDependencies === false ? [...scope.roots] : collectDependencyClosure(graph, scope.roots); } +export interface ResourceExecutionOptions extends DestructiveDecisionOptions { + onFeedback?: RuntimeFeedbackSink; + concurrency?: number; + resultDetail?: ResourceResultDetail; +} + export async function executePlannedProject( planned: ResourcePlanResult, - options: DestructiveDecisionOptions & { - onFeedback?: RuntimeFeedbackSink; - concurrency?: number; - } = {}, + options: ResourceExecutionOptions = {}, +): Promise { + if (options.resultDetail !== "structured") return executePlannedProjectInner(planned, options); + const tracker = new ExecutionReportTracker(planned.plan.actions, planned.executionContext.state); + try { + await executePlannedProjectInner(planned, options, tracker); + return tracker.report(); + } catch (error) { + throw resourceRuntimeError( + error, + { + phase: tracker.mutationStarted ? "execute" : "prepare", + mutationStarted: tracker.mutationStarted, + }, + tracker.report(error), + ); + } +} + +async function executePlannedProjectInner( + planned: ResourcePlanResult, + options: ResourceExecutionOptions, + tracker?: ExecutionReportTracker, ): Promise { if (planned.mode === "create-only") { const errorDiagnostic = planned.plan.diagnostics.find((diagnostic) => diagnostic.severity === "error"); - if (errorDiagnostic) throw new UserError(errorDiagnostic.message); + if (errorDiagnostic) { + const error = new UserError(errorDiagnostic.message); + if (options.resultDetail === "structured") + throw resourceRuntimeError(error, { code: errorDiagnostic.code, phase: "plan", mutationStarted: false }); + throw error; + } } const decision = await decideDestructive(planned.destructiveActions, { @@ -359,26 +434,33 @@ export async function executePlannedProject( confirm: options.confirm, }); if (decision !== "proceed") { - throw new UserError( + const error = new UserError( decision === "cancelled" ? "Destructive actions were declined. No remote resources were changed." : "Current plan contains destructive actions. Apply will not delete remote resources.", ); + if (tracker) + throw resourceRuntimeError(error, { + code: decision === "cancelled" ? "resource.cancelled" : "resource.policy_blocked", + phase: "prepare", + mutationStarted: false, + }); + throw error; } const ctx = planned.executionContext; - const execution = await executePlan( - planned.plan, - { - config: ctx.config, - configPath: ctx.configPath, - providers: ctx.providers, - state: ctx.state, - onFeedback: options.onFeedback, - createOnly: planned.mode === "create-only", - }, - { concurrency: options.concurrency }, - ); + const context = { + config: ctx.config, + configPath: ctx.configPath, + providers: ctx.providers, + state: ctx.state, + onFeedback: options.onFeedback, + createOnly: planned.mode === "create-only", + }; + const execution = await executePlan(planned.plan, tracker ? tracker.context(context) : context, { + concurrency: options.concurrency, + tracker, + }); return toResourceExecutionResult(execution); } @@ -411,20 +493,22 @@ export async function decideDestructive( } export function replaceResourcePlan(planned: ResourcePlanResult, plan: ExecutionPlan): ResourcePlanResult { - return { - ...planned, - plan, - destructiveActions: selectDestructive(plan.actions), - }; + const updated = { ...planned, plan, destructiveActions: selectDestructive(plan.actions) }; + if (planned.fingerprint) updated.fingerprint = resourcePlanFingerprint(updated); + return updated; } -function toResourceRefreshResult(result: RefreshResult | undefined): ResourceRefreshResult | undefined { +function toResourceRefreshResult( + result: RefreshResult | undefined, + structured = false, +): ResourceRefreshResult | undefined { if (!result) return undefined; return { removed: result.removed, errors: result.errors.map((item) => ({ resource: item.resource, error: item.error.message, + ...(structured ? { errorInfo: resourceErrorInfo(item.error, { phase: "plan", mutationStarted: false }) } : {}), })), }; } diff --git a/packages/sdk/src/internal/core/session-event-list-options.ts b/packages/sdk/src/internal/core/session-event-list-options.ts new file mode 100644 index 0000000..92b99d3 --- /dev/null +++ b/packages/sdk/src/internal/core/session-event-list-options.ts @@ -0,0 +1,31 @@ +import type { EventListOptions, ProviderSessionEventList } from "../types/session-event.ts"; + +/** Keep SDK-only routing options out of provider requests; normalize the legacy page alias. */ +export function sessionEventListOptions(options: EventListOptions): EventListOptions | undefined { + const result: EventListOptions = {}; + for (const key of [ + "event_format", + "signal", + "limit", + "order", + "types", + "created_at_gt", + "created_at_gte", + "created_at_lt", + "created_at_lte", + ] as const) { + if (options[key] !== undefined) Object.assign(result, { [key]: options[key] }); + } + const pageToken = options.page_token ?? options.page; + if (pageToken !== undefined) result.page_token = pageToken; + return Object.keys(result).length ? result : undefined; +} + +export function filterSessionEventPage( + result: ProviderSessionEventList, + types: string[] | undefined, +): ProviderSessionEventList { + if (!types?.length) return result; + const allowedTypes = new Set(types); + return { ...result, events: result.events.filter((event) => allowedTypes.has(event.raw_type)) }; +} diff --git a/packages/sdk/src/internal/core/session-event-sanitizer.ts b/packages/sdk/src/internal/core/session-event-sanitizer.ts index 9599ccf..8fb6806 100644 --- a/packages/sdk/src/internal/core/session-event-sanitizer.ts +++ b/packages/sdk/src/internal/core/session-event-sanitizer.ts @@ -24,17 +24,28 @@ function hasDocumentContent(text: string): boolean { return false; } +export interface SessionEventSanitizerOptions { + /** Include raw provider data using the selected redaction/truncation policies. Defaults to false. */ + includeRaw?: boolean; + /** Apply sensitive-text redaction. Defaults to true; independent of truncation. */ + redact?: boolean; + /** Apply the legacy text-size limits. Defaults to true; independent of redaction. */ + truncate?: boolean; +} + export function sanitizeSessionEvents( events: ProviderSessionEvent[], - options: { includeRaw?: boolean } = {}, + options: SessionEventSanitizerOptions = {}, ): SessionEvent[] { return events.map((event) => sanitizeSessionEvent(event, options)); } export function sanitizeSessionEvent( event: ProviderSessionEvent, - options: { includeRaw?: boolean } = {}, + options: SessionEventSanitizerOptions = {}, ): SessionEvent { + if (event.snapshot) return sanitizeSnapshot(event, event.snapshot, options); + // Map the engine's (already 7-classified) provider event up to the snake_case // contract event, preserving the original Agents `type` via `raw_type` so no detail // is dropped. Transport concerns added here: secret redaction + truncation, @@ -43,16 +54,23 @@ export function sanitizeSessionEvent( // presentation layer can read them uniformly). const isToolEvent = event.type === "tool_result" || event.type === "tool_use"; const primarySource = event.content ?? (event.type === "tool_use" ? event.tool_input : undefined); - // Pick a truncation limit appropriate to the content: tool events get 8 000 chars, - // message events containing self-contained documents get 32 000, everything else 4 000. - const textLimit = isToolEvent - ? TOOL_TEXT_LIMIT - : typeof primarySource === "string" && hasDocumentContent(primarySource) - ? DOCUMENT_TEXT_LIMIT - : DEFAULT_TEXT_LIMIT; - const primary = sanitizeOptionalText(primarySource, textLimit); - const raw = options.includeRaw ? sanitizeUnknown(event.raw, TOOL_TEXT_LIMIT * 2) : undefined; - const redacted = Boolean(primary?.redacted || raw?.redacted); + // Preserve the existing limits unless the caller explicitly requests complete content. + const textLimit = + options.truncate === false + ? Number.POSITIVE_INFINITY + : isToolEvent + ? TOOL_TEXT_LIMIT + : typeof primarySource === "string" && hasDocumentContent(primarySource) + ? DOCUMENT_TEXT_LIMIT + : DEFAULT_TEXT_LIMIT; + const rawLimit = options.truncate === false ? Number.POSITIVE_INFINITY : TOOL_TEXT_LIMIT * 2; + const shouldRedact = options.redact !== false; + const primary = sanitizeOptionalText(primarySource, textLimit, shouldRedact); + const raw = options.includeRaw ? sanitizeUnknown(event.raw, rawLimit, shouldRedact) : undefined; + // Keep the tool input's existing length while applying the same policy to its metadata copy. + const toolInput = + shouldRedact && event.tool_input !== undefined ? redactSensitiveText(event.tool_input) : event.tool_input; + const redacted = Boolean(primary?.redacted || raw?.redacted || toolInput !== event.tool_input); const truncated = Boolean(primary?.truncated || raw?.truncated); const content: SessionContentBlock[] = []; @@ -60,7 +78,7 @@ export function sanitizeSessionEvent( const metadata: Record = {}; if (event.tool_name !== undefined) metadata.tool_name = event.tool_name; - if (event.tool_input !== undefined) metadata.tool_input = event.tool_input; + if (toolInput !== undefined) metadata.tool_input = toolInput; if (event.status !== undefined) metadata.status = event.status; if (event.stop_reason !== undefined) metadata.stop_reason = event.stop_reason; if (event.session_thread_id !== undefined) metadata.session_thread_id = event.session_thread_id; @@ -87,9 +105,177 @@ export function sanitizeSessionEvent( return result; } -function sanitizeOptionalText(value: string | undefined, limit: number): SanitizedValue | undefined { +/** Sanitize JSON-shaped snapshots without destroying their content-block structure. */ +function sanitizeSnapshot( + event: ProviderSessionEvent, + snapshot: SessionEvent, + options: SessionEventSanitizerOptions, +): SessionEvent { + // These three keys are sanitizer output, not provider-supplied policy decisions. Raw + // always comes from the triggering frame, never an older cumulative snapshot. + const { raw: _raw, redacted: _redacted, truncated: _truncated, ...metadata } = snapshot.metadata ?? {}; + const source = { ...snapshot, ...(snapshot.metadata === undefined ? {} : { metadata }) }; + const policies: StructuredPolicies = { + redact: options.redact !== false, + truncate: options.truncate !== false, + tool: event.type === "tool_use" || event.type === "tool_result", + raw: false, + }; + const sanitized = sanitizeStructured(source, policies); + const result = sanitized.value as SessionEvent; + const raw = options.includeRaw ? sanitizeStructured(event.raw, { ...policies, raw: true }, "raw") : undefined; + if (raw || sanitized.redacted || sanitized.truncated) { + result.metadata ??= {}; + if (raw) result.metadata.raw = raw.value; + if (sanitized.redacted || raw?.redacted) result.metadata.redacted = true; + if (sanitized.truncated || raw?.truncated) result.metadata.truncated = true; + } + return result; +} + +interface StructuredPolicies { + redact: boolean; + truncate: boolean; + tool: boolean; + raw: boolean; +} + +// Keep these names aligned with redactSensitiveText's key/value policy. URL query +// fields continue to be handled by redactSensitiveText inside each string leaf. +// Recognizing the key separately is necessary because a JSON string leaf contains +// only its value (for example { api_key: "secret-value" }), not "api_key=...". +const SENSITIVE_FIELD = + /^(?:api[_-]?key|access[_-]?key(?:_id)?|authorization|credential|ossaccesskeyid|secret|signature|token|security-token)$/i; +const TOOL_PAYLOAD_FIELD = /^(?:arguments|output|tool_input|tool_output)$/; + +type StructuredLocation = + | "event" + | "raw" + | "metadata" + | "blocks" + | "block" + | "data" + | "stop_reason" + | "error" + | "artifacts" + | "artifact" + | "identity" + | "identities" + | "unknown"; + +const EVENT_IDENTITY_FIELDS = new Set(["event_id", "type", "role", "created_at", "code"]); +const RAW_IDENTITY_FIELDS = new Set(["id", "msg_id", "status", "index", "delta"]); +const DATA_IDENTITY_FIELDS = new Set([ + "call_id", + "event_ids", + "call_ids", + "pending_batch_id", + "pending_call_ids", + "batch_id", + "thread_id", + "session_thread_id", + "from_thread_id", + "to_thread_id", +]); +const METADATA_IDENTITY_FIELDS = new Set(["event_status", "status", "display_bucket"]); +const IDENTITY_ARRAY_FIELDS = new Set(["event_ids", "call_ids", "pending_call_ids"]); + +/** Protocol identities are recognized by position, never by arbitrary payload keys. */ +function childLocation(parent: StructuredLocation, key: string): StructuredLocation { + if (parent === "event" || parent === "raw") { + if (EVENT_IDENTITY_FIELDS.has(key) || (parent === "raw" && RAW_IDENTITY_FIELDS.has(key))) return "identity"; + if (key === "metadata") return "metadata"; + if (key === "content") return "blocks"; + if (parent === "event") return "unknown"; + if (key === "data") return "data"; + } + if (parent === "metadata" && METADATA_IDENTITY_FIELDS.has(key)) return "identity"; + if (parent === "raw" || parent === "metadata" || parent === "data") { + if (DATA_IDENTITY_FIELDS.has(key)) return IDENTITY_ARRAY_FIELDS.has(key) ? "identities" : "identity"; + if (key === "stop_reason") return "stop_reason"; + } + if (parent === "raw" || parent === "metadata") { + if (key === "error") return "error"; + if (key === "artifact" || key === "artifacts") return key; + } + if (parent === "block") { + if (key === "type" || key === "index") return "identity"; + if (key === "data") return "data"; + } + if (parent === "stop_reason") { + if (key === "type") return "identity"; + if (key === "call_ids" || key === "event_ids") return "identities"; + } + if ((parent === "error" && key === "code") || (parent === "artifact" && key === "file_id")) return "identity"; + return "unknown"; +} + +function sanitizeStructured( + value: unknown, + policies: StructuredPolicies, + location: StructuredLocation = "event", + sensitive = false, +): SanitizedValue { + if (Array.isArray(value)) { + const entryLocation = + location === "blocks" + ? "block" + : location === "artifacts" + ? "artifact" + : location === "identities" + ? "identity" + : "unknown"; + const children = value.map((entry) => sanitizeStructured(entry, policies, entryLocation, sensitive)); + return { + value: children.map((entry) => entry.value), + redacted: children.some((entry) => entry.redacted), + truncated: children.some((entry) => entry.truncated), + }; + } + if (value !== null && typeof value === "object") { + const children = Object.entries(value).map( + ([childKey, entry]) => + [ + childKey, + sanitizeStructured( + entry, + TOOL_PAYLOAD_FIELD.test(childKey) ? { ...policies, tool: true } : policies, + childLocation(location, childKey), + sensitive || SENSITIVE_FIELD.test(childKey), + ), + ] as const, + ); + return { + value: Object.fromEntries(children.map(([childKey, entry]) => [childKey, entry.value])), + redacted: children.some(([, entry]) => entry.redacted), + truncated: children.some(([, entry]) => entry.truncated), + }; + } + if (policies.redact && sensitive && value !== undefined && value !== null) { + return { value: "[redacted]", redacted: value !== "[redacted]", truncated: false }; + } + if (typeof value !== "string" || location === "identity") { + return { value, redacted: false, truncated: false }; + } + const limit = !policies.truncate + ? Number.POSITIVE_INFINITY + : policies.raw + ? TOOL_TEXT_LIMIT * 2 + : policies.tool + ? TOOL_TEXT_LIMIT + : hasDocumentContent(value) + ? DOCUMENT_TEXT_LIMIT + : DEFAULT_TEXT_LIMIT; + return sanitizeText(value, limit, policies.redact); +} + +function sanitizeOptionalText( + value: string | undefined, + limit: number, + shouldRedact: boolean, +): SanitizedValue | undefined { if (value === undefined) return undefined; - return sanitizeText(value, limit); + return sanitizeText(value, limit, shouldRedact); } interface SanitizedValue { @@ -98,8 +284,8 @@ interface SanitizedValue { truncated: boolean; } -function sanitizeUnknown(value: unknown, limit: number): SanitizedValue { - if (typeof value === "string") return sanitizeText(value, limit); +function sanitizeUnknown(value: unknown, limit: number, shouldRedact: boolean): SanitizedValue { + if (typeof value === "string") return sanitizeText(value, limit, shouldRedact); if (value === null || typeof value !== "object") { return { value, @@ -109,15 +295,15 @@ function sanitizeUnknown(value: unknown, limit: number): SanitizedValue } const serialized = safeStringify(value); - const sanitized = sanitizeText(serialized, limit); + const sanitized = sanitizeText(serialized, limit, shouldRedact); return { ...sanitized, value: parseJsonOrText(sanitized.value), }; } -function sanitizeText(value: string, limit: number): SanitizedValue { - const redacted = redactSensitiveText(value); +function sanitizeText(value: string, limit: number, shouldRedact: boolean): SanitizedValue { + const redacted = shouldRedact ? redactSensitiveText(value) : value; if (redacted.length <= limit) { return { value: redacted, redacted: redacted !== value, truncated: false }; } @@ -126,7 +312,7 @@ function sanitizeText(value: string, limit: number): SanitizedValue { // an open tag (which would cause the browser to treat all subsequent text as a // single malformed element). let cut = limit; - if (/<[a-z][\s\S]*>/i.test(redacted)) { + if (hasHtmlTag(redacted)) { const lastLt = redacted.lastIndexOf("<", cut); const lastGt = redacted.lastIndexOf(">", cut); if (lastLt > lastGt) { @@ -142,6 +328,19 @@ function sanitizeText(value: string, limit: number): SanitizedValue { }; } +/** Match the existing shape without retrying a suffix scan at every '<'. */ +function hasHtmlTag(value: string): boolean { + for (let offset = 0; offset + 1 < value.length; offset++) { + if (value.charCodeAt(offset) !== 60) continue; + const letter = value.charCodeAt(offset + 1); + if ((letter >= 65 && letter <= 90) || (letter >= 97 && letter <= 122)) { + // If no '>' follows the first candidate, none can follow a later candidate either. + return value.indexOf(">", offset + 2) !== -1; + } + } + return false; +} + function safeStringify(value: unknown): string { try { return JSON.stringify(value, null, 2); diff --git a/packages/sdk/src/internal/core/session-runtime.ts b/packages/sdk/src/internal/core/session-runtime.ts index a23bb4a..83585e1 100644 --- a/packages/sdk/src/internal/core/session-runtime.ts +++ b/packages/sdk/src/internal/core/session-runtime.ts @@ -1,5 +1,6 @@ import { defaultFileUploadPurpose, enrichProviderFileInfo } from "../../file-lifecycle.ts"; import { UserError } from "../errors.ts"; +import { assertEventOptions, assertStreamOptions, sessionEventFormat } from "../providers/session-event-options.ts"; import type { SessionCreateOptions } from "../session/session-manager.ts"; import { buildSessionBindings, resolveSessionProvider } from "../session/session-manager.ts"; import type { ProviderFileInfo } from "../types/file.ts"; @@ -15,6 +16,8 @@ import { prepareInitialSessionPrompt } from "../utils/sandbox-mount.ts"; import { resolveAgentMaterialization } from "./agent-materialization.ts"; import type { ProjectRuntimeContext } from "./project-runtime.ts"; import { getRuntimeProvider } from "./project-runtime.ts"; +import { filterSessionEventPage, sessionEventListOptions } from "./session-event-list-options.ts"; +import { streamReadyBeforeSend } from "./session-stream-runtime.ts"; export interface SessionWorkflowAdapter { readonly name: string; @@ -23,6 +26,8 @@ export interface SessionWorkflowAdapter { * resume after. true → send-then-stream with `afterId`; false → connect-before-send. */ readonly eventResume: boolean; + /** Optional internal capability: onReady fires after the HTTP stream is established. */ + readonly streamReady?: boolean; createSession(bindings: SessionBindings): Promise; listSessions(filter?: SessionFilter): Promise; getSession(id: string): Promise; @@ -61,11 +66,13 @@ export interface SessionRuntimeTarget { export interface SessionRuntimeCreateOptions extends SessionCreateOptions, SessionRuntimeTarget {} export interface SessionRuntimeRunOptions extends SessionRuntimeCreateOptions { + stream?: EventStreamOptions; pollIntervalMs?: number; pollTimeoutMs?: number; } export interface SessionRuntimeSendOptions extends SessionRuntimeTarget { + stream?: EventStreamOptions; pollIntervalMs?: number; pollTimeoutMs?: number; } @@ -166,6 +173,7 @@ export async function startSessionRun( options: SessionRuntimeRunOptions = {}, ): Promise { const { agentName, provider, adapter } = resolveSessionRuntime(ctx, options); + assertStreamOptions(adapter.name, options.stream); const bindings = buildSessionBindings(agentName, ctx.config, provider, ctx.state, { identityId: options.identityId, environment: options.environment, @@ -186,7 +194,12 @@ export async function startSessionRun( agentName, provider, session, - events: streamMessageEvents(adapter, session.id, prepareInitialSessionPrompt(prompt, bindings, provider)), + events: streamMessageEvents( + adapter, + session.id, + prepareInitialSessionPrompt(prompt, bindings, provider), + options.stream, + ), }; } @@ -194,7 +207,10 @@ export function streamMessageEvents( adapter: SessionWorkflowAdapter, sessionId: string, message: string, + options: EventStreamOptions = {}, ): AsyncIterable { + assertStreamOptions(adapter.name, options); + if (adapter.streamReady) return streamReadyBeforeSend(adapter, sessionId, message, options); if (adapter.eventResume) { return streamWithResume(adapter, sessionId, message); } @@ -208,7 +224,7 @@ export async function sendSessionMessageStreaming( options: SessionRuntimeSendOptions = {}, ): Promise> { const adapter = resolveDirectAdapter(ctx, options.provider); - return streamMessageEvents(adapter, sessionId, message); + return streamMessageEvents(adapter, sessionId, message, options.stream); } export async function startSessionRunPolling( @@ -385,23 +401,10 @@ export async function listSessionEvents( sessionId: string, options: SessionRuntimeTarget & EventListOptions = {}, ): Promise { - const listOptions: EventListOptions = {}; - if (options.limit !== undefined) listOptions.limit = options.limit; - if (options.order !== undefined) listOptions.order = options.order; - if (options.types !== undefined) listOptions.types = options.types; - if (options.created_at_gt !== undefined) listOptions.created_at_gt = options.created_at_gt; - if (options.created_at_gte !== undefined) listOptions.created_at_gte = options.created_at_gte; - if (options.created_at_lt !== undefined) listOptions.created_at_lt = options.created_at_lt; - if (options.created_at_lte !== undefined) listOptions.created_at_lte = options.created_at_lte; - const pageToken = options.page_token ?? options.page; - if (pageToken !== undefined) listOptions.page_token = pageToken; - const result = await resolveDirectAdapter(ctx, options.provider).listSessionEvents( - sessionId, - Object.keys(listOptions).length > 0 ? listOptions : undefined, - ); - if (!options.types || options.types.length === 0) return result; - const allowedTypes = new Set(options.types); - return { ...result, events: result.events.filter((event) => allowedTypes.has(event.raw_type)) }; + const adapter = resolveDirectAdapter(ctx, options.provider); + assertEventOptions(adapter.name, options); + const result = await adapter.listSessionEvents(sessionId, sessionEventListOptions(options)); + return filterSessionEventPage(result, options.types); } /** @@ -521,11 +524,14 @@ export function streamSessionEvents( options: SessionRuntimeTarget & EventStreamOptions = {}, ): AsyncIterable { const adapter = resolveDirectAdapter(ctx, options.provider); - if (options.after_id && !adapter.eventResume) { + assertStreamOptions(adapter.name, options); + if (options.after_id && !adapter.eventResume && sessionEventFormat(options) === "legacy") { + if (options.signal || options.onReady || options.connectTimeoutMs || options.idleTimeoutMs) { + throw new UserError("Stream lifecycle controls with after_id require snapshot event format."); + } return replaySessionEventsByPolling(adapter, sessionId, options.after_id); } - const streamOptions: EventStreamOptions = {}; - if (options.after_id !== undefined) streamOptions.after_id = options.after_id; + const { provider: _provider, agent: _agent, ...streamOptions } = options; return adapter.streamSessionEvents(sessionId, Object.keys(streamOptions).length > 0 ? streamOptions : undefined); } diff --git a/packages/sdk/src/internal/core/session-stream-runtime.ts b/packages/sdk/src/internal/core/session-stream-runtime.ts new file mode 100644 index 0000000..fee4648 --- /dev/null +++ b/packages/sdk/src/internal/core/session-stream-runtime.ts @@ -0,0 +1,94 @@ +import { UserError } from "../errors.ts"; +import { sessionEventFormat } from "../providers/session-event-options.ts"; +import { bindSessionStreamTurn } from "../providers/session-stream-turn.ts"; +import type { EventStreamOptions, ProviderSessionEvent } from "../types/session-event.ts"; +import type { SessionWorkflowAdapter } from "./session-runtime.ts"; + +const END_STATUSES = new Set(["idle", "completed", "failed", "terminated", "deleted"]); + +/** A ready-capable adapter must establish the SSE connection before the POST can start. */ +export async function* streamReadyBeforeSend( + adapter: SessionWorkflowAdapter, + sessionId: string, + message: string, + options: EventStreamOptions = {}, +): AsyncGenerator { + const controller = new AbortController(); + const abort = () => controller.abort(); + options.signal?.addEventListener("abort", abort, { once: true }); + if (options.signal?.aborted) controller.abort(); + let resolveReady!: () => void; + const ready = new Promise((resolve) => { + resolveReady = resolve; + }); + const streamOptions: EventStreamOptions = { + ...options, + signal: controller.signal, + onReady: () => { + options.onReady?.(); + resolveReady(); + }, + }; + const snapshot = sessionEventFormat(options) === "snapshot"; + const resolveTurnStart = snapshot ? bindSessionStreamTurn(streamOptions) : undefined; + const iterator = adapter.streamSessionEvents(sessionId, streamOptions)[Symbol.asyncIterator](); + let pending: Promise> | undefined; + let observedRun = false; + try { + pending = iterator.next(); + // Attach an error handler before waiting for readiness; connection failures must not send. + await Promise.race([ + ready, + pending.then(() => { + throw new UserError("Session stream ended or emitted an event before connection readiness."); + }), + ]); + if (controller.signal.aborted) throw new DOMException("Session stream cancelled.", "AbortError"); + const sentEventId = await waitForSend(adapter.sendSessionMessage(sessionId, message), controller.signal); + resolveTurnStart?.(sentEventId); + while (true) { + const item = await pending; + if (controller.signal.aborted) throw new DOMException("Session stream cancelled.", "AbortError"); + if (item.done) return; + const event = item.value; + yield event; + if (snapshot) { + if ( + event.status === "running" || + event.role === "assistant" || + event.type === "tool_use" || + event.type === "thinking" + ) + observedRun = true; + // Ignore an initial idle subscription snapshot before the new run becomes visible. + if ( + event.type === "status" && + END_STATUSES.has(event.status ?? "") && + (observedRun || event.status !== "idle" || event.stop_reason === "requires_action") + ) + return; + } + pending = iterator.next(); + } + } finally { + controller.abort(); + await pending?.catch(() => {}); + await iterator.return?.(); + options.signal?.removeEventListener("abort", abort); + } +} + +// Cancelling observation does not cancel provider execution and must never trigger a resend. +async function waitForSend(pending: Promise, signal: AbortSignal): Promise { + let abort: () => void = () => {}; + const cancelled = new Promise((_resolve, reject) => { + abort = () => reject(new DOMException("Session stream cancelled.", "AbortError")); + if (signal.aborted) abort(); + else signal.addEventListener("abort", abort, { once: true }); + }); + try { + return await Promise.race([pending, cancelled]); + } finally { + signal.removeEventListener("abort", abort); + } +} diff --git a/packages/sdk/src/internal/core/session-thread-runtime.ts b/packages/sdk/src/internal/core/session-thread-runtime.ts new file mode 100644 index 0000000..71510c4 --- /dev/null +++ b/packages/sdk/src/internal/core/session-thread-runtime.ts @@ -0,0 +1,31 @@ +import { assertEventOptions } from "../providers/session-event-options.ts"; +import type { EventListOptions, ProviderSessionEventList } from "../types/session-event.ts"; +import type { SessionThreadListOptions, SessionThreadPage } from "../types/session-thread.ts"; +import { type ManagedApiContext, requireManagedApiMethod, resolveManagedApiAdapter } from "./managed-api-context.ts"; +import { filterSessionEventPage, sessionEventListOptions } from "./session-event-list-options.ts"; +import type { SessionRuntimeTarget } from "./session-runtime.ts"; + +/** List child Agent executions. Bailian's main thrd_* is not returned by this endpoint. */ +export async function listSessionThreads( + ctx: ManagedApiContext, + sessionId: string, + options: SessionRuntimeTarget & SessionThreadListOptions = {}, +): Promise { + const adapter = resolveManagedApiAdapter(ctx, options.provider); + const method = requireManagedApiMethod(adapter.listSessionThreads, adapter.name, "session thread listing"); + return method.call(adapter, sessionId, { limit: options.limit, page: options.page, signal: options.signal }); +} + +/** Query a child Agent's history without starting a separate stream or changing the active Session. */ +export async function listSessionThreadEvents( + ctx: ManagedApiContext, + sessionId: string, + threadId: string, + options: SessionRuntimeTarget & EventListOptions = {}, +): Promise { + const adapter = resolveManagedApiAdapter(ctx, options.provider); + const method = requireManagedApiMethod(adapter.listSessionThreadEvents, adapter.name, "session thread events"); + assertEventOptions(adapter.name, options); + const result = await method.call(adapter, sessionId, threadId, sessionEventListOptions(options)); + return filterSessionEventPage(result, options.types); +} diff --git a/packages/sdk/src/internal/core/usage-runtime.ts b/packages/sdk/src/internal/core/usage-runtime.ts new file mode 100644 index 0000000..1c9e42c --- /dev/null +++ b/packages/sdk/src/internal/core/usage-runtime.ts @@ -0,0 +1,35 @@ +import type { + ModelUsagePage, + ModelUsageRequest, + ToolUsagePage, + ToolUsageRequest, + UsageQueryOptions, +} from "../types/usage.ts"; +import { type ManagedApiContext, requireManagedApiMethod, resolveManagedApiAdapter } from "./managed-api-context.ts"; + +export interface UsageRuntimeOptions extends UsageQueryOptions { + /** Explicit provider; required when more than one provider is configured. */ + provider?: string; +} + +/** Aggregated model usage (calls, failures, token breakdowns) for a workspace/agent/session scope. */ +export async function listModelUsage( + ctx: ManagedApiContext, + request: ModelUsageRequest, + options: UsageRuntimeOptions = {}, +): Promise { + const adapter = resolveManagedApiAdapter(ctx, options.provider); + const method = requireManagedApiMethod(adapter.listModelUsage, adapter.name, "model usage listing"); + return method.call(adapter, request, { signal: options.signal }); +} + +/** Aggregated tool usage (calls, failures by tool source) for a workspace/agent/session scope. */ +export async function listToolUsage( + ctx: ManagedApiContext, + request: ToolUsageRequest, + options: UsageRuntimeOptions = {}, +): Promise { + const adapter = resolveManagedApiAdapter(ctx, options.provider); + const method = requireManagedApiMethod(adapter.listToolUsage, adapter.name, "tool usage listing"); + return method.call(adapter, request, { signal: options.signal }); +} diff --git a/packages/sdk/src/internal/core/validate-config.ts b/packages/sdk/src/internal/core/validate-config.ts index acce0b9..74198c0 100644 --- a/packages/sdk/src/internal/core/validate-config.ts +++ b/packages/sdk/src/internal/core/validate-config.ts @@ -11,7 +11,10 @@ import type { ProjectConfig } from "../types/config.ts"; import type { Diagnostic } from "../types/plan.ts"; import type { ResourceAddress } from "../types/state.ts"; import { providerMountPrefix, resolveSandboxMountPath } from "../utils/sandbox-mount.ts"; -import { findMissingBailianMcpToolConfigs } from "../validation/bailian.ts"; +import { + collectBailianSubagentToolPermissionDiagnostics, + findMissingBailianMcpToolConfigs, +} from "../validation/bailian.ts"; import { getDeploymentEnvironmentVariablesIssue } from "../validation/deployment-environment.ts"; import { resolveAgentMaterialization } from "./agent-materialization.ts"; @@ -498,9 +501,20 @@ export function collectProviderCapabilities( } } + if ( + providerName !== "bailian" && + agent.multiagent?.agents.some((member) => typeof member !== "string" && "type" in member) + ) { + diagnostics.error( + `${providerName}.agent.multiagent.self.unsupported`, + `agent.${name}: Self requires Bailian managed delivery.`, + address, + ); + } if (providerName === "qoder" && agent.multiagent) { const coordinatorMode = resolveAgentMaterialization(providerName, agent).mode; for (const memberName of agent.multiagent.agents) { + if (typeof memberName !== "string" && "type" in memberName) continue; if (typeof memberName !== "string") { if (coordinatorMode === "forward") { diagnostics.error( @@ -721,6 +735,7 @@ export function collectProviderCapabilities( } } + collectBailianSubagentToolPermissionDiagnostics(config, providerName, diagnostics); for (const missing of findMissingBailianMcpToolConfigs(config, providerName)) { diagnostics.error( `${providerName}.agent.mcp_toolkit_missing`, diff --git a/packages/sdk/src/internal/executor/execution-report.ts b/packages/sdk/src/internal/executor/execution-report.ts new file mode 100644 index 0000000..f520d5e --- /dev/null +++ b/packages/sdk/src/internal/executor/execution-report.ts @@ -0,0 +1,239 @@ +import type { ProviderAdapter } from "../providers/interface.ts"; +import { resourceErrorInfo, resourceRuntimeError } from "../resource-runtime-error.ts"; +import type { IStateManager } from "../state/state-manager.ts"; +import type { PlannedAction } from "../types/plan.ts"; +import type { ResourceActionResult, ResourceExecutionResult } from "../types/resource-result.ts"; +import { addressKey } from "../types/state.ts"; +import type { ExecContext } from "./context.ts"; + +const mutations = new Set([ + "createEnvironment", + "updateEnvironment", + "deleteEnvironment", + "createVault", + "deleteVault", + "createSkill", + "updateSkill", + "deleteSkill", + "createAgent", + "updateAgent", + "deleteAgent", + "createTemplate", + "updateTemplate", + "archiveTemplate", + "createIdentity", + "updateIdentity", + "deleteIdentity", + "createChannel", + "updateChannel", + "deleteChannel", + "createMemoryStore", + "updateMemoryStore", + "deleteMemoryStore", + "createMemory", + "updateMemory", + "createDeployment", + "updateDeployment", + "deleteDeployment", + "uploadFile", + "deleteFile", + "reconcileDefaultMemoryStore", +]); + +// Child Memory/Credential IDs must never replace their parent resource's identity. +const identityMutations = new Set([ + "createEnvironment", + "updateEnvironment", + "createVault", + "createSkill", + "updateSkill", + "createAgent", + "updateAgent", + "createTemplate", + "updateTemplate", + "createIdentity", + "updateIdentity", + "createChannel", + "updateChannel", + "createMemoryStore", + "updateMemoryStore", + "createDeployment", + "updateDeployment", + "uploadFile", +]); + +function identity(value: unknown): ResourceActionResult["resource"] { + if (!value || typeof value !== "object" || !("id" in value) || typeof value.id !== "string" || !value.id) return; + const version = "version" in value ? value.version : undefined; + return { + remoteId: value.id, + ...(typeof version === "number" && Number.isSafeInteger(version) && version > 0 ? { version } : {}), + }; +} + +function trackProvider( + provider: T, + onMutation: () => void, + onIdentity?: (value: unknown) => void, +): T { + return new Proxy(provider, { + get(target, key) { + const value = Reflect.get(target, key, target); + if (typeof value !== "function") return value; + return (...args: unknown[]) => { + if (mutations.has(key as keyof ProviderAdapter)) onMutation(); + if (key === "createVault" && onIdentity) args[3] = onIdentity; + const result = value.apply(target, args); + if (!onIdentity || !identityMutations.has(key as keyof ProviderAdapter)) return result; + return Promise.resolve(result).then((resource) => { + onIdentity(resource); + return resource; + }); + }; + }, + }); +} + +/** Captures execution facts without changing the legacy executor result or error path. */ +export class ExecutionReportTracker { + mutationStarted = false; + private readonly writes = new Set(); + private readonly records = new Map(); + private readonly observed = new Map>(); + private readonly initial = new Map>(); + + constructor( + private readonly actions: PlannedAction[], + private readonly state: IStateManager, + ) { + for (const action of actions) { + const resource = this.stateResource(action); + if (resource) this.initial.set(addressKey(action.address), resource); + } + } + + private stateResource(action: PlannedAction) { + const resource = + this.state.getResource(action.address) ?? + (action.previousAddress ? this.state.getResource(action.previousAddress) : undefined); + return identity({ id: resource?.remote_id, version: resource?.version }); + } + + provider(provider: T, action: PlannedAction): T { + return trackProvider( + provider, + () => { + this.mutationStarted = true; + this.writes.add(addressKey(action.address)); + }, + (value) => { + const resource = identity(value); + if (resource) this.observed.set(addressKey(action.address), resource); + }, + ); + } + + context(context: ExecContext): ExecContext { + const state = new Proxy(context.state, { + get: (target, key) => { + const value = Reflect.get(target, key, target); + if (key === "save") + return async () => { + try { + await target.save(); + } catch (error) { + throw resourceRuntimeError(error, { + code: "resource.state_persist_failed", + phase: "persist_state", + mutationStarted: this.mutationStarted, + }); + } + }; + return typeof value === "function" ? value.bind(target) : value; + }, + }); + return { + ...context, + state, + providers: new Map( + [...context.providers].map(([name, provider]) => [ + name, + trackProvider(provider, () => { + this.mutationStarted = true; + }), + ]), + ), + onFeedback: context.onFeedback + ? (event) => { + try { + context.onFeedback?.(event); + } catch (error) { + throw resourceRuntimeError(error, { + code: "resource.feedback_failed", + phase: "execute", + mutationStarted: this.mutationStarted, + }); + } + } + : undefined, + }; + } + + record(action: PlannedAction, status: ResourceActionResult["status"], error?: unknown, code?: string): void { + const mutationStarted = this.writes.has(addressKey(action.address)); + const resource = + this.observed.get(addressKey(action.address)) ?? + this.stateResource(action) ?? + this.initial.get(addressKey(action.address)); + this.records.set(addressKey(action.address), { + action, + status, + ...(error === undefined ? {} : { error: error instanceof Error ? error.message : String(error) }), + ...(status === "success" + ? {} + : { + errorInfo: resourceErrorInfo(error, { + code, + phase: mutationStarted ? "execute" : "prepare", + mutationStarted, + }), + }), + ...(resource ? { resource } : {}), + }); + } + + report(error?: unknown): ResourceExecutionResult { + const results = this.actions + .filter((action) => action.action !== "no-op") + .map( + (action) => + this.records.get(addressKey(action.address)) ?? { + action, + status: "skipped" as const, + errorInfo: resourceErrorInfo(undefined, { + code: "resource.execution_aborted", + phase: "prepare", + mutationStarted: false, + }), + }, + ); + const failed = results.some((result) => result.status !== "success"); + const unknown = + (error !== undefined && this.mutationStarted) || + results.some((result) => result.status === "failed" && result.errorInfo?.mutationStarted); + return { + results, + partial: results.some((result) => result.status === "failed"), + mutationStarted: this.mutationStarted, + outcome: unknown + ? "unknown" + : error !== undefined + ? "failed" + : !failed + ? "succeeded" + : results.some((result) => result.status === "success") + ? "partial" + : "failed", + }; + } +} diff --git a/packages/sdk/src/internal/executor/executor.ts b/packages/sdk/src/internal/executor/executor.ts index 6f503fd..91f276c 100644 --- a/packages/sdk/src/internal/executor/executor.ts +++ b/packages/sdk/src/internal/executor/executor.ts @@ -17,6 +17,7 @@ import { addressKey } from "../types/state.ts"; import { contentHash, sha256 } from "../utils/hash.ts"; import { skillNameFromFiles } from "../utils/skill-manifest.ts"; import type { ExecContext } from "./context.ts"; +import type { ExecutionReportTracker } from "./execution-report.ts"; import { initializeBailianMemories, memoryInitializationEntries } from "./memory-initialization.ts"; import { resolveAgentRefs, resolveChannelRefs, resolveDeploymentRefs, resolveTemplateRefs } from "./resolver.ts"; import { resolveSkillFiles } from "./skill-resolver.ts"; @@ -56,7 +57,7 @@ function clampConcurrency(value?: number): number { export async function executePlan( plan: ExecutionPlan, ctx: ExecContext, - options: { concurrency?: number } = {}, + options: { concurrency?: number; tracker?: ExecutionReportTracker } = {}, ): Promise { const concurrency = clampConcurrency(options.concurrency); const resultsByKey = new Map(); @@ -90,24 +91,29 @@ export async function executePlan( const depFailed = action.dependencies.some((d) => failed.has(addressKey(d))); if (depFailed) { resultsByKey.set(key, { action, status: "skipped" }); + options.tracker?.record(action, "skipped", undefined, "resource.dependency_failed"); failed.add(key); return; } - const provider = ctx.providers.get(action.address.provider); - if (!provider) { + const baseProvider = ctx.providers.get(action.address.provider); + if (!baseProvider) { + const error = new Error(`Provider '${action.address.provider}' not configured`); resultsByKey.set(key, { action, status: "failed", - error: new Error(`Provider '${action.address.provider}' not configured`), + error, }); + options.tracker?.record(action, "failed", error, "resource.provider_not_configured"); failed.add(key); return; } + const provider = options.tracker?.provider(baseProvider, action) ?? baseProvider; try { const adopted = await executeAction(action, provider, ctx); resultsByKey.set(key, { action, status: "success" }); + options.tracker?.record(action, "success"); if (!adopted) { emitRuntimeFeedback(ctx.onFeedback, { type: "resource_action_success", @@ -120,6 +126,7 @@ export async function executePlan( } catch (err) { const error = err instanceof Error ? err : new Error(String(err)); resultsByKey.set(key, { action, status: "failed", error }); + options.tracker?.record(action, "failed", error); failed.add(key); emitRuntimeFeedback(ctx.onFeedback, { type: "resource_action_failed", @@ -133,7 +140,7 @@ export async function executePlan( // create/update: run level-by-level with bounded parallelism, persisting once per level. for (const level of buildActionLevels(mutations)) { - await runWithConcurrency(level, concurrency, runAction); + await runWithConcurrency(level, concurrency, runAction, Boolean(options.tracker)); await ctx.state.save(); } @@ -196,7 +203,12 @@ async function reconcileDefaultMemoryStores(ctx: ExecContext, plannedProviders: } // Run `worker` over `items` with at most `limit` concurrent executions. -async function runWithConcurrency(items: T[], limit: number, worker: (item: T) => Promise): Promise { +async function runWithConcurrency( + items: T[], + limit: number, + worker: (item: T) => Promise, + settle = false, +): Promise { if (items.length === 0) return; let cursor = 0; const size = Math.min(limit, items.length); @@ -211,7 +223,13 @@ async function runWithConcurrency(items: T[], limit: number, worker: (item: T })(), ); } - await Promise.all(runners); + if (!settle) { + await Promise.all(runners); + return; + } + const settled = await Promise.allSettled(runners); + const rejected = settled.find((result) => result.status === "rejected"); + if (rejected?.status === "rejected") throw rejected.reason; } // Group actions into dependency levels (Kahn-style layering). Only dependencies diff --git a/packages/sdk/src/internal/executor/resolver.ts b/packages/sdk/src/internal/executor/resolver.ts index a813cc7..b59959c 100644 --- a/packages/sdk/src/internal/executor/resolver.ts +++ b/packages/sdk/src/internal/executor/resolver.ts @@ -65,6 +65,11 @@ function resolveMultiagentRoster( return { type: "coordinator", members: (agent.multiagent?.agents ?? []).map((member) => { + if (typeof member !== "string" && "type" in member) { + if (provider !== "bailian" || resourceType !== "agent") + throw new UserError("multiagent.self.unsupported: Self requires Bailian managed delivery."); + return { type: "self" as const }; + } if (typeof member !== "string") { if (resourceType === "template") { throw new UserError( diff --git a/packages/sdk/src/internal/multiagent/comparable.ts b/packages/sdk/src/internal/multiagent/comparable.ts index 183c044..f91e0cf 100644 --- a/packages/sdk/src/internal/multiagent/comparable.ts +++ b/packages/sdk/src/internal/multiagent/comparable.ts @@ -1,8 +1,9 @@ -import type { ResolvedMultiagentRoster } from "./model.ts"; +import { isSelfRosterMember, type ResolvedMultiagentRoster } from "./model.ts"; export interface ComparableMultiagentRoster { type: "coordinator"; member_ids: string[]; + self?: true; } export type MultiagentMaterialization = "managed" | "forward"; @@ -13,13 +14,17 @@ export function canonicalizeDesiredRoster( resolved: ResolvedMultiagentRoster | undefined, ): ComparableMultiagentRoster | undefined { if (!resolved) return undefined; - const memberIds = [...new Set(resolved.members.map((member) => member.remote_id))].sort(); - return { type: "coordinator", member_ids: memberIds }; + const memberIds = [ + ...new Set(resolved.members.flatMap((member) => ("type" in member ? [] : [member.remote_id]))), + ].sort(); + const self = resolved.members.some((member) => "type" in member); + return { type: "coordinator", member_ids: memberIds, ...(self ? { self: true } : {}) }; } export function canonicalizeRemoteRoster( raw: unknown, materialization: MultiagentMaterialization, + allowSelf = false, ): CanonicalRemoteRoster { if (raw === null || raw === undefined) return { supported: true }; if (typeof raw !== "object") return { supported: false }; @@ -29,18 +34,24 @@ export function canonicalizeRemoteRoster( if (roster.agents.length === 0) return { supported: true }; const memberIds: string[] = []; + let self = false; for (const entry of roster.agents) { + if (allowSelf && materialization === "managed" && isSelfRosterMember(entry)) { + self = true; + continue; + } if (typeof entry !== "object" || entry === null) return { supported: false }; const member = entry as { type?: unknown; id?: unknown; template_id?: unknown }; - // `self` and advisor members are deliberately rejected: Phase 1 cannot - // declare them, so treating them as ordinary agents would silently hide - // a remote roster this project can never converge to. + // Self requires an explicit provider opt-in; all other unknown members fail closed. if (member.type !== "agent") return { supported: false }; const id = materialization === "forward" ? member.template_id : member.id; if (typeof id !== "string") return { supported: false }; memberIds.push(id); } - return { supported: true, roster: { type: "coordinator", member_ids: [...new Set(memberIds)].sort() } }; + return { + supported: true, + roster: { type: "coordinator", member_ids: [...new Set(memberIds)].sort(), ...(self ? { self: true } : {}) }, + }; } /** @@ -51,8 +62,9 @@ export function canonicalizeRemoteRoster( export function comparableMultiagentField( raw: unknown, materialization: MultiagentMaterialization, + allowSelf = false, ): ComparableMultiagentRoster | { type: "unsupported" } | undefined { - const canonical = canonicalizeRemoteRoster(raw, materialization); + const canonical = canonicalizeRemoteRoster(raw, materialization, allowSelf); if (!canonical.supported) return { type: "unsupported" }; return canonical.roster; } diff --git a/packages/sdk/src/internal/multiagent/model.ts b/packages/sdk/src/internal/multiagent/model.ts index 7710531..b58bb98 100644 --- a/packages/sdk/src/internal/multiagent/model.ts +++ b/packages/sdk/src/internal/multiagent/model.ts @@ -1,11 +1,39 @@ -export interface ResolvedMultiagentMember { - /** Present only when the member is owned and named by this project. */ - logical_name?: string; - resource_type: "agent" | "template"; - remote_id: string; -} +import { UserError } from "../errors.ts"; +import type { MultiagentMemberDecl } from "../types/config.ts"; + +type SelfMember = Extract; + +export type ResolvedMultiagentMember = + | SelfMember + | { + /** Present only when the member is owned and named by this project. */ + logical_name?: string; + resource_type: "agent" | "template"; + remote_id: string; + }; export interface ResolvedMultiagentRoster { type: "coordinator"; members: ResolvedMultiagentMember[]; } + +/** Provider null identity placeholders are unset; non-null identities and extensions are not Self. */ +export function isSelfRosterMember(value: unknown): value is SelfMember { + return ( + value !== null && + typeof value === "object" && + !Array.isArray(value) && + "type" in value && + value.type === "self" && + Object.keys(value).every( + (key) => + key === "type" || ((key === "id" || key === "version") && (value as Record)[key] === null), + ) + ); +} + +/** Native Self must never be serialized as an external member id. */ +export function externalMultiagentMemberId(member: ResolvedMultiagentMember): string { + if ("type" in member) throw new UserError("multiagent.self.unsupported: Self requires Bailian managed delivery."); + return member.remote_id; +} diff --git a/packages/sdk/src/internal/multiagent/reverse-index.ts b/packages/sdk/src/internal/multiagent/reverse-index.ts index 05abab9..1dcfc80 100644 --- a/packages/sdk/src/internal/multiagent/reverse-index.ts +++ b/packages/sdk/src/internal/multiagent/reverse-index.ts @@ -1,5 +1,6 @@ import { UserError } from "../errors.ts"; import type { MultiagentMemberDecl } from "../types/config.ts"; +import { isSelfRosterMember } from "./model.ts"; /** One `/agents` listing entry, keyed by remote agent id. */ export interface ReverseIndexEntry { @@ -82,6 +83,7 @@ export function memberDeclResolver(index: ReverseIndex): (memberId: string) => M export function reverseMultiagentDecl( raw: unknown, resolveMember?: (memberId: string) => MultiagentMemberDecl, + allowSelf = false, ): { type: "coordinator"; agents: MultiagentMemberDecl[] } | undefined { if (raw === null || raw === undefined) return undefined; if (typeof raw !== "object") return undefined; @@ -92,14 +94,16 @@ export function reverseMultiagentDecl( ); } if (!Array.isArray(roster.agents) || roster.agents.length === 0) return undefined; - if (!resolveMember) { + if (!resolveMember && roster.agents.some((member) => !(allowSelf && isSelfRosterMember(member)))) { throw new UserError( "sync.multiagent.member.unresolved: reverse-mapping a multi-agent roster requires a member name resolver.", ); } return { type: "coordinator", - agents: roster.agents.map((member) => resolveMember(rosterMemberId(member))), + agents: roster.agents.map((member) => + allowSelf && isSelfRosterMember(member) ? { type: "self" } : resolveMember!(rosterMemberId(member)), + ), }; } diff --git a/packages/sdk/src/internal/parser/file-resolver.ts b/packages/sdk/src/internal/parser/file-resolver.ts index 94cde1f..b8a15fa 100644 --- a/packages/sdk/src/internal/parser/file-resolver.ts +++ b/packages/sdk/src/internal/parser/file-resolver.ts @@ -4,9 +4,17 @@ import { UserError } from "../errors.ts"; import type { AgentDecl, MemoryEntryDecl, ProjectConfig, ResolvedProjectConfig } from "../types/config.ts"; import { isFileReference, loadPrompt } from "../utils/prompt-loader.ts"; -export async function resolveFileReferences(config: ProjectConfig, configPath: string): Promise { +export async function resolveFileReferences( + config: ProjectConfig, + configPath: string, + textFileReferences: "resolve" | "literal" = "resolve", +): Promise { const basePath = configPath; const resolved = structuredClone(config) as ProjectConfig & { _resolved: true }; + if (textFileReferences === "literal") { + resolved._resolved = true; + return resolved as ResolvedProjectConfig; + } if (resolved.agents) { for (const [name, agent] of Object.entries(resolved.agents)) { diff --git a/packages/sdk/src/internal/parser/resolve-project-config.ts b/packages/sdk/src/internal/parser/resolve-project-config.ts index 61593d7..eb40966 100644 --- a/packages/sdk/src/internal/parser/resolve-project-config.ts +++ b/packages/sdk/src/internal/parser/resolve-project-config.ts @@ -56,6 +56,8 @@ export async function resolveProjectConfig( } export interface ResolveProjectConfigFromObjectOptions { + /** Treat prompt and memory text as literal strings. File/Skill sources remain file references. */ + textFileReferences?: "resolve" | "literal"; /** Project name to stamp onto the resolved config. */ projectName: string; /** Base path used to resolve any `file:` references (defaults to process.cwd()). */ @@ -89,12 +91,17 @@ export async function resolveProjectConfigFromObject( // file inside basePath so `file:` refs resolve against basePath itself. const anchor = resolve(basePath, "__in_memory_config__"); const parsed = result.data as ProjectConfig; - const sourcePaths = collectProjectSourcePaths(parsed, anchor, false); - const config = await resolveFileReferences(parsed, anchor); + const sourcePaths = collectProjectSourcePaths(parsed, anchor, false, options.textFileReferences); + const config = await resolveFileReferences(parsed, anchor, options.textFileReferences); return { configPath: basePath, projectName: options.projectName, config, sourcePaths }; } -function collectProjectSourcePaths(config: ProjectConfig, configPath: string, includeConfigPath: boolean): string[] { +function collectProjectSourcePaths( + config: ProjectConfig, + configPath: string, + includeConfigPath: boolean, + textFileReferences: "resolve" | "literal" = "resolve", +): string[] { const baseDirectory = dirname(configPath); const paths = new Set(); if (includeConfigPath) paths.add(configPath); @@ -105,11 +112,11 @@ function collectProjectSourcePaths(config: ProjectConfig, configPath: string, in paths.add(resolve(baseDirectory, value)); }; - for (const agent of Object.values(config.agents ?? {})) { - addLocalPath(agent.instructions, true); - } - for (const store of Object.values(config.memory_stores ?? {})) { - for (const entry of store.entries ?? []) addLocalPath(entry.content, true); + if (textFileReferences === "resolve") { + for (const agent of Object.values(config.agents ?? {})) addLocalPath(agent.instructions, true); + for (const store of Object.values(config.memory_stores ?? {})) { + for (const entry of store.entries ?? []) addLocalPath(entry.content, true); + } } for (const skill of Object.values(config.skills ?? {})) addLocalPath(skill.source); for (const file of Object.values(config.files ?? {})) addLocalPath(file.source); diff --git a/packages/sdk/src/internal/parser/schema.ts b/packages/sdk/src/internal/parser/schema.ts index 422b153..dd50ca5 100644 --- a/packages/sdk/src/internal/parser/schema.ts +++ b/packages/sdk/src/internal/parser/schema.ts @@ -224,14 +224,23 @@ const toolsSchema = z const multiagentSchema = z .object({ type: z.literal("coordinator"), - agents: z.array(z.union([z.string().min(1), z.object({ agent_id: z.string().trim().min(1) })])).min(1), + agents: z + .array( + z.union([ + z.string().min(1), + z.object({ agent_id: z.string().trim().min(1) }).strict(), + z.object({ type: z.literal("self") }).strict(), + ]), + ) + .min(1), }) .superRefine((multiagent, ctx) => { const seen = new Set(); for (const [index, member] of multiagent.agents.entries()) { - const key = typeof member === "string" ? `logical:${member}` : `external:${member.agent_id}`; + const key = + typeof member === "string" ? `logical:${member}` : "type" in member ? "self" : `external:${member.agent_id}`; if (seen.has(key)) { - const label = typeof member === "string" ? member : member.agent_id; + const label = typeof member === "string" ? member : "type" in member ? "Self" : member.agent_id; ctx.addIssue({ code: "custom", path: ["agents", index], diff --git a/packages/sdk/src/internal/planner/plan-fingerprint.ts b/packages/sdk/src/internal/planner/plan-fingerprint.ts new file mode 100644 index 0000000..68ba27b --- /dev/null +++ b/packages/sdk/src/internal/planner/plan-fingerprint.ts @@ -0,0 +1,80 @@ +import type { IStateManager } from "../state/state-manager.ts"; +import type { ExecutionPlan } from "../types/plan.ts"; +import { addressKey, type ResourceAddress } from "../types/state.ts"; +import { contentHash } from "../utils/hash.ts"; + +interface FingerprintInput { + plan: ExecutionPlan; + executionContext: { state: IStateManager }; + mode?: string; + targetProviders?: string[]; + selectedAddresses?: ResourceAddress[]; +} + +/** Versioned execution semantics only: no credentials, response snapshots, timestamps or display messages. */ +export function resourcePlanFingerprint(input: FingerprintInput): string { + const keys = new Set( + input.plan.actions + .flatMap((action) => [ + action.address, + ...(action.previousAddress ? [action.previousAddress] : []), + ...action.dependencies, + ]) + .map(addressKey), + ); + const state = input.executionContext.state.getStateFile(); + const resources = state.resources + .filter((resource) => keys.has(addressKey(resource.address))) + .map((resource) => ({ + address: resource.address, + remote_id: resource.remote_id, + version: resource.version, + content_hash: resource.content_hash, + desired_hash: resource.desired_hash, + remote_hash: resource.remote_hash, + desired_comparable_hash: resource.desired_comparable_hash, + desired_readiness_baseline: resource.desired_readiness_baseline, + externally_managed: resource.externally_managed, + api_mode: resource.api_mode, + memory_initialization: resource.memory_initialization, + replacement_fingerprint: resource.replacement_fingerprint, + drift_status: resource.drift_status, + drift_paths: resource.drift_paths?.slice().sort(), + })) + .sort((left, right) => addressKey(left.address).localeCompare(addressKey(right.address))); + const actions = input.plan.actions + .map((action) => ({ + action: action.action, + address: action.address, + previousAddress: action.previousAddress, + dependencies: action.dependencies.map(addressKey).sort(), + before: action.before + ? { + content_hash: action.before.content_hash, + remote_hash: action.before.remote_hash, + drift_paths: action.before.drift_paths, + } + : undefined, + after: action.after ? { content_hash: action.after.content_hash } : undefined, + driftKind: action.driftKind, + readinessImpact: action.readinessImpact, + changedPaths: action.changedPaths?.slice().sort(), + })) + .sort((left, right) => addressKey(left.address).localeCompare(addressKey(right.address))); + return `resource-plan-v1:${contentHash({ + mode: input.mode ?? "reconcile", + providers: input.targetProviders?.slice().sort(), + scope: input.selectedAddresses?.map(addressKey).sort(), + actions, + resources, + diagnostics: input.plan.diagnostics + .map(({ code, severity, resource }) => ({ code, severity, resource })) + .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))), + pendingDefaultMemoryStores: + input.mode === "create-only" + ? undefined + : state.pending_default_memory_store_cleanups + ?.map(({ last_error: _error, ...cleanup }) => cleanup) + .sort((left, right) => left.remote_id.localeCompare(right.remote_id)), + })}`; +} diff --git a/packages/sdk/src/internal/providers/ark/adapter.ts b/packages/sdk/src/internal/providers/ark/adapter.ts index bbf0b51..7e9b96a 100644 --- a/packages/sdk/src/internal/providers/ark/adapter.ts +++ b/packages/sdk/src/internal/providers/ark/adapter.ts @@ -45,6 +45,7 @@ import type { } from "../interface.ts"; import { ProviderMemoryApi } from "../memory-api.ts"; import { arkEnvironmentWireNameAttempt, normalizeWireResourceName } from "../resource-naming.ts"; +import { assertEventOptions, assertStreamOptions } from "../session-event-options.ts"; import { extractCreatedEventId, listSessionEventsPaged } from "../session-event-response.ts"; import { buildSessionInfo, @@ -458,7 +459,8 @@ export class ArkAdapter implements ProviderAdapter { return extractCreatedEventId(res); } - async *streamSessionEvents(sessionId: string, _options?: EventStreamOptions): AsyncIterable { + async *streamSessionEvents(sessionId: string, options?: EventStreamOptions): AsyncIterable { + assertStreamOptions(this.name, options); // Like claude/bailian: the stream pushes only post-connect events and rejects a // cursor param; reconnection replays history via listSessionEvents + de-dup by id. for await (const raw of this.client.sse(`/sessions/${sessionId}/events/stream`)) { @@ -467,6 +469,7 @@ export class ArkAdapter implements ProviderAdapter { } async listSessionEvents(sessionId: string, options?: EventListOptions): Promise { + assertEventOptions(this.name, options); return listSessionEventsPaged(this.client, sessionId, options, toSessionEvent); } diff --git a/packages/sdk/src/internal/providers/ark/mapper.ts b/packages/sdk/src/internal/providers/ark/mapper.ts index 6b16de8..e917bfc 100644 --- a/packages/sdk/src/internal/providers/ark/mapper.ts +++ b/packages/sdk/src/internal/providers/ark/mapper.ts @@ -1,4 +1,5 @@ import { UserError } from "../../errors.ts"; +import { externalMultiagentMemberId } from "../../multiagent/model.ts"; import { reverseMultiagentDecl } from "../../multiagent/reverse-index.ts"; import type { AgentDecl, @@ -283,7 +284,7 @@ export function mapAgent( // not a bare id string array (bare strings → 400 "Mismatch type agent.AgentRef"). body.multiagent = { type: "coordinator", - agents: refs.multiagent.members.map(({ remote_id }) => ({ type: "agent", id: remote_id })), + agents: refs.multiagent.members.map((member) => ({ type: "agent", id: externalMultiagentMemberId(member) })), }; } diff --git a/packages/sdk/src/internal/providers/bailian/adapter.ts b/packages/sdk/src/internal/providers/bailian/adapter.ts index 96a4a73..a00a671 100644 --- a/packages/sdk/src/internal/providers/bailian/adapter.ts +++ b/packages/sdk/src/internal/providers/bailian/adapter.ts @@ -37,6 +37,9 @@ import type { FilePage, SessionEventInput, SessionEventSendResult, + SessionResourceListOptions, + SessionResourceMountInput, + SessionResourcePage, SessionUpdateInput, SkillDownloadInfo, SkillListOptions, @@ -56,16 +59,30 @@ import type { UpdateMemoryInput, UpdateMemoryStoreInput, } from "../../types/memory.ts"; -import type { ProviderSessionInfo, SessionBindings, SessionFilter, SessionListResult } from "../../types/session.ts"; +import type { + ProviderSessionInfo, + SessionBindings, + SessionFilter, + SessionListResult, + SessionResourceInfo, +} from "../../types/session.ts"; import type { EventListOptions, EventStreamOptions, ProviderSessionEvent, ProviderSessionEventList, } from "../../types/session-event.ts"; +import type { SessionThreadListOptions, SessionThreadPage } from "../../types/session-thread.ts"; import type { SkillFile } from "../../types/skill-file.ts"; import type { ProviderSkillInfo } from "../../types/skill-info.ts"; import type { ResourceType } from "../../types/state.ts"; +import type { + ModelUsagePage, + ModelUsageRequest, + ToolUsagePage, + ToolUsageRequest, + UsageQueryOptions, +} from "../../types/usage.ts"; import type { CreateWebhookEndpointInput, UpdateWebhookEndpointInput, @@ -94,11 +111,14 @@ import type { DriftSupport, ExportedResource, ProviderAdapter, + ProviderResourceMode, RemoteResource, ResolvedAgentRefs, ResolvedDeploymentRefs, + ResourceCreationObserver, } from "../interface.ts"; import { ProviderMemoryApi } from "../memory-api.ts"; +import { assertEventOptions } from "../session-event-options.ts"; import { extractCreatedEventId, listSessionEventsPaged } from "../session-event-response.ts"; import { buildSessionInfo, @@ -111,6 +131,7 @@ import { toRestFileInfo, } from "../shared.ts"; import { BailianClient } from "./client.ts"; +import { correlateBailianHistoryEvents } from "./history-event-correlation.ts"; import { agentToDecl, envToDecl, @@ -127,10 +148,14 @@ import { toSessionEvent, vaultToDecl, } from "./mapper.ts"; +import { streamBailianSessionEvents } from "./session-stream.ts"; +import { listBailianSessionThreadEvents, listBailianSessionThreads } from "./session-threads.ts"; +import { listBailianModelUsage, listBailianToolUsage } from "./usage.ts"; export class BailianAdapter implements ProviderAdapter { readonly name = "bailian" as const; readonly eventResume = false; + readonly streamReady = true; readonly memoryCapabilities = { archive_store: true, batch_create: false, @@ -398,7 +423,7 @@ export class BailianAdapter implements ProviderAdapter { instructions: raw.system, tools: normalizeBailianTools(raw.tools), mcp_servers: normalizeBailianMcpServers(raw.mcp_servers), - multiagent: comparableMultiagentField(raw.multiagent, "managed"), + multiagent: comparableMultiagentField(raw.multiagent, "managed", true), metadata: stripAgentsMetadata(raw.metadata), }); } @@ -529,10 +554,10 @@ export class BailianAdapter implements ProviderAdapter { return cursorPage(res, toCloudAgent); } - async getRemoteAgent(id: string, version?: number): Promise { + async getRemoteAgent(id: string, version?: number, options?: { signal?: AbortSignal }): Promise { const params = new URLSearchParams(); if (version !== undefined) params.set("version", String(version)); - const res = (await this.client.get(withQuery(`/agents/${id}`, params))) as Record; + const res = (await this.client.get(withQuery(`/agents/${id}`, params), options)) as Record; return toCloudAgent(res); } @@ -834,13 +859,21 @@ export class BailianAdapter implements ProviderAdapter { // thin wrappers over the AgentStudio endpoints, exposed so callers/tests can // exercise the full surface through real project code rather than raw fetch. - async createVault(name: string, decl: VaultDecl): Promise { + async createVault( + name: string, + decl: VaultDecl, + _mode?: ProviderResourceMode, + onCreated?: ResourceCreationObserver, + ): Promise { // Validate every nested credential before creating the parent Vault so an // unsupported declaration cannot leave an empty remote Vault behind. for (const credential of decl.credentials ?? []) mapCredential(credential); const body = mapVault(name, decl, this.projectName); const res = (await this.client.post("/vaults", body)) as Record; const vaultId = res.id as string; + // The parent already exists even if a later Credential request fails. Only + // structured execution installs this sink; legacy exceptions and State stay unchanged. + onCreated?.({ id: vaultId }); for (const cred of decl.credentials ?? []) { await this.createCredential(vaultId, cred); @@ -1198,6 +1231,35 @@ export class BailianAdapter implements ProviderAdapter { await this.client.delete(`/sessions/${id}`); } + async mountSessionResource(sessionId: string, input: SessionResourceMountInput): Promise { + const res = (await this.client.post(`/sessions/${sessionId}/resources`, { + type: input.type, + file_id: input.file_id, + // The runtime endpoint takes the path under the sandbox session root + // ("/uploads/…"), while the SDK's neutral layer — and the create-session + // API — use the full sandbox path ("/mnt/session/uploads/…"). + mount_path: toRuntimeResourceMountPath(input.mount_path), + })) as Record; + return toSessionResourceInfo(res); + } + + async listSessionResources(sessionId: string, options?: SessionResourceListOptions): Promise { + const res = (await this.client.get(withQuery(`/sessions/${sessionId}/resources`, cursorParams(options)))) as Record< + string, + unknown + >; + return cursorPage(res, toSessionResourceInfo); + } + + async getSessionResource(sessionId: string, resourceId: string): Promise { + const res = (await this.client.get(`/sessions/${sessionId}/resources/${resourceId}`)) as Record; + return toSessionResourceInfo(res); + } + + async unmountSessionResource(sessionId: string, resourceId: string): Promise { + await this.client.delete(`/sessions/${sessionId}/resources/${resourceId}`); + } + async sendSessionMessage(sessionId: string, message: string): Promise { const body = mapSendMessage(message); const res = (await this.client.post(`/sessions/${sessionId}/events`, body)) as Record; @@ -1214,13 +1276,8 @@ export class BailianAdapter implements ProviderAdapter { }; } - async *streamSessionEvents(sessionId: string, _options?: EventStreamOptions): AsyncIterable { - // AGENTSTUDIO's stream pushes only post-connect events and accepts no cursor - // param; reconnection is done by replaying history via listSessionEvents and - // de-duplicating by event id, so `after_id` is intentionally not forwarded. - for await (const raw of this.client.sse(`/sessions/${sessionId}/events/stream`)) { - yield toSessionEvent(raw); - } + streamSessionEvents(sessionId: string, options?: EventStreamOptions): AsyncIterable { + return streamBailianSessionEvents(this.client, sessionId, options); } async listSessionEvents(sessionId: string, options?: EventListOptions): Promise { @@ -1228,7 +1285,41 @@ export class BailianAdapter implements ProviderAdapter { // http 200 with the full unfiltered list rather than rejecting), so forwarding it // buys nothing; it is never sent (mirrors claude). Shared page-cursor handling // lives in listSessionEventsPaged. - return listSessionEventsPaged(this.client, sessionId, options, toSessionEvent, { forwardTypes: false }); + assertEventOptions(this.name, options); + const result = await listSessionEventsPaged( + this.client, + sessionId, + options, + (raw) => toSessionEvent(raw, options), + { + forwardTypes: false, + }, + ); + return options?.event_format === "snapshot" + ? { ...result, events: correlateBailianHistoryEvents(result.events) } + : result; + } + + listSessionThreads(sessionId: string, options?: SessionThreadListOptions): Promise { + return listBailianSessionThreads(this.client, sessionId, options); + } + + listSessionThreadEvents( + sessionId: string, + threadId: string, + options?: EventListOptions, + ): Promise { + return listBailianSessionThreadEvents(this.client, sessionId, threadId, options); + } + + // --- Usage (app-control usage.*) --- + + listModelUsage(request: ModelUsageRequest, options?: UsageQueryOptions): Promise { + return listBailianModelUsage(this.client, request, options); + } + + listToolUsage(request: ToolUsageRequest, options?: UsageQueryOptions): Promise { + return listBailianToolUsage(this.client, request, options); } // --- Files --- @@ -1321,6 +1412,38 @@ export function toSessionInfo(res: Record): ProviderSessionInfo return sessionInfo; } +/** Sandbox session root on bailian; the runtime resources API takes paths relative to it. */ +const BAILIAN_SESSION_SANDBOX_ROOT = "/mnt/session"; + +/** + * Runtime resource mount_path wire convention: absolute under `/uploads/`. Accept the + * full sandbox path used by the neutral layer and create-session API (`/mnt/session/uploads/…`), + * or an already wire-shaped `/uploads/…` path; anything else is rejected client-side. + */ +function toRuntimeResourceMountPath(mountPath: string): string { + const wirePath = mountPath.startsWith(`${BAILIAN_SESSION_SANDBOX_ROOT}/`) + ? mountPath.slice(BAILIAN_SESSION_SANDBOX_ROOT.length) + : mountPath; + if (wirePath === "/uploads" || wirePath.startsWith("/uploads/")) return wirePath; + throw new UserError( + `bailian runtime mount_path must resolve to '/uploads/…' (sandbox '${BAILIAN_SESSION_SANDBOX_ROOT}/uploads/…'); received '${mountPath}'.`, + ); +} + +/** Raw bailian session-resource object → neutral SessionResourceInfo; the full payload rides in `attributes`. */ +function toSessionResourceInfo(res: Record): SessionResourceInfo { + return { + ...(typeof res.id === "string" ? { id: res.id } : {}), + type: (res.type as string) ?? "file", + ...(typeof res.mount_path === "string" ? { mount_path: res.mount_path } : {}), + ...(typeof res.file_id === "string" ? { file_id: res.file_id } : {}), + ...(typeof res.memory_store_id === "string" ? { memory_store_id: res.memory_store_id } : {}), + ...(res.access === "read_write" || res.access === "read_only" ? { access: res.access } : {}), + ...(typeof res.instructions === "string" ? { instructions: res.instructions } : {}), + attributes: res, + }; +} + // Raw Bailian `/skills` item → neutral ProviderSkillInfo. Kept provider-local (not the // shared toRestSkillInfo) because bailian's wire differs: name is `name` (not display_title), // the custom catalog reports `customer`, and skills carry a real security-scan status. @@ -1421,6 +1544,10 @@ function normalizeBailianModel(value: unknown): unknown { return value; } +function bailianPermissionType(value: unknown): unknown { + return value && typeof value === "object" ? (value as Record).type : value; +} + function normalizeBailianTools(value: unknown): unknown { if (!Array.isArray(value)) return undefined; const builtins = value.find( @@ -1430,12 +1557,21 @@ function normalizeBailianTools(value: unknown): unknown { const configs = builtins.configs; if (!Array.isArray(configs)) return undefined; - const enabled = configs + const enabledConfigs = configs .map((c) => c as Record) - .filter((c) => c.enabled !== false && typeof c.name === "string") - .map((c) => c.name as string); + .filter((c) => c.enabled !== false && typeof c.name === "string"); + const enabled = enabledConfigs.map((c) => c.name as string); + const defaults = builtins.default_config as { permission_policy?: unknown } | undefined; + const inherited = bailianPermissionType(defaults?.permission_policy) ?? "always_allow"; + const permissions = Object.fromEntries( + enabledConfigs.flatMap((tool) => { + const permission = bailianPermissionType(tool.permission_policy) ?? inherited; + // Keep legacy allow-only baselines stable while detecting effective approval changes. + return permission === "always_allow" ? [] : [[tool.name as string, permission] as const]; + }), + ); - return enabled.length ? { builtin: enabled } : undefined; + return enabled.length ? { builtin: enabled, ...(Object.keys(permissions).length ? { permissions } : {}) } : undefined; } function normalizeBailianMcpServers(value: unknown): unknown { diff --git a/packages/sdk/src/internal/providers/bailian/client.ts b/packages/sdk/src/internal/providers/bailian/client.ts index 9c70034..4454b21 100644 --- a/packages/sdk/src/internal/providers/bailian/client.ts +++ b/packages/sdk/src/internal/providers/bailian/client.ts @@ -29,6 +29,7 @@ export class BailianClient extends BaseApiClient { return { "Content-Type": "application/json", Authorization: `Bearer ${this.apiKey}`, + "x-dashscope-agentstudio-source-config": "openagentpack", }; } diff --git a/packages/sdk/src/internal/providers/bailian/event-accumulator.ts b/packages/sdk/src/internal/providers/bailian/event-accumulator.ts new file mode 100644 index 0000000..2691df9 --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/event-accumulator.ts @@ -0,0 +1,336 @@ +import type { SessionContentBlock } from "../../types/dto.ts"; +import type { ProviderSessionEvent } from "../../types/session-event.ts"; +import { expandBailianEventFrame, isBailianEventFrame } from "./event-frame.ts"; +import { toSessionEvent } from "./event-mapper.ts"; +import { + BailianEventProtocolError, + cloneEventValue, + deriveArtifacts, + isRecord, + normalizeContent, +} from "./snapshot-mapper.ts"; + +interface MessageState { + identity?: Record; + blocks: Map; + pending: { raw: Record; content?: SessionContentBlock }[]; + completed: boolean; + needsAuthoritativeContent?: boolean; + lastSnapshot?: string; + /** Only the SDK stream marks delivery; seeding history alone does not qualify for replay. */ + deliveredSnapshot?: string; + /** Public history recovery retains identities until clear(), never silently evicting them. */ + historySeeded?: boolean; + historyFinalContent?: boolean; + recoveringHistory?: boolean; +} + +/** One instance belongs to one logical subscription, including its reconnect attempts. */ +export class BailianEventAccumulator { + private readonly messages = new Map(); + private readonly callNames = new Map(); + private readonly interruptedContent = new Set(); + private readonly interruptedMessages = new Set(); + private readonly maxEntries: number; + private readonly boundContentBlocks: boolean; + private pendingCount = 0; + private recovering = false; + + constructor(options: { maxEntries?: number; boundContentBlocks?: boolean } = {}) { + this.maxEntries = options.maxEntries ?? 1024; + this.boundContentBlocks = options.boundContentBlocks ?? false; + if (!Number.isInteger(this.maxEntries) || this.maxEntries < 1) { + throw new RangeError("Bailian accumulator maxEntries must be a positive integer."); + } + } + + push(raw: Record): ProviderSessionEvent | undefined { + const expanded = expandBailianEventFrame(raw); + const event = expanded.content + ? this.ingestContent(expanded.event, expanded.content) + : this.ingest(expanded.event, false); + if (event) event.raw = raw; + return event; + } + + /** Only complete business events can advance the stream's recovery marker. */ + isCompleted(id: string): boolean { + return this.messages.get(id)?.completed === true; + } + + /** History entries are authoritative completed events, even when lifecycle fields are absent. */ + seed(raw: Record): ProviderSessionEvent | undefined { + if (raw.object === "content" || isBailianEventFrame(raw)) { + throw new BailianEventProtocolError("Bailian history must contain complete events."); + } + return this.ingest(raw, true); + } + + /** + * Browser consumers may read history while a message is still being generated. + * Its content has no delta watermark: expose it for display, never as an append baseline. + * Kept separate from seed() so existing server recovery behavior remains unchanged. + */ + seedSnapshot(raw: Record): ProviderSessionEvent | undefined { + if (raw.object === "content" || isBailianEventFrame(raw)) { + throw new BailianEventProtocolError("Bailian history must contain complete events."); + } + const id = typeof raw.id === "string" ? raw.id : raw.event_id; + if (raw.status === "in_progress") { + if (typeof id !== "string" || !id) { + throw new BailianEventProtocolError("Bailian unfinished history is missing its event ID."); + } + const event = toSessionEvent(raw, { event_format: "snapshot" }); + const state = this.getState(id); + if (state.completed) return undefined; + this.correlateTool(event); + state.identity = cloneEventValue(raw); + delete state.identity.content; + state.blocks.clear(); + this.pendingCount -= state.pending.length; + state.pending = []; + state.historySeeded = true; + state.recoveringHistory = true; + state.needsAuthoritativeContent = true; + return event; + } + const event = this.seed(raw); + if (typeof id === "string" && id) { + const state = this.getState(id); + state.historySeeded = true; + // Status/tool events can change at the same ID. Freeze only finalized text/reasoning. + state.historyFinalContent = state.identity?.type === "message" || state.identity?.type === "reasoning"; + state.recoveringHistory = false; + } + return event; + } + + /** Recovery must repair older unfinished messages even if a newer message completed first. */ + pendingMessageIds(): string[] { + return [ + ...new Set([ + ...this.interruptedMessages, + ...[...this.messages].filter(([, state]) => !state.completed).map(([id]) => id), + ]), + ]; + } + + captureDelivery() { + // Capture before seeding pages: replaying old history can evict these bounded states. + const snapshots = new Map(); + for (const [id, state] of this.messages) { + if (state.deliveredSnapshot !== undefined) snapshots.set(id, state.deliveredSnapshot); + } + return { + has: (id: string) => snapshots.has(id), + get: (id: string) => snapshots.get(id), + matches: (event: ProviderSessionEvent, prior = snapshots.get(event.id ?? "")) => + event.id !== undefined && prior === stableKey(event.snapshot), + }; + } + + markDelivered(event: ProviderSessionEvent): void { + const state = event.id ? this.messages.get(event.id) : undefined; + if (state) state.deliveredSnapshot = stableKey(event.snapshot); + } + + /** Never append a resumed delta to a pre-disconnection partial baseline. */ + resetPartials(): void { + for (const [id, state] of this.messages) { + if (!state.completed) { + this.interruptedMessages.add(id); + if (state.blocks.size || state.pending.length || state.needsAuthoritativeContent) + this.interruptedContent.add(id); + this.messages.delete(id); + } + } + if (this.interruptedMessages.size > this.maxEntries) { + throw new BailianEventProtocolError("Bailian interrupted message buffer exceeded its limit."); + } + this.pendingCount = 0; + this.recovering = true; + } + + clear(): void { + this.messages.clear(); + this.callNames.clear(); + this.interruptedContent.clear(); + this.interruptedMessages.clear(); + this.pendingCount = 0; + this.recovering = false; + } + + private ingest(raw: Record, history: boolean): ProviderSessionEvent | undefined { + if (raw.object === "content") return this.ingestContent(raw); + const id = typeof raw.id === "string" ? raw.id : raw.event_id; + if (typeof id !== "string" || !id) { + const event = toSessionEvent(raw, { event_format: "snapshot" }); + this.correlateTool(event); + return event; + } + const state = this.getState(id); + if (!history && state.historyFinalContent) return undefined; + if (!history && state.recoveringHistory && raw.status !== "completed") return undefined; + const completes = + history || + raw.status === "completed" || + (raw.object !== "message" && (raw.status === undefined || raw.type === "session_status")); + if (state.completed && !completes) return undefined; + const merged = mergeSparse(state.identity ?? {}, raw); + // Identity is never inferred from the content frame's block type (for example "text"). + if (typeof merged.type !== "string" || !merged.type) { + throw new BailianEventProtocolError("Bailian message is missing its type."); + } + state.identity = merged; + if (completes && state.needsAuthoritativeContent && raw.content === undefined) { + throw new BailianEventProtocolError("Bailian resumed message is missing an authoritative content snapshot."); + } + if (raw.content !== undefined) { + state.recoveringHistory = false; + state.needsAuthoritativeContent = false; + this.interruptedContent.delete(id); + } + this.interruptedMessages.delete(id); + if (raw.content !== undefined) this.replaceBlocks(state, normalizeContent(raw.content)); + if (state.pending.length) { + // A final explicit content array supersedes all older orphaned fragments. + if (!completes || raw.content === undefined) { + for (const frame of state.pending) this.applyContent(state, frame.raw, frame.content); + } + this.pendingCount -= state.pending.length; + state.pending = []; + } + state.completed = completes; + if (state.historySeeded && completes) { + state.historyFinalContent = state.identity.type === "message" || state.identity.type === "reasoning"; + } + return this.emit(state, raw); + } + + private ingestContent(raw: Record, content?: SessionContentBlock): ProviderSessionEvent | undefined { + if (typeof raw.msg_id !== "string" || !raw.msg_id) { + throw new BailianEventProtocolError("Bailian content frame is missing msg_id."); + } + if (!Number.isInteger(raw.index) || (raw.index as number) < 0) { + throw new BailianEventProtocolError("Bailian content frame has an invalid index."); + } + if (raw.delta !== true && raw.delta !== false) { + throw new BailianEventProtocolError("Bailian content frame is missing its delta mode."); + } + const state = this.getState(raw.msg_id); + if (state.completed || state.recoveringHistory) return undefined; + if (!state.identity) { + if (this.pendingCount >= this.maxEntries) { + throw new BailianEventProtocolError("Bailian orphan content buffer exceeded its limit."); + } + state.pending.push({ raw: cloneEventValue(raw), ...(content ? { content: cloneEventValue(content) } : {}) }); + state.needsAuthoritativeContent = this.recovering; + this.pendingCount++; + return undefined; + } + this.applyContent(state, raw, content); + return this.emit(state, raw); + } + + private applyContent(state: MessageState, raw: Record, content?: SessionContentBlock): void { + const index = raw.index as number; + if (this.boundContentBlocks && !state.blocks.has(index) && state.blocks.size >= this.maxEntries) { + throw new BailianEventProtocolError("Bailian content block buffer exceeded its limit."); + } + const prior = state.blocks.get(index); + const fields = + content ?? Object.fromEntries(Object.entries(raw).filter(([key]) => !CONTENT_ENVELOPE_FIELDS.has(key))); + const baseline = raw.delta === true ? prior : prior ? { type: prior.type } : undefined; + const block = normalizeContent([{ ...baseline, ...fields }])[0]!; + if (raw.delta === true && typeof fields.text === "string") { + block.text = (prior?.text ?? "") + fields.text; + } + state.blocks.set(index, block); + } + + private replaceBlocks(state: MessageState, blocks: SessionContentBlock[]): void { + if (this.boundContentBlocks && blocks.length > this.maxEntries) { + throw new BailianEventProtocolError("Bailian content block buffer exceeded its limit."); + } + state.blocks.clear(); + for (const [position, block] of blocks.entries()) { + const index = + typeof block.index === "number" && Number.isInteger(block.index) && block.index >= 0 ? block.index : position; + state.blocks.set(index, block); + } + } + + private emit(state: MessageState, raw: Record): ProviderSessionEvent | undefined { + // A sparse restart only identifies the message; it does not establish which + // pre-disconnection text or other blocks are missing from the resumed tail. + if (state.needsAuthoritativeContent) return undefined; + const aggregate = cloneEventValue(state.identity!); + if (state.blocks.size || aggregate.content !== undefined) { + aggregate.content = [...state.blocks.entries()] + .sort(([a], [b]) => a - b) + .map(([, block]) => cloneEventValue(block)); + } + const event = toSessionEvent(aggregate, { event_format: "snapshot" }); + this.correlateTool(event); + const serialized = stableKey(event.snapshot); + // Only completed snapshots are deduplicated: repeated text deltas are legitimate output. + if (state.completed && state.lastSnapshot === serialized) return undefined; + state.lastSnapshot = serialized; + event.raw = raw; + return event; + } + + private correlateTool(event: ProviderSessionEvent): void { + if (event.type !== "tool_use" && event.type !== "tool_result") return; + const metadata = event.snapshot?.metadata; + const callId = metadata?.call_id; + if (typeof callId !== "string" || !callId) return; + if (event.tool_name) { + this.callNames.delete(callId); + this.callNames.set(callId, event.tool_name); + while (this.callNames.size > this.maxEntries) this.callNames.delete(this.callNames.keys().next().value!); + } else { + const name = this.callNames.get(callId); + if (name && metadata) metadata.tool_name = event.tool_name = name; + } + deriveArtifacts(event); + } + + private getState(id: string): MessageState { + let state = this.messages.get(id); + if (state) return state; + if (this.messages.size >= this.maxEntries) { + const evictable = [...this.messages].find(([, item]) => item.completed && !item.historySeeded); + if (!evictable) throw new BailianEventProtocolError("Bailian active message buffer exceeded its limit."); + this.messages.delete(evictable[0]); + } + state = { + blocks: new Map(), + pending: [], + completed: false, + needsAuthoritativeContent: this.interruptedContent.has(id), + }; + this.messages.set(id, state); + return state; + } +} + +const CONTENT_ENVELOPE_FIELDS = new Set(["object", "msg_id", "index", "delta", "status", "id", "event_id"]); + +function mergeSparse(prior: Record, next: Record): Record { + const merged = cloneEventValue(prior); + for (const [key, value] of Object.entries(next)) { + if (value === undefined) continue; + merged[key] = + key === "metadata" && isRecord(value) && isRecord(merged[key]) + ? { ...merged[key], ...cloneEventValue(value) } + : cloneEventValue(value); + } + return merged; +} + +function stableKey(value: unknown): string { + return JSON.stringify(value, (_key, item: unknown) => + isRecord(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item, + ); +} diff --git a/packages/sdk/src/internal/providers/bailian/event-frame.ts b/packages/sdk/src/internal/providers/bailian/event-frame.ts new file mode 100644 index 0000000..0bf8541 --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/event-frame.ts @@ -0,0 +1,57 @@ +import type { SessionContentBlock } from "../../types/dto.ts"; +import { BailianEventProtocolError, isRecord, normalizeContent } from "./snapshot-mapper.ts"; + +export interface ExpandedBailianEventFrame { + event: Record; + /** Keep nested block fields separate from the stream envelope's own ID and status. */ + content?: SessionContentBlock; +} + +/** Convert stream envelopes to the existing message/content accumulator vocabulary. */ +export function expandBailianEventFrame(raw: Record): ExpandedBailianEventFrame { + if (raw.type === "event_start") { + const { event, type: _type, ...envelope } = raw; + if ( + !isRecord(event) || + typeof event.id !== "string" || + !event.id || + typeof event.type !== "string" || + !event.type + ) { + throw new BailianEventProtocolError("Bailian event_start is missing its event identity."); + } + return { + event: { + ...envelope, + ...event, + ...(isRecord(envelope.metadata) && isRecord(event.metadata) + ? { metadata: { ...envelope.metadata, ...event.metadata } } + : {}), + object: "message", + status: "in_progress", + }, + }; + } + if (raw.type === "event_delta") { + if (typeof raw.event_id !== "string" || !raw.event_id || !isRecord(raw.delta)) { + throw new BailianEventProtocolError("Bailian event_delta is missing its event ID or delta."); + } + const delta = raw.delta; + const content = + delta.type === "reasoning_delta" && typeof delta.reasoning === "string" + ? { type: "text", text: delta.reasoning } + : delta.type === "content_delta" && isRecord(delta.content) + ? normalizeContent([delta.content])[0]! + : undefined; + if (!content) throw new BailianEventProtocolError("Unsupported Bailian event_delta content."); + return { + event: { object: "content", msg_id: raw.event_id, index: delta.index, delta: true }, + content, + }; + } + return { event: raw }; +} + +export function isBailianEventFrame(raw: Record): boolean { + return raw.type === "event_start" || raw.type === "event_delta"; +} diff --git a/packages/sdk/src/internal/providers/bailian/event-mapper.ts b/packages/sdk/src/internal/providers/bailian/event-mapper.ts index c3de68b..74bcb05 100644 --- a/packages/sdk/src/internal/providers/bailian/event-mapper.ts +++ b/packages/sdk/src/internal/providers/bailian/event-mapper.ts @@ -4,6 +4,7 @@ import type { SessionEventType } from "../../types/dto.ts"; import type { ProviderSessionEvent } from "../../types/session-event.ts"; +import { attachSnapshot, type BailianEventMappingOptions } from "./snapshot-mapper.ts"; const BAILIAN_EVENT_MAP: Record = { message: "message", @@ -20,7 +21,15 @@ const BAILIAN_EVENT_MAP: Record = { error: "error", }; -export function toSessionEvent(raw: Record): ProviderSessionEvent { +export function toSessionEvent( + raw: Record, + options: BailianEventMappingOptions = {}, +): ProviderSessionEvent { + const event = toLegacySessionEvent(raw); + return options.event_format === "snapshot" ? attachSnapshot(event, raw) : event; +} + +function toLegacySessionEvent(raw: Record): ProviderSessionEvent { const rawType = (raw.type as string) ?? ""; const type: SessionEventType = BAILIAN_EVENT_MAP[rawType] ?? "unknown"; diff --git a/packages/sdk/src/internal/providers/bailian/event-normalizer.ts b/packages/sdk/src/internal/providers/bailian/event-normalizer.ts new file mode 100644 index 0000000..b44c9ec --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/event-normalizer.ts @@ -0,0 +1,36 @@ +import { type SessionEventSanitizerOptions, sanitizeSessionEvent } from "../../core/session-event-sanitizer.ts"; +import type { SessionEvent } from "../../types/dto.ts"; +import type { ProviderSessionEvent } from "../../types/session-event.ts"; +import { BailianEventAccumulator } from "./event-accumulator.ts"; + +export interface BailianSessionEventNormalizerOptions extends SessionEventSanitizerOptions { + /** Maximum retained identities, orphan frames and blocks per message. Defaults to 1024. */ + maxEntries?: number; +} + +export interface BailianSessionEventNormalizer { + /** Consume one parsed Bailian business frame, returning a cumulative contract snapshot. */ + push(raw: Record): SessionEvent | undefined; + /** Display and protect history; unfinished text is never used as a resumed delta baseline. */ + seed(raw: Record): SessionEvent | undefined; + /** Release all state. Call before rebuilding history or changing the logical session. */ + clear(): void; +} + +/** + * Pure browser-safe Bailian conversion. No HTTP, credentials, SSE framing or retry policy. + * Use one instance per subscription. Redaction/truncation default to true; raw defaults off. + */ +export function createBailianSessionEventNormalizer( + options: BailianSessionEventNormalizerOptions = {}, +): BailianSessionEventNormalizer { + const { maxEntries, ...policy } = options; + const accumulator = new BailianEventAccumulator({ maxEntries, boundContentBlocks: true }); + const normalize = (event: ProviderSessionEvent | undefined): SessionEvent | undefined => + event === undefined ? undefined : sanitizeSessionEvent(event, policy); + return { + push: (raw) => normalize(accumulator.push(raw)), + seed: (raw) => normalize(accumulator.seedSnapshot(raw)), + clear: () => accumulator.clear(), + }; +} diff --git a/packages/sdk/src/internal/providers/bailian/history-event-correlation.ts b/packages/sdk/src/internal/providers/bailian/history-event-correlation.ts new file mode 100644 index 0000000..ebceaa4 --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/history-event-correlation.ts @@ -0,0 +1,30 @@ +import type { ProviderSessionEvent } from "../../types/session-event.ts"; +import { deriveArtifacts } from "./snapshot-mapper.ts"; + +/** + * Correlate within one fetched page only. The provider may return descending order, + * so collect identities before decorating outputs; never guess across queries/pages. + */ +export function correlateBailianHistoryEvents(events: ProviderSessionEvent[]): ProviderSessionEvent[] { + const names = new Map(); + for (const event of events) { + const callId = event.snapshot?.metadata?.call_id; + if (event.type !== "tool_use" || typeof callId !== "string" || !callId || !event.tool_name) continue; + const previous = names.get(callId); + names.set(callId, previous !== undefined && previous !== event.tool_name ? null : event.tool_name); + } + return events.map((event) => { + const snapshot = event.snapshot; + const callId = snapshot?.metadata?.call_id; + if (event.type !== "tool_result" || event.tool_name || !snapshot || typeof callId !== "string") return event; + const name = names.get(callId); + if (!name) return event; + const correlated: ProviderSessionEvent = { + ...event, + tool_name: name, + snapshot: { ...snapshot, metadata: { ...snapshot.metadata, tool_name: name } }, + }; + deriveArtifacts(correlated); + return correlated; + }); +} diff --git a/packages/sdk/src/internal/providers/bailian/index.ts b/packages/sdk/src/internal/providers/bailian/index.ts index a125bb0..d860b10 100644 --- a/packages/sdk/src/internal/providers/bailian/index.ts +++ b/packages/sdk/src/internal/providers/bailian/index.ts @@ -7,7 +7,7 @@ registerProvider({ name: "bailian", configSchema: bailianConfigSchema, capabilities: BAILIAN_CAPABILITIES, - features: { tool_permissions: false, session_resources: ["memory_store"] }, + features: { tool_permissions: true, session_resources: ["memory_store"] }, createAdapter: (config, projectName) => { const c = config as BailianConfig; return new BailianAdapter(c.api_key, c.workspace_id, c.base_url, projectName); diff --git a/packages/sdk/src/internal/providers/bailian/mapper.ts b/packages/sdk/src/internal/providers/bailian/mapper.ts index 56df948..565c42b 100644 --- a/packages/sdk/src/internal/providers/bailian/mapper.ts +++ b/packages/sdk/src/internal/providers/bailian/mapper.ts @@ -13,7 +13,13 @@ import type { import type { ManagedSessionBindings } from "../../types/session.ts"; import { compactDeep, stripAgentsMetadata } from "../../utils/comparable.ts"; import { resolveSandboxMountPath } from "../../utils/sandbox-mount.ts"; -import { resolveBuiltinTools } from "../../utils/tool-permissions.ts"; +import { + canonicalToolName, + permissionFromWire, + permissionOverridesFromWire, + resolveBuiltinTools, + toPermissionPolicy, +} from "../../utils/tool-permissions.ts"; import { assertDeploymentEnvironmentVariables } from "../../validation/deployment-environment.ts"; import type { MappingOperation, ResolvedAgentRefs, ResolvedDeploymentRefs } from "../interface.ts"; import { injectMetadata, secretPlaceholder } from "../sync-mapping.ts"; @@ -170,14 +176,31 @@ export function agentToDecl( // Reverse-map tools: extract builtin names from builtin_toolkit configs let builtinTools: string[] | undefined; + let builtinDefaultPermission: "allow" | "ask" | undefined; + let builtinPermissions: Record | undefined; if (tools?.length) { const toolset = tools.find((t) => t.type === "builtin_toolkit"); if (toolset) { const configs = (toolset.configs ?? []) as Array<{ name: string; enabled?: boolean; + permission_policy?: unknown; }>; builtinTools = configs.filter((c) => c.enabled !== false).map((c) => c.name); + const defaults = toolset.default_config as { enabled?: boolean; permission_policy?: unknown } | undefined; + builtinDefaultPermission = permissionFromWire(defaults?.permission_policy); + builtinPermissions = permissionOverridesFromWire(configs); + // A default-enabled toolkit has an open-ended provider-owned tool catalogue. + // The schema can only enumerate enabled tools; guessing would lose policies. + if ( + defaults?.enabled === true && + (builtinDefaultPermission === "ask" || Object.values(builtinPermissions ?? {}).includes("ask")) + ) { + throw new UserError( + "sync.agent.tool_permissions.implicit_tools: Cannot export approval policies from a default-enabled Bailian toolkit. Set default_config.enabled to false and explicitly enable each required tool before exporting. / 默认启用全部工具的审批策略无法无损导出;请关闭默认启用并显式列出所需工具。", + ); + } + if (!builtinTools.length && defaults?.enabled !== false) builtinTools = undefined; } } @@ -209,10 +232,12 @@ export function agentToDecl( description: raw.description as string | undefined, model: modelValue, instructions: raw.system as string | undefined, - tools: builtinTools?.length ? { builtin: builtinTools } : undefined, + tools: builtinTools + ? { builtin: builtinTools, default_permission: builtinDefaultPermission, permissions: builtinPermissions } + : undefined, mcp_servers: mcpServerDecls, skills: skillDecls, - multiagent: reverseMultiagentDecl(raw.multiagent, resolveMember), + multiagent: reverseMultiagentDecl(raw.multiagent, resolveMember, true), metadata: stripAgentsMetadata(raw.metadata), }) as Record; } @@ -263,16 +288,25 @@ export function mapAgent( "mark_artifacts", ]); if (decl.tools) { + const permissionNames = new Set(Object.keys(decl.tools.permissions ?? {}).map(canonicalToolName)); const toolConfigs = resolveBuiltinTools(decl.tools, { supportedWireNames: BAILIAN_BUILTINS, }).map((tool) => ({ name: tool.wireName, enabled: true, + ...(permissionNames.has(canonicalToolName(tool.configuredName)) + ? { permission_policy: toPermissionPolicy(tool.permission) } + : {}), })); body.tools = [ { type: "builtin_toolkit", - default_config: { enabled: false }, + default_config: { + enabled: false, + ...(decl.tools.default_permission + ? { permission_policy: toPermissionPolicy(decl.tools.default_permission) } + : {}), + }, configs: toolConfigs, }, ]; @@ -325,7 +359,9 @@ export function mapAgent( body.multiagent = { type: "coordinator", // No version: Bailian resolves the child Thread on first creation. - agents: refs.multiagent.members.map(({ remote_id }) => ({ type: "agent", id: remote_id })), + agents: refs.multiagent.members.map((member) => + "type" in member ? { type: "self" } : { type: "agent", id: member.remote_id }, + ), }; } else if (operation === "update") { // Bailian updates replace the field wholesale; an empty roster clears it. diff --git a/packages/sdk/src/internal/providers/bailian/session-stream.ts b/packages/sdk/src/internal/providers/bailian/session-stream.ts new file mode 100644 index 0000000..142ead6 --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/session-stream.ts @@ -0,0 +1,362 @@ +import { UserError } from "../../errors.ts"; +import type { EventStreamOptions, ProviderSessionEvent } from "../../types/session-event.ts"; +import { ApiError, type BaseApiClient, SseTransportError } from "../base-client.ts"; +import { assertStreamOptions, sessionEventFormat } from "../session-event-options.ts"; +import { listSessionEventsPaged } from "../session-event-response.ts"; +import { sessionStreamTurn } from "../session-stream-turn.ts"; +import { BailianEventAccumulator } from "./event-accumulator.ts"; +import { toSessionEvent } from "./event-mapper.ts"; + +const MAX_BUFFERED_FRAMES = 1024; +const MAX_BUFFERED_BYTES = 8 * 1024 * 1024; +const RETRY_DELAYS = [250, 500, 1000]; +const TERMINAL_STATUSES = new Set(["idle", "completed", "failed", "terminated", "deleted"]); +type RawEvent = Record; + +/** Bailian has no native cursor replay. Recovery combines a live subscription with REST history. */ +export async function* streamBailianSessionEvents( + client: BaseApiClient, + sessionId: string, + options: EventStreamOptions = {}, +): AsyncGenerator { + assertStreamOptions("bailian", options); + const snapshot = sessionEventFormat(options) === "snapshot"; + const params = new URLSearchParams(); + for (const type of new Set(options.event_deltas)) params.append("event_deltas[]", type); + const path = `/sessions/${sessionId}/events/stream${params.size ? `?${params}` : ""}`; + if (!snapshot) { + for await (const raw of client.sse(path, options)) yield toSessionEvent(raw); + return; + } + + const accumulator = new BailianEventAccumulator(); + // History may create a status before the answer it later completes. Keep such + // updates until all history is repaired, including across a failed history attempt. + const recoveredStatuses = new Map(); + const unfinished = new Set(); + const turnStart = sessionStreamTurn(options); + let retries = 0; + let recover = options.after_id !== undefined; + let lastCompletedId = options.after_id; + while (true) { + throwIfAborted(options.signal); + const controller = new AbortController(); + const abort = () => controller.abort(); + options.signal?.addEventListener("abort", abort, { once: true }); + let pump: Promise | undefined; + let queue: FrameQueue | undefined; + try { + throwIfAborted(options.signal); + const ready = deferred(); + // This rejection always has a handler, including failures before onReady. + void ready.promise.catch(() => {}); + queue = new FrameQueue(); + const activeQueue = queue; + const source = client.sse(path, { + ...options, + strict: true, + signal: controller.signal, + onReady: () => { + options.onReady?.(); + ready.resolve(); + }, + }); + pump = (async () => { + try { + for await (const raw of source) activeQueue.push(raw); + throw new SseTransportError("unexpected-eof"); + } catch (error) { + ready.reject(error); + activeQueue.fail(error); + } + })(); + await ready.promise; + throwIfAborted(options.signal); + let repairingWithLiveStatus = false; + if (recover) { + // onReady has already allowed the parent to POST. Wait for its identity + // before replaying history, including initial after_id subscriptions. + const sentEventId = turnStart + ? await waitForHistory(turnStart, activeQueue, controller.signal, options.connectTimeoutMs ?? 30_000) + : undefined; + if (turnStart && !sentEventId) { + throw new UserError("Cannot recover this session turn: send response did not include an event id."); + } + let turnFound = turnStart === undefined; + const interrupted = new Set(accumulator.pendingMessageIds()); + for (const id of interrupted) trackUnfinished(unfinished, id); + const delivered = accumulator.captureDelivery(); + accumulator.resetPartials(); + const marker = lastCompletedId ?? sentEventId; + let markerFound = marker === undefined; + const cursors = new Set(); + let page: string | undefined; + do { + throwIfAborted(options.signal); + const result = await waitForHistory( + listSessionEventsPaged( + client, + sessionId, + { + limit: 100, + order: "asc", + page_token: page, + signal: controller.signal, + }, + (raw) => toSessionEvent(raw, { event_format: "snapshot" }), + { forwardTypes: false }, + ), + activeQueue, + controller.signal, + options.connectTimeoutMs ?? 30_000, + ); + for (const event of result.events) { + throwIfAborted(options.signal); + if (event.id === sentEventId) turnFound = true; + const beforeMarker = !markerFound; + if (event.id === marker) { + markerFound = true; + if (turnFound) lastCompletedId = marker; + } + // In-progress history has no frame-level watermark; never append live deltas to it. + if (event.raw.status === "in_progress") { + if (event.id && accumulator.isCompleted(event.id)) continue; + if ( + turnFound && + (!beforeMarker || + (event.id && (interrupted.has(event.id) || delivered.has(event.id) || unfinished.has(event.id)))) + ) { + if (!event.id) throw new UserError("Unfinished Session history is missing its event ID."); + trackUnfinished(unfinished, event.id); + } + continue; + } + const mapped = accumulator.seed(event.raw); + if (event.id) unfinished.delete(event.id); + // Still seed old events for correlation/dedup, but never deliver a + // previous turn's assistant or terminal state to a single-turn send. + if (!turnFound) continue; + if (mapped) { + // Creation order differs from update/completion order. Only IDs + // actually delivered (or interrupted) may cross an exclusive marker. + if ( + beforeMarker && + (!mapped.id || + (!interrupted.has(mapped.id) && !delivered.has(mapped.id) && !recoveredStatuses.has(mapped.id))) + ) + continue; + const pendingStatus = mapped.id ? recoveredStatuses.get(mapped.id) : undefined; + if (delivered.matches(mapped, pendingStatus?.deliveredSnapshot)) { + if (mapped.id) recoveredStatuses.delete(mapped.id); + accumulator.markDelivered(mapped); + continue; + } + if (mapped.id && !beforeMarker) lastCompletedId = mapped.id; + if ( + mapped.id && + mapped.type === "status" && + (recoveredStatuses.size > 0 || TERMINAL_STATUSES.has(mapped.status ?? "")) + ) { + // Replacing the same ID also cancels a deferred terminal state + // if a later recovery observes it running again. + if (!recoveredStatuses.has(mapped.id) && recoveredStatuses.size >= MAX_BUFFERED_FRAMES) + throw new UserError("Session status recovery buffer exceeded its limit."); + recoveredStatuses.set(mapped.id, { + event: mapped, + // Retain only the original delivery fingerprint across retries: + // older history pages may evict the accumulator's copy. + deliveredSnapshot: pendingStatus?.deliveredSnapshot ?? delivered.get(mapped.id), + }); + continue; + } + accumulator.markDelivered(mapped); + yield mapped; + } + } + if (result.has_more && !result.next_page) + throw new UserError("Session event history is missing a pagination cursor."); + page = result.next_page; + if (page && cursors.has(page)) throw new UserError("Session event pagination returned a repeated cursor."); + if (page) cursors.add(page); + } while (page); + if (!turnFound) throw new UserError("Session turn's sent event was not found in history."); + if (!markerFound) throw new UserError("Session event resume marker was not found in history."); + // Pages are not a consistent snapshot. If text still needs repair, a + // historical terminal state cannot establish a safe handoff to live events. + // Require a live status after all unfinished identities have converged instead. + repairingWithLiveStatus = unfinished.size > 0; + if (repairingWithLiveStatus) recoveredStatuses.clear(); + for (const [id, { event }] of recoveredStatuses) { + throwIfAborted(options.signal); + recoveredStatuses.delete(id); + accumulator.markDelivered(event); + yield event; + } + } + while (true) { + throwIfAborted(options.signal); + const raw = repairingWithLiveStatus + ? await waitForHistory(queue.next(), activeQueue, controller.signal, options.connectTimeoutMs ?? 30_000) + : await queue.next(); + throwIfAborted(options.signal); + let event = accumulator.push(raw); + if (repairingWithLiveStatus) { + const id = + event?.id ?? + (typeof raw.id === "string" ? raw.id : typeof raw.event_id === "string" ? raw.event_id : undefined); + if (id && accumulator.isCompleted(id)) unfinished.delete(id); + else if (event?.id) trackUnfinished(unfinished, event.id); + // A complete live status may duplicate the historical status that was + // deliberately withheld. Its position after the repaired answer still matters. + if (!event && raw.type === "session_status") event = toSessionEvent(raw, { event_format: "snapshot" }); + if (event?.type === "status" && event.status !== undefined) { + if (unfinished.size === 0) repairingWithLiveStatus = false; + else if (TERMINAL_STATUSES.has(event.status)) continue; + } + } + if (event) { + if (event.id && accumulator.isCompleted(event.id)) lastCompletedId = event.id; + accumulator.markDelivered(event); + yield event; + } + } + } catch (error) { + throwIfAborted(options.signal); + if (!options.reconnect || !retryable(error) || retries >= RETRY_DELAYS.length) { + // History HTTP errors include provider response bodies; do not expose them here. + if (error instanceof ApiError) throw new SseTransportError("http", error.statusCode); + throw error; + } + } finally { + controller.abort(); + queue?.clear(); + await pump; + options.signal?.removeEventListener("abort", abort); + } + recover = true; + await abortableDelay(RETRY_DELAYS[retries++]!, options.signal); + } +} + +function trackUnfinished(ids: Set, id: string): void { + if (!ids.has(id) && ids.size >= MAX_BUFFERED_FRAMES) { + throw new UserError("Session unfinished event recovery buffer exceeded its limit."); + } + ids.add(id); +} + +function retryable(error: unknown): boolean { + return error instanceof SseTransportError + ? error.retryable + : error instanceof ApiError && (error.statusCode === 429 || error.statusCode >= 500); +} + +function throwIfAborted(signal?: AbortSignal): void { + if (signal?.aborted) throw new DOMException("Session event stream cancelled.", "AbortError"); +} + +function abortableDelay(ms: number, signal?: AbortSignal): Promise { + throwIfAborted(signal); + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + signal?.removeEventListener("abort", abort); + resolve(); + }, ms); + const abort = () => { + clearTimeout(timer); + signal?.removeEventListener("abort", abort); + reject(new DOMException("Session event stream cancelled.", "AbortError")); + }; + signal?.addEventListener("abort", abort, { once: true }); + }); +} + +function deferred() { + let resolve!: () => void; + let reject!: (error: unknown) => void; + const promise = new Promise((yes, no) => { + resolve = yes; + reject = no; + }); + return { promise, resolve, reject }; +} + +class FrameQueue { + private items: { raw: RawEvent; bytes: number }[] = []; + private readonly failureSignal = deferred(); + readonly failurePromise = this.failureSignal.promise; + constructor() { + void this.failurePromise.catch(() => {}); + } + private bytes = 0; + private failure: unknown; + private failed = false; + private wake?: () => void; + + push(raw: RawEvent): void { + const bytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength; + if (this.items.length >= MAX_BUFFERED_FRAMES || this.bytes + bytes > MAX_BUFFERED_BYTES) { + throw new UserError("Session event recovery buffer exceeded its limit."); + } + this.items.push({ raw, bytes }); + this.bytes += bytes; + this.wake?.(); + } + + fail(error: unknown): void { + if (this.failed) return; + this.failure = error; + this.failed = true; + this.failureSignal.reject(error); + this.wake?.(); + } + clear(): void { + this.items = []; + this.bytes = 0; + } + async next(): Promise { + while (!this.items.length) { + if (this.failed) throw this.failure; + await new Promise((resolve) => { + this.wake = resolve; + }); + this.wake = undefined; + } + const item = this.items.shift()!; + this.bytes -= item.bytes; + return item.raw; + } +} + +async function waitForHistory( + pending: Promise, + queue: FrameQueue, + signal: AbortSignal, + timeoutMs: number, +): Promise { + let timer: ReturnType | undefined; + let abort: () => void = () => {}; + const stopped = new Promise((_resolve, reject) => { + abort = () => reject(new DOMException("Session event stream cancelled.", "AbortError")); + if (signal.aborted) abort(); + else signal.addEventListener("abort", abort, { once: true }); + timer = setTimeout(() => reject(new SseTransportError("connect-timeout")), timeoutMs); + }); + try { + // The failure promise can only reject, never resolve; mapping preserves the result type. + return await Promise.race([ + pending, + queue.failurePromise.then(() => { + throw new SseTransportError("unexpected-eof"); + }), + stopped, + ]); + } catch (error) { + if (error instanceof TypeError) throw new SseTransportError("network"); + if (error instanceof SyntaxError) throw new SseTransportError("protocol"); + throw error; + } finally { + clearTimeout(timer); + signal.removeEventListener("abort", abort); + } +} diff --git a/packages/sdk/src/internal/providers/bailian/session-threads.ts b/packages/sdk/src/internal/providers/bailian/session-threads.ts new file mode 100644 index 0000000..7b36e8f --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/session-threads.ts @@ -0,0 +1,44 @@ +import type { EventListOptions, ProviderSessionEventList } from "../../types/session-event.ts"; +import type { SessionThreadListOptions, SessionThreadPage } from "../../types/session-thread.ts"; +import { assertEventOptions } from "../session-event-options.ts"; +import { listEventsAtPathPaged } from "../session-event-response.ts"; +import type { BailianClient } from "./client.ts"; +import { toSessionEvent } from "./event-mapper.ts"; +import { correlateBailianHistoryEvents } from "./history-event-correlation.ts"; + +export async function listBailianSessionThreads( + client: BailianClient, + sessionId: string, + options: SessionThreadListOptions = {}, +): Promise { + const query = new URLSearchParams(); + if (options.limit !== undefined) query.set("limit", String(options.limit)); + if (options.page !== undefined) query.set("page", options.page); + const path = `/sessions/${encodeURIComponent(sessionId)}/threads${query.size ? `?${query}` : ""}`; + const result = (await client.get(path, { signal: options.signal })) as { + data?: SessionThreadPage["data"]; + has_more?: boolean; + next_page?: string | null; + }; + const nextPage = result.next_page ?? undefined; + return { data: result.data ?? [], has_more: result.has_more ?? nextPage != null, next_page: nextPage }; +} + +export async function listBailianSessionThreadEvents( + client: BailianClient, + sessionId: string, + threadId: string, + options?: EventListOptions, +): Promise { + assertEventOptions("bailian", options); + const result = await listEventsAtPathPaged( + client, + `/sessions/${encodeURIComponent(sessionId)}/threads/${encodeURIComponent(threadId)}/events`, + options, + (raw) => toSessionEvent(raw, options), + { forwardTypes: false }, + ); + return options?.event_format === "snapshot" + ? { ...result, events: correlateBailianHistoryEvents(result.events) } + : result; +} diff --git a/packages/sdk/src/internal/providers/bailian/snapshot-mapper.ts b/packages/sdk/src/internal/providers/bailian/snapshot-mapper.ts new file mode 100644 index 0000000..9062883 --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/snapshot-mapper.ts @@ -0,0 +1,196 @@ +import type { SessionContentBlock, SessionEvent } from "../../types/dto.ts"; +import type { ProviderSessionEvent } from "../../types/session-event.ts"; + +export interface BailianEventMappingOptions { + event_format?: "legacy" | "snapshot"; +} + +/** Safe protocol error: never attach the provider payload to an error or message. */ +export class BailianEventProtocolError extends Error { + readonly code = "BAILIAN_EVENT_PROTOCOL_ERROR"; + constructor(message: string) { + super(message); + this.name = "BailianEventProtocolError"; + } +} + +export function isRecord(value: unknown): value is Record { + return value !== null && typeof value === "object" && !Array.isArray(value); +} + +/** Provider events are JSON values; this also keeps explicit undefined fields intact. */ +export function cloneEventValue(value: T): T { + if (Array.isArray(value)) return value.map(cloneEventValue) as T; + if (isRecord(value)) { + return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneEventValue(item)])) as T; + } + return value; +} + +export function normalizeContent(value: unknown): SessionContentBlock[] { + if (typeof value === "string") return [{ type: "text", text: value }]; + if (!Array.isArray(value)) throw new BailianEventProtocolError("Invalid Bailian message content."); + return value.map((block) => { + if (!isRecord(block)) throw new BailianEventProtocolError("Invalid Bailian content block."); + const result = cloneEventValue(block); + if (typeof result.type !== "string") { + if (typeof result.text === "string") result.type = "text"; + else if ("data" in result) result.type = "data"; + else throw new BailianEventProtocolError("Bailian content block is missing its type."); + } + if (result.text !== undefined && typeof result.text !== "string") { + throw new BailianEventProtocolError("Invalid Bailian text block."); + } + return result as SessionContentBlock; + }); +} + +const STRUCTURAL_FIELDS = new Set([ + "object", + "id", + "event_id", + "type", + "role", + "created_at", + "content", + "metadata", + "status", + "is_error", + "code", + "message", + "error", +]); +const DATA_METADATA_FIELDS = [ + "call_id", + "server_label", + "evaluated_permission", + "stop_reason", + "event_ids", + "call_ids", + "pending_batch_id", + "pending_call_ids", + "batch_id", + "thread_id", + "session_thread_id", + "from_thread_id", + "to_thread_id", +] as const; + +export function attachSnapshot(event: ProviderSessionEvent, raw: Record): ProviderSessionEvent { + if (raw.object === "content") { + throw new BailianEventProtocolError("Bailian content frames require a message accumulator."); + } + if (typeof raw.type !== "string" || raw.type.length === 0) { + throw new BailianEventProtocolError("Bailian event is missing its type."); + } + const snapshot: SessionEvent = { type: raw.type }; + const id = typeof raw.id === "string" ? raw.id : raw.event_id; + if (typeof id === "string") snapshot.event_id = event.id = id; + if (event.role !== undefined) snapshot.role = event.role; + if (typeof raw.created_at === "string") snapshot.created_at = raw.created_at; + if (raw.content !== undefined) snapshot.content = normalizeContent(raw.content); + const metadata: Record = isRecord(raw.metadata) ? cloneEventValue(raw.metadata) : {}; + for (const [key, value] of Object.entries(raw)) { + if (!STRUCTURAL_FIELDS.has(key) && value !== undefined) metadata[key] = cloneEventValue(value); + } + if (typeof raw.status === "string" && (raw.object === "message" || event.type !== "status")) { + metadata.event_status = raw.status; + } + const dataBlocks = snapshot.content?.flatMap((block) => (isRecord(block.data) ? [block.data] : [])) ?? []; + for (const data of dataBlocks) { + for (const key of DATA_METADATA_FIELDS) { + if (data[key] !== undefined && metadata[key] === undefined) metadata[key] = cloneEventValue(data[key]); + } + } + const data = dataBlocks[0]; + if (event.type === "status") { + // The message envelope's status is a lifecycle flag, never a session state. + // Only legacy non-message envelopes put the session state directly in status. + const status = + data?.session_status ?? + raw.session_status ?? + metadata.status ?? + (raw.object !== "message" ? raw.status : undefined); + delete event.status; + if (typeof status === "string") metadata.status = event.status = status; + } + if (event.type === "tool_use" || event.type === "tool_result") { + if (typeof data?.name === "string") metadata.tool_name = event.tool_name = data.name; + if (data?.arguments !== undefined) { + metadata.tool_input = cloneEventValue(data.arguments); + event.tool_input = typeof data.arguments === "string" ? data.arguments : JSON.stringify(data.arguments); + } + } + const threadId = metadata.session_thread_id ?? metadata.thread_id; + if (typeof threadId === "string") metadata.session_thread_id = event.session_thread_id = threadId; + const error = isRecord(raw.error) ? raw.error : undefined; + if (raw.error !== undefined) metadata.error = cloneEventValue(raw.error); + if (typeof raw.is_error === "boolean" || raw.is_error === null) snapshot.is_error = raw.is_error; + else if (typeof data?.is_error === "boolean") snapshot.is_error = data.is_error; + else if (event.type === "error") snapshot.is_error = true; + for (const key of ["code", "message"] as const) { + const value = raw[key] ?? error?.[key]; + if (typeof value === "string" || value === null) snapshot[key] = value; + } + if (event.type === "thinking" || event.type === "message" || event.type === "tool_result") { + event.content = contentText(snapshot.content); + } + if (event.type === "error" && typeof snapshot.message === "string") event.content = snapshot.message; + snapshot.metadata = metadata; + event.snapshot = snapshot; + deriveArtifacts(event); + return event; +} + +export function contentText(content: SessionContentBlock[] | undefined): string { + return ( + content + ?.map((block) => { + if (typeof block.text === "string") return block.text; + if (isRecord(block.data) && block.data.output !== undefined) { + return typeof block.data.output === "string" ? block.data.output : JSON.stringify(block.data.output); + } + return ""; + }) + .join("") ?? "" + ); +} + +/** Only an identified mark_artifacts result may create the SDK's derived file descriptors. */ +export function deriveArtifacts(event: ProviderSessionEvent): void { + const snapshot = event.snapshot; + if (!snapshot || event.type !== "tool_result" || event.tool_name !== "mark_artifacts" || snapshot.is_error === true) + return; + const artifacts: Record[] = []; + for (const block of snapshot.content ?? []) { + if (!isRecord(block.data)) continue; + let output: unknown = block.data.output; + if (typeof output === "string") { + try { + output = JSON.parse(output); + } catch { + continue; + } + } + if (!isRecord(output) || !Array.isArray(output.marked)) continue; + for (const item of output.marked) { + if (!isRecord(item) || typeof item.file_id !== "string" || !item.file_id.trim()) continue; + const artifact = cloneEventValue(item); + artifact.file_id = item.file_id.trim(); + if (typeof artifact.filename !== "string" && typeof item.path === "string") { + const name = item.path.split("/").pop(); + if (name) artifact.filename = name; + } + artifacts.push(artifact); + } + } + if (!artifacts.length) return; + snapshot.metadata ??= {}; + snapshot.metadata.artifacts = artifacts; + snapshot.metadata.artifact = cloneEventValue(artifacts[0]); + const first = artifacts[0]!; + event.artifact = { file_id: first.file_id as string }; + if (typeof first.filename === "string") event.artifact.filename = first.filename; + if (typeof first.content_type === "string") event.artifact.content_type = first.content_type; + if (typeof first.size === "number") event.artifact.size = first.size; +} diff --git a/packages/sdk/src/internal/providers/bailian/usage.ts b/packages/sdk/src/internal/providers/bailian/usage.ts new file mode 100644 index 0000000..fbafb74 --- /dev/null +++ b/packages/sdk/src/internal/providers/bailian/usage.ts @@ -0,0 +1,73 @@ +import { UserError } from "../../errors.ts"; +import type { + ModelUsagePage, + ModelUsageRequest, + ToolUsagePage, + ToolUsageRequest, + UsageQueryOptions, + UsageScope, +} from "../../types/usage.ts"; +import type { BailianClient } from "./client.ts"; + +// The app-control usage RPCs (`ziel:dashy::bailian-app-control.usage.*`) map to the +// AgentStudio resource paths below (confirmed with the usage contract owner). The +// public AgentStudio deployment has not enabled them yet (404 at the gateway); +// once it does, these calls go through without further changes. If the deployed +// envelope differs from the top-level body, only the unwrapping below needs to change. +const MODEL_USAGE_PATH = "/usage/models"; +const TOOL_USAGE_PATH = "/usage/tools"; + +/** + * Cross-field request rules from the usage contract, enforced before the call: + * workspace/agent scopes require an explicit time_range (session scopes reuse the + * Session's own window and must not send one), workspace scopes must list at least + * one workspace, and pagination is 1-based with a 1..100 page size. + */ +export function assertUsageRequest(request: ModelUsageRequest | ToolUsageRequest): void { + const scope: UsageScope = request.scope; + if (scope.type === "workspace" && !scope.workspace_ids?.length) { + throw new UserError("Usage scope 'workspace' requires a non-empty workspace_ids list."); + } + if (scope.type === "session") { + if (request.time_range !== undefined) { + throw new UserError("Usage scope 'session' forbids time_range; the Session's own window is used."); + } + } else if (!request.time_range) { + throw new UserError(`Usage scope '${scope.type}' requires time_range.`); + } + if (request.page_no !== undefined && (!Number.isInteger(request.page_no) || request.page_no < 1)) { + throw new UserError("page_no must be an integer >= 1."); + } + if ( + request.page_size !== undefined && + (!Number.isInteger(request.page_size) || request.page_size < 1 || request.page_size > 100) + ) { + throw new UserError("page_size must be an integer between 1 and 100."); + } +} + +/** The endpoint answers with `{ data: UsagePageDTO }`; tolerate a bare page for forward compatibility. */ +function unwrapPage(result: unknown): T { + const page = (result as { data?: T } | null)?.data; + return (page ?? (result as T)) as T; +} + +export async function listBailianModelUsage( + client: BailianClient, + request: ModelUsageRequest, + options: UsageQueryOptions = {}, +): Promise { + assertUsageRequest(request); + const result = await client.post(MODEL_USAGE_PATH, request, options.signal ? { signal: options.signal } : undefined); + return unwrapPage(result); +} + +export async function listBailianToolUsage( + client: BailianClient, + request: ToolUsageRequest, + options: UsageQueryOptions = {}, +): Promise { + assertUsageRequest(request); + const result = await client.post(TOOL_USAGE_PATH, request, options.signal ? { signal: options.signal } : undefined); + return unwrapPage(result); +} diff --git a/packages/sdk/src/internal/providers/base-client.ts b/packages/sdk/src/internal/providers/base-client.ts index 1516223..e4db297 100644 --- a/packages/sdk/src/internal/providers/base-client.ts +++ b/packages/sdk/src/internal/providers/base-client.ts @@ -1,5 +1,8 @@ import { resolveFetch } from "../transport.ts"; import type { RemoteResource } from "./interface.ts"; +import { type SseRequestOptions, streamSse } from "./sse-transport.ts"; + +export { type SseRequestOptions, SseTransportError } from "./sse-transport.ts"; export class ApiError extends Error { constructor( @@ -99,68 +102,8 @@ export abstract class BaseApiClient { return Buffer.from(await res.arrayBuffer()); } - async *sse(path: string, options?: { headers?: Record }): AsyncGenerator> { - const controller = new AbortController(); - const res = await resolveFetch()(`${this.baseUrl}${path}`, { - method: "GET", - headers: { ...this.headers(), Accept: "text/event-stream", ...options?.headers }, - signal: controller.signal, - }); - await this.throwIfError(res); - const reader = res.body!.getReader(); - const decoder = new TextDecoder(); - let buffer = ""; - - try { - while (true) { - const { done, value } = await reader.read(); - if (done) break; - buffer += decoder.decode(value, { stream: true }); - - let boundary = buffer.indexOf("\n\n"); - while (boundary !== -1) { - const frame = buffer.slice(0, boundary); - buffer = buffer.slice(boundary + 2); - boundary = buffer.indexOf("\n\n"); - - const dataLines: string[] = []; - let sseId: string | undefined; - for (const line of frame.split("\n")) { - if (line.startsWith(":")) continue; - if (line.startsWith("event:") && line.slice(6).trim() === "heartbeat") { - dataLines.length = 0; - break; - } - if (line.startsWith("data:")) { - dataLines.push(line.slice(5).trimStart()); - } - if (line.startsWith("id:")) { - sseId = line.slice(3).trimStart(); - } - } - if (dataLines.length === 0) continue; - - const json = dataLines.join("\n"); - try { - const parsed = JSON.parse(json) as Record; - if (sseId !== undefined && parsed.id === undefined) { - parsed.id = sseId; - } - yield parsed; - } catch { - // skip unparseable frames - } - } - } - } finally { - try { - await reader.cancel(); - } catch { - // The stream may already be closed or aborted. - } - controller.abort(); - reader.releaseLock(); - } + async *sse(path: string, options?: SseRequestOptions): AsyncGenerator> { + yield* streamSse(`${this.baseUrl}${path}`, this.headers(), options, (response) => this.throwIfError(response)); } async postFormData(path: string, formData: FormData): Promise { diff --git a/packages/sdk/src/internal/providers/claude/adapter.ts b/packages/sdk/src/internal/providers/claude/adapter.ts index 106d9a4..f50034e 100644 --- a/packages/sdk/src/internal/providers/claude/adapter.ts +++ b/packages/sdk/src/internal/providers/claude/adapter.ts @@ -47,6 +47,7 @@ import type { ResolvedDeploymentRefs, } from "../interface.ts"; import { ProviderMemoryApi } from "../memory-api.ts"; +import { assertEventOptions, assertStreamOptions } from "../session-event-options.ts"; import { extractCreatedEventId, listSessionEventsPaged } from "../session-event-response.ts"; import { buildSessionInfo, @@ -535,7 +536,8 @@ export class ClaudeAdapter implements ProviderAdapter { return extractCreatedEventId(res); } - async *streamSessionEvents(sessionId: string, _options?: EventStreamOptions): AsyncIterable { + async *streamSessionEvents(sessionId: string, options?: EventStreamOptions): AsyncIterable { + assertStreamOptions(this.name, options); // The managed-agents stream pushes only post-connect events and rejects a // cursor param (`after_id` → HTTP 400 "unknown field"); reconnection is done // by replaying history via listSessionEvents and de-duplicating by event id, @@ -546,6 +548,7 @@ export class ClaudeAdapter implements ProviderAdapter { } async listSessionEvents(sessionId: string, options?: EventListOptions): Promise { + assertEventOptions(this.name, options); // The managed-agents events endpoint rejects `after_id` (HTTP 400), so it is // never forwarded (mirrors bailian); shared page-cursor handling lives in // listSessionEventsPaged. diff --git a/packages/sdk/src/internal/providers/claude/mapper.ts b/packages/sdk/src/internal/providers/claude/mapper.ts index 9022f49..5d5c2a9 100644 --- a/packages/sdk/src/internal/providers/claude/mapper.ts +++ b/packages/sdk/src/internal/providers/claude/mapper.ts @@ -1,4 +1,5 @@ import { UserError } from "../../errors.ts"; +import { externalMultiagentMemberId } from "../../multiagent/model.ts"; import { reverseMultiagentDecl } from "../../multiagent/reverse-index.ts"; import type { AgentDecl, @@ -294,7 +295,7 @@ export function mapAgent( if (decl.multiagent && refs.multiagent) { body.multiagent = { type: "coordinator", - agents: refs.multiagent.members.map((member) => member.remote_id), + agents: refs.multiagent.members.map(externalMultiagentMemberId), }; } diff --git a/packages/sdk/src/internal/providers/interface.ts b/packages/sdk/src/internal/providers/interface.ts index a8cacc2..a54a46a 100644 --- a/packages/sdk/src/internal/providers/interface.ts +++ b/packages/sdk/src/internal/providers/interface.ts @@ -26,6 +26,9 @@ import type { FilePage, SessionEventInput, SessionEventSendResult, + SessionResourceListOptions, + SessionResourceMountInput, + SessionResourcePage, SessionUpdateInput, SkillDownloadInfo, SkillListOptions, @@ -54,16 +57,30 @@ import type { UpdateMemoryInput, UpdateMemoryStoreInput, } from "../types/memory.ts"; -import type { ProviderSessionInfo, SessionBindings, SessionFilter, SessionListResult } from "../types/session.ts"; +import type { + ProviderSessionInfo, + SessionBindings, + SessionFilter, + SessionListResult, + SessionResourceInfo, +} from "../types/session.ts"; import type { EventListOptions, EventStreamOptions, ProviderSessionEvent, ProviderSessionEventList, } from "../types/session-event.ts"; +import type { SessionThreadListOptions, SessionThreadPage } from "../types/session-thread.ts"; import type { SkillFile } from "../types/skill-file.ts"; import type { ProviderSkillInfo } from "../types/skill-info.ts"; import type { ResourceType } from "../types/state.ts"; +import type { + ModelUsagePage, + ModelUsageRequest, + ToolUsagePage, + ToolUsageRequest, + UsageQueryOptions, +} from "../types/usage.ts"; import type { CreateWebhookEndpointInput, UpdateWebhookEndpointInput, @@ -84,6 +101,9 @@ export interface RemoteResource { version?: number; } +/** Optional execution fact sink; observing an ID does not mean the resource is fully configured. */ +export type ResourceCreationObserver = (resource: Pick) => void; + export type ProviderResourceMode = "managed" | "forward" | "auto"; export interface ModelInfo { @@ -234,7 +254,7 @@ export interface ProviderAdapter { listAgents?(filter?: { prefix?: string; limit?: number }): Promise; /** Cursor-preserving API listing used by command surfaces. */ listAgentResources?(options?: AgentListOptions): Promise; - getRemoteAgent?(id: string, version?: number): Promise; + getRemoteAgent?(id: string, version?: number, options?: { signal?: AbortSignal }): Promise; listAgentVersions?(id: string, options?: AgentVersionListOptions): Promise; // Raw cloud environment list (full remote objects). Optional: only providers that can // enumerate their remote environments implement it. Environments are a shared base @@ -301,7 +321,12 @@ export interface ProviderAdapter { ): Promise; deleteEnvironment(id: string, cascade?: boolean, mode?: ProviderResourceMode): Promise; - createVault(name: string, decl: VaultDecl, mode?: ProviderResourceMode): Promise; + createVault( + name: string, + decl: VaultDecl, + mode?: ProviderResourceMode, + onCreated?: ResourceCreationObserver, + ): Promise; deleteVault(id: string, mode?: ProviderResourceMode): Promise; createCredential?(vaultId: string, credential: CredentialDecl): Promise; listCredentials?(vaultId: string): Promise; @@ -444,13 +469,38 @@ export interface ProviderAdapter { archiveSession?(id: string): Promise; deleteSession(id: string): Promise; + /** Mount one resource into a RUNNING session. Produces no session events. */ + mountSessionResource?(sessionId: string, input: SessionResourceMountInput): Promise; + listSessionResources?(sessionId: string, options?: SessionResourceListOptions): Promise; + getSessionResource?(sessionId: string, resourceId: string): Promise; + /** Unmount one resource and clear the provider's internal file copy. Unrecoverable. */ + unmountSessionResource?(sessionId: string, resourceId: string): Promise; + sendSessionMessage(sessionId: string, message: string): Promise; sendSessionEvents?(sessionId: string, events: SessionEventInput[]): Promise; streamSessionEvents(sessionId: string, options?: EventStreamOptions): AsyncIterable; listSessionEvents(sessionId: string, options?: EventListOptions): Promise; + listSessionThreads?(sessionId: string, options?: SessionThreadListOptions): Promise; + listSessionThreadEvents?( + sessionId: string, + threadId: string, + options?: EventListOptions, + ): Promise; listModels?(): Promise; + /** + * Aggregated model usage rows for a scope (app-control usage.listModelUsage). + * Bailian-only today; other providers reject at the runtime seam. + */ + listModelUsage?(request: ModelUsageRequest, options?: UsageQueryOptions): Promise; + + /** + * Aggregated tool usage rows for a scope (app-control usage.listToolUsage). + * Bailian-only today; other providers reject at the runtime seam. + */ + listToolUsage?(request: ToolUsageRequest, options?: UsageQueryOptions): Promise; + /** * Download all remote skills and return their extracted file content. * Used by `agents sync` to materialize skill sources locally. diff --git a/packages/sdk/src/internal/providers/qoder/adapter.ts b/packages/sdk/src/internal/providers/qoder/adapter.ts index 4532a27..fba11d3 100644 --- a/packages/sdk/src/internal/providers/qoder/adapter.ts +++ b/packages/sdk/src/internal/providers/qoder/adapter.ts @@ -62,6 +62,7 @@ import type { ResolvedTemplateRefs, } from "../interface.ts"; import { ProviderMemoryApi } from "../memory-api.ts"; +import { assertEventOptions, assertStreamOptions } from "../session-event-options.ts"; import { extractCreatedEventId, listSessionEventsPaged } from "../session-event-response.ts"; import { buildSessionInfo, @@ -1176,6 +1177,7 @@ export class QoderAdapter implements ProviderAdapter { } async *streamSessionEvents(sessionId: string, options?: EventStreamOptions): AsyncIterable { + assertStreamOptions(this.name, options); if (this.forwardSessionIds.has(sessionId)) { yield* this.streamForwardSessionEvents(sessionId, options); return; @@ -1209,6 +1211,7 @@ export class QoderAdapter implements ProviderAdapter { } async listSessionEvents(sessionId: string, options?: EventListOptions): Promise { + assertEventOptions(this.name, options); if (this.forwardSessionIds.has(sessionId)) return this.listForwardSessionEvents(sessionId, options); // Qoder additionally accepts the Agents-style `after_id` resume marker, so it is // forwarded (claude/bailian reject it); shared page-cursor handling lives in diff --git a/packages/sdk/src/internal/providers/qoder/mapper.ts b/packages/sdk/src/internal/providers/qoder/mapper.ts index 2e69e5c..afbd972 100644 --- a/packages/sdk/src/internal/providers/qoder/mapper.ts +++ b/packages/sdk/src/internal/providers/qoder/mapper.ts @@ -1,4 +1,5 @@ import { UserError } from "../../errors.ts"; +import { externalMultiagentMemberId } from "../../multiagent/model.ts"; import { reverseMultiagentDecl } from "../../multiagent/reverse-index.ts"; import type { AgentDecl, @@ -490,7 +491,7 @@ export function mapAgent( if (refs.multiagent) { body.multiagent = { type: "coordinator", - agents: refs.multiagent.members.map(({ remote_id }) => ({ type: "agent", id: remote_id })), + agents: refs.multiagent.members.map((member) => ({ type: "agent", id: externalMultiagentMemberId(member) })), }; } else if (operation === "update") { // Qoder updates are merge-style; null is the only way to clear a roster. @@ -579,7 +580,10 @@ export function mapForwardTemplate( if (refs.multiagent) { body.multiagent = { type: "coordinator", - agents: refs.multiagent.members.map(({ remote_id }) => ({ type: "agent", template_id: remote_id })), + agents: refs.multiagent.members.map((member) => ({ + type: "agent", + template_id: externalMultiagentMemberId(member), + })), }; } else if (operation === "update") { // Forward updates are merge-style; null is the only way to clear a roster. diff --git a/packages/sdk/src/internal/providers/resource-workflow.ts b/packages/sdk/src/internal/providers/resource-workflow.ts index 337ac5a..a1d2ce8 100644 --- a/packages/sdk/src/internal/providers/resource-workflow.ts +++ b/packages/sdk/src/internal/providers/resource-workflow.ts @@ -33,6 +33,7 @@ import type { ResolvedChannelRefs, ResolvedDeploymentRefs, ResolvedTemplateRefs, + ResourceCreationObserver, } from "./interface.ts"; /** @@ -62,7 +63,12 @@ export interface ResourceCrudAdapter { ): Promise; deleteEnvironment(id: string, cascade?: boolean, mode?: ProviderResourceMode): Promise; - createVault(name: string, decl: VaultDecl, mode?: ProviderResourceMode): Promise; + createVault( + name: string, + decl: VaultDecl, + mode?: ProviderResourceMode, + onCreated?: ResourceCreationObserver, + ): Promise; deleteVault(id: string, mode?: ProviderResourceMode): Promise; createSkill(name: string, decl: SkillDecl, files: SkillFile[], mode?: ProviderResourceMode): Promise; diff --git a/packages/sdk/src/internal/providers/session-event-options.ts b/packages/sdk/src/internal/providers/session-event-options.ts new file mode 100644 index 0000000..f7c5239 --- /dev/null +++ b/packages/sdk/src/internal/providers/session-event-options.ts @@ -0,0 +1,52 @@ +import { UserError } from "../errors.ts"; +import type { EventListOptions, EventStreamOptions, SessionEventFormat } from "../types/session-event.ts"; + +export function sessionEventFormat(options: EventStreamOptions | EventListOptions = {}): SessionEventFormat { + if (options.event_format !== undefined && options.event_format !== "legacy" && options.event_format !== "snapshot") { + throw new UserError("Unsupported session event format."); + } + const deltas = "event_deltas" in options ? options.event_deltas : undefined; + if ( + deltas !== undefined && + (!Array.isArray(deltas) || deltas.some((type) => type !== "message" && type !== "reasoning")) + ) { + throw new UserError("event_deltas accepts only message and reasoning."); + } + if (deltas?.length && options.event_format === "legacy") { + throw new UserError("event_deltas requires snapshot event format."); + } + return options.event_format ?? (deltas?.length ? "snapshot" : "legacy"); +} + +export function assertEventOptions(provider: string, options: EventStreamOptions | EventListOptions = {}): void { + const format = sessionEventFormat(options); + if ( + provider !== "bailian" && + (format === "snapshot" || ("event_deltas" in options && options.event_deltas !== undefined)) + ) { + throw new UserError("Structured snapshots and event_deltas are supported only by Bailian."); + } + if ("reconnect" in options && options.reconnect && format !== "snapshot") { + throw new UserError("Automatic reconnection requires Bailian snapshot event format."); + } + for (const key of ["connectTimeoutMs", "idleTimeoutMs"] as const) { + if (key in options) { + const value = (options as EventStreamOptions)[key]; + if (value !== undefined && (!Number.isFinite(value) || value <= 0)) { + throw new UserError(`${key} must be a positive finite number.`); + } + } + } +} + +export function assertStreamOptions(provider: string, options: EventStreamOptions = {}): void { + assertEventOptions(provider, options); + if ( + provider !== "bailian" && + [options.signal, options.onReady, options.reconnect, options.connectTimeoutMs, options.idleTimeoutMs].some( + (value) => value !== undefined, + ) + ) { + throw new UserError("These stream lifecycle options are supported only by Bailian."); + } +} diff --git a/packages/sdk/src/internal/providers/session-event-response.ts b/packages/sdk/src/internal/providers/session-event-response.ts index 292be0c..04d6377 100644 --- a/packages/sdk/src/internal/providers/session-event-response.ts +++ b/packages/sdk/src/internal/providers/session-event-response.ts @@ -10,11 +10,22 @@ import type { EventListOptions, ProviderSessionEvent, ProviderSessionEventList } * `has_more`. */ export async function listSessionEventsPaged( - client: { get(path: string): Promise }, + client: { get(path: string, options?: { signal?: AbortSignal }): Promise }, sessionId: string, options: EventListOptions | undefined, toEvent: (raw: Record) => ProviderSessionEvent, config?: { forwardAfterId?: boolean; forwardTypes?: boolean }, +): Promise { + return listEventsAtPathPaged(client, `/sessions/${sessionId}/events`, options, toEvent, config); +} + +/** Shared query and envelope handling for Session and child-thread event history. */ +export async function listEventsAtPathPaged( + client: { get(path: string, options?: { signal?: AbortSignal }): Promise }, + path: string, + options: EventListOptions | undefined, + toEvent: (raw: Record) => ProviderSessionEvent, + config?: { forwardAfterId?: boolean; forwardTypes?: boolean }, ): Promise { const params = new URLSearchParams(); if (options?.limit) params.set("limit", String(options.limit)); @@ -30,7 +41,11 @@ export async function listSessionEventsPaged( if (pageCursor) params.set("page", pageCursor); if (config?.forwardAfterId && options?.after_id) params.set("after_id", options.after_id); const qs = params.toString(); - const res = (await client.get(`/sessions/${sessionId}/events${qs ? `?${qs}` : ""}`)) as Record; + const url = `${path}${qs ? `?${qs}` : ""}`; + const res = (await (options?.signal ? client.get(url, { signal: options.signal }) : client.get(url))) as Record< + string, + unknown + >; const data = (res.data ?? []) as Record[]; const nextPage = (res.next_page as string | null | undefined) ?? undefined; return { diff --git a/packages/sdk/src/internal/providers/session-stream-turn.ts b/packages/sdk/src/internal/providers/session-stream-turn.ts new file mode 100644 index 0000000..419275d --- /dev/null +++ b/packages/sdk/src/internal/providers/session-stream-turn.ts @@ -0,0 +1,22 @@ +import type { EventStreamOptions } from "../types/session-event.ts"; + +// A high-level send and its provider subscription share the exact options object. +// Keep the turn boundary internal: no public options, event fields, or wire parameters. +const turnStarts = new WeakMap>(); + +export function bindSessionStreamTurn(options: EventStreamOptions): (eventId: string | undefined) => void { + let resolve!: (eventId: string | undefined) => void; + turnStarts.set( + options, + new Promise((done) => { + resolve = done; + }), + ); + // If sending fails, the owning iterator aborts the subscription. This promise + // only resolves, so a failed send cannot leave an unobserved rejection behind. + return resolve; +} + +export function sessionStreamTurn(options: EventStreamOptions): Promise | undefined { + return turnStarts.get(options); +} diff --git a/packages/sdk/src/internal/providers/sse-parser.ts b/packages/sdk/src/internal/providers/sse-parser.ts new file mode 100644 index 0000000..8928e3e --- /dev/null +++ b/packages/sdk/src/internal/providers/sse-parser.ts @@ -0,0 +1,62 @@ +/** Transport fields stay separate from the provider's JSON message identity. */ +export interface SseFrame { + data: string; + event?: string; + id?: string; +} + +/** Incremental SSE framing. Decoding bytes is the transport's responsibility. */ +export class SseParser { + private line = ""; + private skipLf = false; + private data: string[] = []; + private event: string | undefined; + private id: string | undefined; + + push(text: string): SseFrame[] { + const frames: SseFrame[] = []; + for (const char of text) { + if (this.skipLf) { + this.skipLf = false; + if (char === "\n") continue; + } + if (char === "\r" || char === "\n") { + const frame = this.consumeLine(); + if (frame) frames.push(frame); + this.skipLf = char === "\r"; + } else { + this.line += char; + } + } + return frames; + } + + private consumeLine(): SseFrame | undefined { + const line = this.line; + this.line = ""; + if (line === "") { + const frame = this.data.length ? { data: this.data.join("\n"), event: this.event, id: this.id } : undefined; + this.data = []; + this.event = undefined; + this.id = undefined; + return frame; + } + if (line.startsWith(":")) return undefined; + const colon = line.indexOf(":"); + const name = colon === -1 ? line : line.slice(0, colon); + let value = colon === -1 ? "" : line.slice(colon + 1); + if (value.startsWith(" ")) value = value.slice(1); + switch (name) { + case "data": + this.data.push(value); + break; + case "event": + this.event = value; + break; + case "id": + if (!value.includes("\0")) this.id = value; + break; + } + return undefined; + } +} diff --git a/packages/sdk/src/internal/providers/sse-transport.ts b/packages/sdk/src/internal/providers/sse-transport.ts new file mode 100644 index 0000000..588fe77 --- /dev/null +++ b/packages/sdk/src/internal/providers/sse-transport.ts @@ -0,0 +1,202 @@ +import { resolveFetch } from "../transport.ts"; +import { SseParser } from "./sse-parser.ts"; + +export interface SseRequestOptions { + headers?: Record; + signal?: AbortSignal; + /** Snapshot streams reject malformed frames and unexpected EOF. */ + strict?: boolean; + onReady?: () => void; + connectTimeoutMs?: number; + idleTimeoutMs?: number; +} + +export type SseTransportErrorCode = + | "http" + | "network" + | "unexpected-eof" + | "connect-timeout" + | "idle-timeout" + | "protocol"; + +const ERROR_MESSAGES: Record = { + http: "SSE request failed", + network: "SSE network connection failed", + "unexpected-eof": "SSE connection closed before the subscription ended", + "connect-timeout": "SSE connection timed out", + "idle-timeout": "SSE connection received no network activity before the timeout", + protocol: "SSE response contains an invalid event", +}; + +/** No URL, credentials, provider body or unsanitized cause is attached. */ +export class SseTransportError extends Error { + readonly retryable: boolean; + + constructor( + readonly code: SseTransportErrorCode, + readonly statusCode?: number, + ) { + super(`${ERROR_MESSAGES[code]}${statusCode === undefined ? "" : ` (HTTP ${statusCode})`}`); + this.name = "SseTransportError"; + this.retryable = + code === "http" + ? statusCode === 429 || (statusCode !== undefined && statusCode >= 500 && statusCode <= 599) + : code !== "protocol"; + } +} + +function abortError(): Error { + return new DOMException("SSE subscription was cancelled", "AbortError"); +} + +/** Abort races also cover custom fetch implementations that ignore AbortSignal. */ +class StreamCancellation { + readonly controller = new AbortController(); + private failure: Error | undefined; + private timer: ReturnType | undefined; + private readonly onAbort = () => this.abort(abortError()); + + constructor(private readonly signal?: AbortSignal) { + if (signal?.aborted) this.onAbort(); + else signal?.addEventListener("abort", this.onAbort, { once: true }); + } + + abort(error: Error): void { + if (this.failure) return; + this.failure = error; + this.controller.abort(); + } + + throwIfAborted(): void { + if (this.failure) throw this.failure; + } + + startTimeout(ms: number | undefined, code: "connect-timeout" | "idle-timeout"): void { + this.clearTimeout(); + if (ms !== undefined) this.timer = setTimeout(() => this.abort(new SseTransportError(code)), ms); + } + + clearTimeout(): void { + if (this.timer !== undefined) clearTimeout(this.timer); + this.timer = undefined; + } + + wait(pending: Promise): Promise { + return new Promise((resolve, reject) => { + const signal = this.controller.signal; + const onAbort = () => reject(this.failure ?? abortError()); + if (signal.aborted) { + // Still observe rejection of a pending read/fetch after cancellation. + void pending.catch(() => {}); + onAbort(); + return; + } + signal.addEventListener("abort", onAbort, { once: true }); + pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort)); + }); + } + + dispose(): void { + this.clearTimeout(); + this.signal?.removeEventListener("abort", this.onAbort); + this.controller.abort(); + } +} + +function timeout(value: number | undefined, fallback: number | undefined): number | undefined { + if (value === undefined) return fallback; + if (!Number.isFinite(value) || value <= 0) throw new RangeError("SSE timeout must be a positive finite number"); + return value; +} + +export async function* streamSse( + url: string, + headers: Record, + options: SseRequestOptions = {}, + checkLegacyResponse: (response: Response) => Promise, +): AsyncGenerator> { + const strict = options.strict === true; + // The legacy path has no new timeout unless the caller explicitly opts in. + const connectTimeout = timeout(options.connectTimeoutMs, strict ? 30_000 : undefined); + const idleTimeout = timeout(options.idleTimeoutMs, strict ? 180_000 : undefined); + const cancellation = new StreamCancellation(options.signal); + let reader: { cancel(): Promise; releaseLock(): void } | undefined; + try { + cancellation.throwIfAborted(); + cancellation.startTimeout(connectTimeout, "connect-timeout"); + let response: Response; + try { + response = await cancellation.wait( + resolveFetch()(url, { + method: "GET", + headers: { ...headers, Accept: "text/event-stream", ...options.headers }, + signal: cancellation.controller.signal, + }), + ); + } catch (error) { + cancellation.throwIfAborted(); + if (strict) throw new SseTransportError("network"); + throw error; + } + if (strict && !response.ok) throw new SseTransportError("http", response.status); + if (!strict) await cancellation.wait(checkLegacyResponse(response)); + if (!response.body) throw new SseTransportError("protocol"); + const activeReader = response.body.getReader(); + reader = activeReader; + cancellation.clearTimeout(); + cancellation.throwIfAborted(); + options.onReady?.(); + const parser = new SseParser(); + const decoder = new TextDecoder("utf-8", { fatal: strict }); + for (;;) { + cancellation.throwIfAborted(); + cancellation.startTimeout(idleTimeout, "idle-timeout"); + let chunk: Awaited>; + try { + chunk = await cancellation.wait(activeReader.read()); + } catch (error) { + cancellation.throwIfAborted(); + if (strict) throw new SseTransportError("network"); + throw error; + } finally { + cancellation.clearTimeout(); + } + if (chunk.done) { + if (strict) throw new SseTransportError("unexpected-eof"); + return; + } + let text: string; + try { + text = decoder.decode(chunk.value, { stream: true }); + } catch { + throw new SseTransportError("protocol"); + } + for (const frame of parser.push(text)) { + if (frame.event?.trim() === "heartbeat") continue; + let parsed: Record; + try { + parsed = JSON.parse(frame.data) as Record; + if (strict && (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))) { + throw new Error("Invalid event object"); + } + if (!strict && frame.id !== undefined && parsed.id === undefined) parsed.id = frame.id; + } catch { + if (strict) throw new SseTransportError("protocol"); + continue; + } + cancellation.throwIfAborted(); + yield parsed; + } + } + } finally { + cancellation.dispose(); + if (reader) { + try { + await reader.cancel(); + } catch { + // A fetch abort may already have errored the underlying stream. + } + reader.releaseLock(); + } + } +} diff --git a/packages/sdk/src/internal/resource-runtime-error.ts b/packages/sdk/src/internal/resource-runtime-error.ts new file mode 100644 index 0000000..9127d00 --- /dev/null +++ b/packages/sdk/src/internal/resource-runtime-error.ts @@ -0,0 +1,75 @@ +import { ApiError } from "./providers/base-client.ts"; +import type { ResourceErrorInfo, ResourceErrorPhase, ResourceExecutionResult } from "./types/resource-result.ts"; + +const summaries: Record = { + "resource.plan_failed": "Resource planning failed.", + "resource.prepare_failed": "Resource preparation failed.", + "resource.provider_not_configured": "Resource Provider is not configured.", + "resource.provider_failed": "Resource Provider request failed.", + "resource.state_persist_failed": "Resource state could not be persisted.", + "resource.feedback_failed": "Resource execution feedback could not be delivered.", + "resource.dependency_failed": "A required dependency failed; this action was skipped.", + "resource.execution_aborted": "Execution stopped before this action completed.", + "resource.policy_blocked": "The resource plan requires destructive confirmation.", + "resource.cancelled": "Resource execution was cancelled.", + "resource.unknown": "Resource execution failed; its result requires verification.", +}; + +/** Only structured resource operations throw this class. Legacy callers keep original exceptions. */ +export class ResourceRuntimeError extends Error { + readonly info: ResourceErrorInfo; + readonly execution?: ResourceExecutionResult; + + constructor( + message: string, + info: ResourceErrorInfo, + options: { cause?: unknown; execution?: ResourceExecutionResult } = {}, + ) { + super(message, { cause: options.cause }); + this.name = "ResourceRuntimeError"; + this.info = info; + this.execution = options.execution; + } +} + +export function resourceErrorInfo( + error: unknown, + options: { phase: ResourceErrorPhase; mutationStarted: boolean; code?: string }, +): ResourceErrorInfo { + if (error instanceof ResourceRuntimeError) + return { ...error.info, mutationStarted: options.mutationStarted || error.info.mutationStarted }; + const httpStatus = error instanceof ApiError ? error.statusCode : undefined; + const code = + options.code ?? + (httpStatus + ? "resource.provider_failed" + : options.phase === "plan" + ? "resource.plan_failed" + : options.mutationStarted + ? "resource.unknown" + : "resource.prepare_failed"); + return { + code, + phase: options.phase, + message: + summaries[code] ?? (options.phase === "plan" ? "Resource plan is invalid." : summaries["resource.unknown"]!), + retryable: httpStatus !== undefined && (httpStatus === 429 || httpStatus >= 500), + mutationStarted: options.mutationStarted, + ...(httpStatus === undefined ? {} : { httpStatus }), + }; +} + +export function resourceRuntimeError( + error: unknown, + options: Parameters[1], + execution?: ResourceExecutionResult, +): ResourceRuntimeError { + return new ResourceRuntimeError( + error instanceof Error ? error.message : String(error), + resourceErrorInfo(error, options), + { + cause: error, + execution, + }, + ); +} diff --git a/packages/sdk/src/internal/state/in-memory-state-manager.ts b/packages/sdk/src/internal/state/in-memory-state-manager.ts index 81c14dc..9338991 100644 --- a/packages/sdk/src/internal/state/in-memory-state-manager.ts +++ b/packages/sdk/src/internal/state/in-memory-state-manager.ts @@ -4,14 +4,18 @@ import type { IStateManager } from "./state-manager.ts"; /** * In-memory implementation of IStateManager. - * Does not perform any file I/O — `save()` is a no-op. + * Does not perform file I/O. Hosts may supply a persistence callback for `save()`. * Suitable for WebUI, testing, or ephemeral scenarios. */ export class InMemoryStateManager implements IStateManager { + private saves: Promise = Promise.resolve(); private state: StateFile; private index: Map; - private constructor(state: StateFile) { + private constructor( + state: StateFile, + private readonly onSave?: (snapshot: StateFile) => void | Promise, + ) { this.state = state; this.index = this.buildIndex(); } @@ -24,12 +28,17 @@ export class InMemoryStateManager implements IStateManager { return idx; } - static fromJSON(data: StateFile): InMemoryStateManager { - return new InMemoryStateManager(structuredClone(data)); + static fromJSON(data: StateFile, onSave?: (snapshot: StateFile) => void | Promise): InMemoryStateManager { + return new InMemoryStateManager(structuredClone(data), onSave); } - static empty(): InMemoryStateManager { - return new InMemoryStateManager({ resources: [] }); + static empty(onSave?: (snapshot: StateFile) => void | Promise): InMemoryStateManager { + return new InMemoryStateManager({ resources: [] }, onSave); + } + + /** Detached snapshot suitable for host storage; preserves the SDK state format. */ + toJSON(): StateFile { + return structuredClone(this.state); } getResource(address: ResourceAddress): ResourceState | undefined { @@ -78,6 +87,11 @@ export class InMemoryStateManager implements IStateManager { } async save(): Promise { - // no-op: in-memory state does not persist + if (!this.onSave) return; + const snapshot = this.toJSON(); + const saved = this.saves.then(() => this.onSave!(snapshot)); + // A failed checkpoint is reported to its caller without poisoning later saves. + this.saves = saved.catch(() => {}); + await saved; } } diff --git a/packages/sdk/src/internal/types/config.ts b/packages/sdk/src/internal/types/config.ts index 2966dfd..5a9b910 100644 --- a/packages/sdk/src/internal/types/config.ts +++ b/packages/sdk/src/internal/types/config.ts @@ -279,8 +279,8 @@ export interface MultiagentDecl { agents: MultiagentMemberDecl[]; } -/** A project-owned logical Agent name, or an externally owned Managed Agent id. */ -export type MultiagentMemberDecl = string | { agent_id: string }; +/** A project logical name, an external Managed Agent id, or Bailian's native Self member. */ +export type MultiagentMemberDecl = string | { agent_id: string } | { type: "self" }; // --- Deployment --- diff --git a/packages/sdk/src/internal/types/managed-api.ts b/packages/sdk/src/internal/types/managed-api.ts index e67e40d..2f8d39b 100644 --- a/packages/sdk/src/internal/types/managed-api.ts +++ b/packages/sdk/src/internal/types/managed-api.ts @@ -1,6 +1,7 @@ import type { CredentialInjectionLocation, CredentialNetworking } from "./config.ts"; import type { CloudAgent, CloudEnvironment, CloudVault } from "./dto.ts"; import type { ProviderFileInfo } from "./file.ts"; +import type { SessionResourceInfo } from "./session.ts"; import type { ProviderSkillInfo } from "./skill-info.ts"; export interface CursorPage { @@ -87,6 +88,18 @@ export interface SessionUpdateInput { metadata?: Record; } +/** One resource to mount into a RUNNING session (provider session-resources API). */ +export interface SessionResourceMountInput { + type: "file"; + file_id: string; + /** Sandbox path inside the session, e.g. `/mnt/session/uploads/report.csv`. */ + mount_path: string; +} + +export type SessionResourceListOptions = CursorListOptions; + +export type SessionResourcePage = CursorPage; + /** Raw AgentStudio message/event input. Provider adapters preserve the wire shape. */ export type SessionEventInput = Record; diff --git a/packages/sdk/src/internal/types/resource-result.ts b/packages/sdk/src/internal/types/resource-result.ts new file mode 100644 index 0000000..bc7d1ad --- /dev/null +++ b/packages/sdk/src/internal/types/resource-result.ts @@ -0,0 +1,34 @@ +import type { PlannedAction } from "./plan.ts"; + +/** Detailed contracts are opt-in; the default public result retains its legacy shape. */ +export type ResourceResultDetail = "legacy" | "structured"; +export type ResourceExecutionOutcome = "succeeded" | "failed" | "partial" | "unknown"; +export type ResourceErrorPhase = "plan" | "prepare" | "execute" | "persist_state"; + +export interface ResourceErrorInfo { + code: string; + phase: ResourceErrorPhase; + /** Safe summary, never a raw Provider response or request. */ + message: string; + /** Transient failure hint, not permission to replay a mutation. */ + retryable: boolean; + /** False only when no mutating Provider method has been invoked. */ + mutationStarted: boolean; + httpStatus?: number; +} + +export interface ResourceActionResult { + action: PlannedAction; + status: "success" | "failed" | "skipped"; + error?: string; + errorInfo?: ResourceErrorInfo; + resource?: { remoteId: string; version?: number }; +} + +export interface ResourceExecutionResult { + results: ResourceActionResult[]; + /** Legacy meaning: at least one action failed. */ + partial: boolean; + outcome?: ResourceExecutionOutcome; + mutationStarted?: boolean; +} diff --git a/packages/sdk/src/internal/types/session-event.ts b/packages/sdk/src/internal/types/session-event.ts index 9b94dc4..0c8fa69 100644 --- a/packages/sdk/src/internal/types/session-event.ts +++ b/packages/sdk/src/internal/types/session-event.ts @@ -1,6 +1,8 @@ -import type { SessionEventType } from "./dto.ts"; +import type { SessionEvent, SessionEventType } from "./dto.ts"; export interface ProviderSessionEvent { + /** Opt-in cumulative contract snapshot. raw remains the actual triggering provider frame. */ + snapshot?: SessionEvent; type: SessionEventType; raw_type: string; /** Stable per-event id when the provider supplies one; used to de-dupe history replay vs. live stream. */ @@ -11,7 +13,7 @@ export interface ProviderSessionEvent { tool_input?: string; status?: string; stop_reason?: string; - /** Child-agent thread id when a Managed Agents multi-agent event carries one. */ + /** Provider thread reference; snapshot metadata.thread_id retains actual event ownership. */ session_thread_id?: string; /** * A file the agent delivered to the provider's Files API (qoder DeliverArtifacts / @@ -23,7 +25,12 @@ export interface ProviderSessionEvent { raw: Record; } +export type SessionEventFormat = "legacy" | "snapshot"; + export interface EventListOptions { + /** Bailian structured event conversion; defaults to legacy. */ + event_format?: SessionEventFormat; + signal?: AbortSignal; limit?: number; after_id?: string; // Opaque forward cursor echoed verbatim from a prior response's `next_page`. @@ -40,6 +47,18 @@ export interface EventListOptions { export interface EventStreamOptions { after_id?: string; + /** Bailian only. Nonempty event_deltas selects snapshot unless explicitly conflicting. */ + event_format?: SessionEventFormat; + event_deltas?: ("message" | "reasoning")[]; + signal?: AbortSignal; + /** Called once per successful connection, before the first business event. */ + onReady?: () => void; + /** Bailian snapshot mode only; defaults to false. Never resends a user message. */ + reconnect?: boolean; + /** Snapshot mode default: 30 seconds. */ + connectTimeoutMs?: number; + /** Snapshot mode default: 180 seconds; comments and heartbeats count as activity. */ + idleTimeoutMs?: number; } export interface ProviderSessionEventList { diff --git a/packages/sdk/src/internal/types/session-thread.ts b/packages/sdk/src/internal/types/session-thread.ts new file mode 100644 index 0000000..8c84976 --- /dev/null +++ b/packages/sdk/src/internal/types/session-thread.ts @@ -0,0 +1,22 @@ +import type { CursorListOptions, CursorPage } from "./managed-api.ts"; + +/** A child Agent execution within a Session; the main thread is not a resource in this list. */ +export interface SessionThread { + id: string; + type: "session_thread"; + session_id: string; + parent_thread_id: string; + agent: { id: string; version?: number; name?: string }; + /** Provider status, currently running, idle, or terminated. Unknown future values are preserved. */ + status: string; + created_at: string; + updated_at: string; + archived_at?: string | null; + agent_name?: string; +} + +export interface SessionThreadListOptions extends CursorListOptions { + signal?: AbortSignal; +} + +export type SessionThreadPage = CursorPage; diff --git a/packages/sdk/src/internal/types/session.ts b/packages/sdk/src/internal/types/session.ts index c01a687..9d28bf1 100644 --- a/packages/sdk/src/internal/types/session.ts +++ b/packages/sdk/src/internal/types/session.ts @@ -24,6 +24,8 @@ export type SessionResource = SessionGithubRepositoryResource | SessionMemorySto /** Provider response resource, including server-assigned sandbox mount paths. */ export interface SessionResourceInfo extends Record { + /** Provider-assigned resource id (`sesrsc_…`); required to unmount a runtime-mounted resource. */ + id?: string; type: string; mount_path?: string; memory_store_id?: string; diff --git a/packages/sdk/src/internal/types/usage.ts b/packages/sdk/src/internal/types/usage.ts new file mode 100644 index 0000000..58ef3b1 --- /dev/null +++ b/packages/sdk/src/internal/types/usage.ts @@ -0,0 +1,98 @@ +/** + * Usage-query scope, discriminated by `type` (app-control usage.* endpoints): + * - `workspace`: aggregated over the listed workspaces (overview page); `agent_id` narrows to one Agent. + * - `agent`: one Agent (optionally a pinned version); `workspace_ids` may pin a single workspace, + * otherwise the caller's identity workspace is used. + * - `session`: one Session; the Session's own window is used, so `time_range` is forbidden and + * `workspace_ids` (if sent) is ignored. + */ +export type UsageScope = + | { type: "workspace"; workspace_ids: string[]; agent_id?: string } + | { type: "agent"; agent_id: string; workspace_ids?: string[]; agent_version?: string } + | { type: "session"; session_id: string }; + +/** Millisecond-precision epoch window. Required for workspace/agent scopes; forbidden for session. */ +export interface UsageTimeRange { + start_time: number; + end_time: number; +} + +export type ModelUsageSortBy = "call_count" | "failed_count" | "input_tokens" | "output_tokens"; +export type ToolUsageSortBy = "call_count" | "failed_count"; +export type UsageSortOrder = "asc" | "desc"; + +export interface ModelUsageRequest { + scope: UsageScope; + time_range?: UsageTimeRange; + /** Exact model name; omitted/null means all models. */ + model_name?: string | null; + /** 1-based page number. */ + page_no?: number; + /** Page size, clamped to 1..100 by the endpoint. */ + page_size?: number; + sort_by?: ModelUsageSortBy; + sort_order?: UsageSortOrder; +} + +export type UsageToolSource = "builtin" | "mcp" | "custom"; + +export interface ToolUsageRequest { + scope: UsageScope; + time_range?: UsageTimeRange; + /** Exact tool source; omitted/null means all sources. Unknown provider values are preserved. */ + source?: UsageToolSource | null; + /** Exact tool name; omitted/null means all tools. */ + tool_name?: string | null; + page_no?: number; + page_size?: number; + /** Tool usage does not support token sorts — only call_count / failed_count. */ + sort_by?: ToolUsageSortBy; + sort_order?: UsageSortOrder; +} + +export interface UsageTokenStats { + input_tokens: number; + output_tokens: number; + cache_read_tokens: number; + cache_creation_tokens: number; + total_tokens: number; + cache_hit_ratio: number; +} + +/** One aggregated row. The paging key is workspace_id + model_name: the same model in different workspaces is not merged. */ +export interface ModelUsageItem { + workspace_id: string; + model_name: string; + call_count: number; + failed_count: number; + tokens: UsageTokenStats; +} + +/** One aggregated row. The paging key is workspace_id + source + tool_name: same-name tools from different sources are separate rows. */ +export interface ToolUsageItem { + workspace_id: string; + tool_name: string; + /** builtin | mcp | custom; unknown future values are preserved verbatim. */ + source: string; + call_count: number; + failed_count: number; +} + +/** Header totals come from the aggregates: token columns sum `items[].tokens`, the call total is `total_call_count`. */ +export interface UsagePage { + items: TItem[]; + /** Total rows across all pages (the paging count). */ + total: number; + /** Total calls across all pages (the headline "N calls" figure). */ + total_call_count: number; + page_no: number; + page_size: number; + data_updated_at: number; +} + +export type ModelUsagePage = UsagePage; +export type ToolUsagePage = UsagePage; + +export interface UsageQueryOptions { + signal?: AbortSignal; +} diff --git a/packages/sdk/src/internal/utils/tool-permissions.ts b/packages/sdk/src/internal/utils/tool-permissions.ts index f064931..ba48a3c 100644 --- a/packages/sdk/src/internal/utils/tool-permissions.ts +++ b/packages/sdk/src/internal/utils/tool-permissions.ts @@ -48,6 +48,18 @@ export function toPermissionPolicy(permission: ToolPermission): { type: "always_ return { type: permission === "ask" ? "always_ask" : "always_allow" }; } +export function permissionFromWire(rawPolicy: unknown): ToolPermission | undefined { + const type = + typeof rawPolicy === "string" + ? rawPolicy + : rawPolicy && typeof rawPolicy === "object" + ? (rawPolicy as { type?: unknown }).type + : undefined; + if (type === "always_ask") return "ask"; + if (type === "always_allow") return "allow"; + return undefined; +} + /** Preserve remote permission policies when syncing provider tool configs back to YAML. */ export function permissionOverridesFromWire( configs: Array<{ name: string; enabled?: boolean; permission_policy?: unknown }>, @@ -56,15 +68,8 @@ export function permissionOverridesFromWire( const permissions: Record = {}; for (const config of configs) { if (config.enabled === false) continue; - const rawPolicy = config.permission_policy; - const type = - typeof rawPolicy === "string" - ? rawPolicy - : rawPolicy && typeof rawPolicy === "object" - ? (rawPolicy as { type?: unknown }).type - : undefined; - if (type === "always_ask") permissions[toConfigName(config.name)] = "ask"; - else if (type === "always_allow") permissions[toConfigName(config.name)] = "allow"; + const permission = permissionFromWire(config.permission_policy); + if (permission) permissions[toConfigName(config.name)] = permission; } return Object.keys(permissions).length ? permissions : undefined; } diff --git a/packages/sdk/src/internal/validation/bailian.ts b/packages/sdk/src/internal/validation/bailian.ts index acc51de..cb8c0d6 100644 --- a/packages/sdk/src/internal/validation/bailian.ts +++ b/packages/sdk/src/internal/validation/bailian.ts @@ -1,4 +1,34 @@ +import type { DiagnosticCollector } from "../diagnostics/diagnostics.ts"; import type { ProjectConfig } from "../types/config.ts"; +import { resolveBuiltinTools } from "../utils/tool-permissions.ts"; + +/** Bailian enforces approvals only on the main Agent, including when Self is delegated. */ +export function collectBailianSubagentToolPermissionDiagnostics( + config: ProjectConfig, + providerName: string, + diagnostics: DiagnosticCollector, +): void { + if (providerName !== "bailian") return; + for (const [name, coordinator] of Object.entries(config.agents ?? {})) { + if (coordinator.provider && coordinator.provider !== providerName) continue; + for (const member of coordinator.multiagent?.agents ?? []) { + // External ids carry no local tool declaration; never infer their policies. + if (typeof member !== "string" && !("type" in member)) continue; + const memberName = typeof member === "string" ? member : name; + const agent = config.agents?.[memberName]; + if (!agent?.tools || (agent.provider && agent.provider !== providerName)) continue; + const approvalTools = resolveBuiltinTools(agent.tools) + .filter((tool) => tool.permission === "ask") + .map((tool) => tool.configuredName); + if (!approvalTools.length) continue; + diagnostics.error( + "bailian.agent.multiagent.tool_permissions.unsupported", + `agent.${name}: member '${memberName}'${typeof member === "string" ? "" : " (Self)"} requires approval for ${approvalTools.join(", ")}, but Bailian supports tool approval only on the main Agent. Run this member as a main Agent or remove its effective 'ask' policies before delegating. / 百炼子 Agent 不支持工具审批,请独立运行该成员或移除其有效 ask 策略。`, + { type: "agent", name, provider: providerName }, + ); + } + } +} export interface MissingBailianMcpToolConfig { agentName: string; diff --git a/packages/sdk/src/redaction.ts b/packages/sdk/src/redaction.ts index 6c83611..c405708 100644 --- a/packages/sdk/src/redaction.ts +++ b/packages/sdk/src/redaction.ts @@ -56,25 +56,52 @@ const DOWNLOAD_EXTENSIONS = new Set([ "html", ]); -/** Markdown image/link destinations: `![alt](url)` or `[label](url)`. */ -const MARKDOWN_LINK_RE = /!?\[[^\]]*\]\((https?:\/\/[^)\s]+)\)/g; +const MEDIA_URL_PLACEHOLDER_RE = /__AGENTS_PRESERVED_MEDIA_URL_(0|[1-9][0-9]*)__/g; export function redactSensitiveText(value: string): string { const preservedUrls: string[] = []; - const withPlaceholders = value.replace(MARKDOWN_LINK_RE, (match, url: string) => { - if (!shouldPreserveMarkdownMediaUrl(url, match.startsWith("!"))) { - return match; + const withPlaceholders = preserveMarkdownMediaUrls(value, preservedUrls); + + return redactKeyValuePairs(redactUrls(withPlaceholders)).replace( + MEDIA_URL_PLACEHOLDER_RE, + (match, index: string) => preservedUrls[Number(index)] ?? match, + ); +} + +/** Preserve Markdown destinations with monotonic scans, including on malformed input. */ +function preserveMarkdownMediaUrls(value: string, preservedUrls: string[]): string { + const parts: string[] = []; + let scanFrom = 0; + let copyFrom = 0; + let urlEnd = -1; + while (scanFrom < value.length) { + const labelStart = value.indexOf("[", scanFrom); + if (labelStart === -1) break; + const labelEnd = value.indexOf("]", labelStart + 1); + if (labelEnd === -1) break; + // Every nested opening bracket before this closing bracket shares its destination. + scanFrom = labelEnd + 1; + if (value[scanFrom] !== "(") continue; + const urlStart = scanFrom + 1; + const schemeLength = value.startsWith("https://", urlStart) ? 8 : value.startsWith("http://", urlStart) ? 7 : 0; + if (!schemeLength) continue; + const contentStart = urlStart + schemeLength; + // Reuse the scanned suffix when another candidate begins inside an unclosed URL. + // Otherwise repeated `[](http://` would repeatedly scan the entire remaining input. + if (urlEnd < contentStart) { + urlEnd = contentStart; + while (urlEnd < value.length && value[urlEnd] !== ")" && !/\s/.test(value[urlEnd]!)) urlEnd++; } - const index = preservedUrls.length; + if (urlEnd === contentStart || value[urlEnd] !== ")") continue; + scanFrom = urlEnd + 1; + const url = value.slice(urlStart, urlEnd); + if (!shouldPreserveMarkdownMediaUrl(url, labelStart > 0 && value[labelStart - 1] === "!")) continue; + parts.push(value.slice(copyFrom, urlStart), mediaUrlPlaceholder(preservedUrls.length)); preservedUrls.push(url); - return match.replace(url, mediaUrlPlaceholder(index)); - }); - - let result = redactKeyValuePairs(redactUrls(withPlaceholders)); - for (let i = 0; i < preservedUrls.length; i++) { - result = result.replaceAll(mediaUrlPlaceholder(i), preservedUrls[i]!); + copyFrom = urlEnd; } - return result; + parts.push(value.slice(copyFrom)); + return parts.join(""); } function mediaUrlPlaceholder(index: number): string { diff --git a/packages/sdk/src/session-events.ts b/packages/sdk/src/session-events.ts index 7c77673..d43ef9d 100644 --- a/packages/sdk/src/session-events.ts +++ b/packages/sdk/src/session-events.ts @@ -1,7 +1,15 @@ // Pure, browser-safe subpath barrel for the shared session-event mapping pipeline. -// Re-exports only type-only-importing modules so browser consumers can compose the +// Re-exports only browser-safe pure modules so browser consumers can compose the // same raw→ProviderSessionEvent→contract-SessionEvent pipeline that the server uses, // WITHOUT pulling in the Node-only main SDK bundle. +export type { SessionEventSanitizerOptions } from "./internal/core/session-event-sanitizer.ts"; export { sanitizeSessionEvent, sanitizeSessionEvents } from "./internal/core/session-event-sanitizer.ts"; export { toSessionEvent as toBailianSessionEvent } from "./internal/providers/bailian/event-mapper.ts"; +export { + type BailianSessionEventNormalizer, + type BailianSessionEventNormalizerOptions, + createBailianSessionEventNormalizer, +} from "./internal/providers/bailian/event-normalizer.ts"; +export type { SessionEvent } from "./internal/types/dto.ts"; +export type { SessionThread, SessionThreadListOptions, SessionThreadPage } from "./internal/types/session-thread.ts"; diff --git a/packages/sdk/tests/e2e/README.md b/packages/sdk/tests/e2e/README.md new file mode 100644 index 0000000..840069d --- /dev/null +++ b/packages/sdk/tests/e2e/README.md @@ -0,0 +1,41 @@ +# 真实 Cloud 探针 + +`session-threads-live.ts` 只使用 SDK 公开入口验证百炼子 Agent 线程查询,不在普通 `bun test` +中执行。先把凭据通过进程环境注入;脚本不会读取或打印 `.env`,不会输出 Provider 错误正文、 +消息正文或凭据。Bun 本身默认加载 `.env`,需要禁止时使用 `bun --no-env-file`。 + +## Session Threads + +先生成计划,不改变远端: + +```sh +bun --no-env-file packages/sdk/tests/e2e/session-threads-live.ts +``` + +计划包含唯一 `kit-e2e-*` 前缀的 worker、coordinator 和 Environment。设置 +`KIT_THREAD_ENVIRONMENT_ID` 后复用指定的现有 Environment,只创建两个临时 Agent, +不会修改或清理这个既有 Environment。默认模型 `qwen3.7-max`,可用 `KIT_THREAD_MODEL` +覆盖。所有新资源和 Session 都带 `{ kit: "live-validation", probe: "session-threads", prefix }`。 + +审阅计划后,显式执行: + +```sh +KIT_LIVE=1 bun --no-env-file packages/sdk/tests/e2e/session-threads-live.ts --execute +``` + +需要 `BAILIAN_API_KEY` 或 `DASHSCOPE_API_KEY`,以及 `BAILIAN_BASE_URL` 或 +`BAILIAN_WORKSPACE_ID`。如果需要让审阅与执行使用同一组资源名,两个命令都设置同一个 +唯一 `KIT_THREAD_PREFIX=kit-e2e--`。脚本校验计划只包含预期数量的 +`create` 动作,并以 `policy: "block"` 拒绝破坏性变更。 + +执行流程为创建资源 → 创建 Session → 要求 coordinator 委派算术任务 → 等待主会话和 +子线程结束 → `listSessionThreads(limit: 1)` → 逐线程 +`listSessionThreadEvents(limit: 1, event_format: "snapshot")`。断言包括子线程身份、 +主父线程关联、子线程归属、稳定事件 ID、游标续页不重复和实际子 Agent 消息;事件分页必须 +跨越至少两页。只产生一个子线程时,线程列表验证末页合同,事件查询负责验证真实续页。 + +`finally` 中先停止仍在运行的 Session 并删除,再输出本次资源的清理计划,按 coordinator、 +worker、Environment 顺序调用 SDK 的清理流程。百炼 Agent 清理按 Provider 协议归档。 +若 Environment 因引用关系拒删,SDK 当前没有公开归档入口;脚本报告残留 ID 和临时 state +路径、退出非零,调用方需按正式协议归档并记录结果。任何清理失败都保留 state 供恢复, +成功后删除临时目录。脚本不扫描、不删除其他测试或用户资源。 diff --git a/packages/sdk/tests/e2e/session-threads-live.ts b/packages/sdk/tests/e2e/session-threads-live.ts new file mode 100644 index 0000000..ce45fdd --- /dev/null +++ b/packages/sdk/tests/e2e/session-threads-live.ts @@ -0,0 +1,320 @@ +// Default: print the concrete create-only plan without changing Cloud resources. +// Execute only after reviewing that plan: KIT_LIVE=1 bun .../session-threads-live.ts --execute +// Credentials must already be in the process environment; this script never loads or prints an .env file. +import { randomUUID } from "node:crypto"; +import { mkdtempSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { + ApiError, + createProjectRuntime, + createSessionForAgent, + deleteSession, + destroyPlannedProjectResources, + executePlannedProject, + getSession, + listSessionThreadEvents, + listSessionThreads, + type ProjectRuntimeContext, + planDestroyProjectContext, + planProjectContext, + resolveProjectConfigFromObject, + type SessionThread, + StateManager, + sendRemoteSessionEvents, +} from "../../src/index.ts"; +import { sanitizeSessionEvents } from "../../src/session-events.ts"; + +const execute = process.argv.includes("--execute"); +const prefix = process.env.KIT_THREAD_PREFIX ?? `kit-e2e-${Date.now()}-${randomUUID().slice(0, 8)}`; +const model = process.env.KIT_THREAD_MODEL ?? "qwen3.7-max"; +const environmentId = process.env.KIT_THREAD_ENVIRONMENT_ID; +const metadata = { kit: "live-validation", probe: "session-threads", prefix }; +const workerName = `${prefix}-worker`; +const coordinatorName = `${prefix}-coordinator`; +const environmentName = `${prefix}-environment`; + +class ProbeFailure extends Error {} + +function assert(value: unknown, message: string): asserts value { + if (!value) throw new ProbeFailure(message); +} + +function safeError(error: unknown): Record { + // Provider error bodies can echo credentials. Report only bounded classification. + if (error instanceof ProbeFailure) return { kind: "assertion", message: error.message }; + return error instanceof ApiError + ? { kind: "provider_error", status: error.statusCode } + : { kind: error instanceof Error ? error.name : "unknown_error" }; +} + +async function threadPages(ctx: ProjectRuntimeContext, sessionId: string): Promise { + const threads: SessionThread[] = []; + const cursors = new Set(); + let page: string | undefined; + do { + const result = await listSessionThreads(ctx, sessionId, { limit: 1, page, signal: AbortSignal.timeout(30_000) }); + threads.push(...result.data); + if (!result.has_more) break; + assert(result.next_page && !cursors.has(result.next_page), "Thread pagination returned an invalid cursor"); + cursors.add(result.next_page); + page = result.next_page; + assert(cursors.size <= 20, "Thread pagination exceeded the probe bound"); + } while (page); + assert(new Set(threads.map((thread) => thread.id)).size === threads.length, "Thread pagination duplicated an ID"); + return threads; +} + +async function verifyThreadHistory( + ctx: ProjectRuntimeContext, + sessionId: string, + thread: SessionThread, +): Promise { + const ids = new Set(); + const cursors = new Set(); + let page: string | undefined; + let sawMessage = false; + let pages = 0; + do { + const result = await listSessionThreadEvents(ctx, sessionId, thread.id, { + event_format: "snapshot", + order: "asc", + limit: 1, + page_token: page, + signal: AbortSignal.timeout(30_000), + }); + pages += 1; + for (const event of sanitizeSessionEvents(result.events, { redact: false, truncate: false })) { + assert(event.event_id && !ids.has(event.event_id), "Thread event pagination lost or duplicated an ID"); + ids.add(event.event_id); + assert( + !event.metadata?.thread_id || event.metadata.thread_id === thread.id, + "Thread history leaked another owner", + ); + if (event.type === "message" && event.role === "assistant" && event.content?.length) sawMessage = true; + } + if (!result.has_more) break; + assert(result.next_page && !cursors.has(result.next_page), "Thread event pagination returned an invalid cursor"); + cursors.add(result.next_page); + page = result.next_page; + assert(pages <= 200, "Thread event pagination exceeded the probe bound"); + } while (page); + assert(pages > 1, "The thread did not exercise event cursor continuation"); + assert(sawMessage, "The child Agent produced no assistant message in thread history"); + console.log(JSON.stringify({ stage: "thread_history", threadId: thread.id, pages, events: ids.size })); +} + +async function cleanup(ctx: ProjectRuntimeContext, sessionId?: string): Promise { + let complete = true; + if (sessionId) { + try { + const current = await getSession(ctx, sessionId); + if (current.status === "running") { + await sendRemoteSessionEvents(ctx, sessionId, [{ role: "user", type: "interrupt" }]); + const deadline = Date.now() + 30_000; + while (Date.now() < deadline && (await getSession(ctx, sessionId)).status === "running") await Bun.sleep(1000); + } + await deleteSession(ctx, sessionId); + console.log(JSON.stringify({ stage: "cleanup_session", sessionId, status: "deleted" })); + } catch (error) { + complete = false; + console.log(JSON.stringify({ stage: "cleanup_session", sessionId, ...safeError(error) })); + } + } + const planned = planDestroyProjectContext(ctx); + const order = (name: string) => (name === coordinatorName ? 0 : name === workerName ? 1 : 2); + planned.resources.sort((left, right) => order(left.address.name) - order(right.address.name)); + assert( + planned.resources.every((resource) => resource.address.name.startsWith(`${prefix}-`)), + "Cleanup scope escaped probe resources", + ); + console.log( + JSON.stringify({ + stage: "cleanup_plan", + resources: planned.resources.map(({ address, remote_id }) => ({ address, id: remote_id })), + }), + ); + const result = await destroyPlannedProjectResources(planned); + for (const item of result.results) { + console.log( + JSON.stringify({ + stage: "cleanup_resource", + type: item.resource.address.type, + id: item.resource.remote_id, + status: item.status, + }), + ); + } + return complete && !result.partial; +} + +async function main(): Promise { + assert( + /^kit-e2e-[a-zA-Z0-9-]+$/.test(prefix), + "KIT_THREAD_PREFIX must start with kit-e2e- and use safe resource-name characters", + ); + const apiKey = process.env.BAILIAN_API_KEY ?? process.env.DASHSCOPE_API_KEY; + const baseUrl = process.env.BAILIAN_BASE_URL; + const workspaceId = process.env.BAILIAN_WORKSPACE_ID; + if (execute) { + assert(process.env.KIT_LIVE === "1", "Explicit KIT_LIVE=1 is required for execution"); + assert(apiKey && (baseUrl || workspaceId), "Bailian credentials and base URL or workspace ID are required"); + } + const directory = mkdtempSync(join(tmpdir(), `${prefix}-`)); + const statePath = join(directory, "state.json"); + const loaded = await resolveProjectConfigFromObject( + { + version: "1", + providers: { + bailian: { + api_key: apiKey ?? "plan-only", + ...(baseUrl + ? { base_url: baseUrl } + : workspaceId + ? { workspace_id: workspaceId } + : { base_url: "https://bailian.test/api/v1/agentstudio" }), + }, + }, + defaults: { provider: "bailian" }, + ...(environmentId ? {} : { environments: { [environmentName]: { config: { type: "cloud" }, metadata } } }), + agents: { + [workerName]: { + model, + instructions: + "You are a validation worker. Answer arithmetic questions with just the result. Do not use tools.", + metadata, + }, + [coordinatorName]: { + model, + instructions: + "Delegate the user's arithmetic question to your worker Agent in a new child thread. Wait for the worker and return its result. Do not solve it yourself.", + ...(environmentId ? {} : { environment: environmentName }), + multiagent: { type: "coordinator", agents: [workerName] }, + metadata, + }, + }, + }, + { projectName: prefix, basePath: directory }, + ); + const ctx = createProjectRuntime({ ...loaded, state: StateManager.initialize(statePath) }); + let sessionId: string | undefined; + let created = false; + let cleaned = false; + try { + const planned = await planProjectContext(ctx, { + provider: "bailian", + refresh: false, + mode: "create-only", + scope: { + roots: [ + { type: "agent", name: coordinatorName, provider: "bailian" }, + { type: "agent", name: workerName, provider: "bailian" }, + ...(environmentId ? [] : [{ type: "environment" as const, name: environmentName, provider: "bailian" }]), + ], + includeDependencies: true, + }, + }); + console.log( + JSON.stringify({ + stage: "diagnostics", + items: planned.plan.diagnostics.map(({ code, severity, resource }) => ({ code, severity, resource })), + }), + ); + assert( + planned.plan.diagnostics.every((diagnostic) => diagnostic.severity !== "error"), + "The probe plan has validation errors", + ); + assert( + planned.plan.actions.length === (environmentId ? 2 : 3), + "The probe plan does not contain the expected resource count", + ); + assert( + planned.plan.actions.every( + (action) => action.action === "create" && action.address.name.startsWith(`${prefix}-`), + ), + "The probe plan contains an unexpected action", + ); + console.log( + JSON.stringify({ + stage: "plan", + prefix, + model, + reuseEnvironment: Boolean(environmentId), + actions: planned.plan.actions.map(({ action, address }) => ({ action, address })), + }), + ); + if (!execute) return; + created = true; + const applied = await executePlannedProject(planned, { policy: "block", concurrency: 1 }); + assert( + !applied.partial && applied.results.every((result) => result.status === "success"), + "Creating probe resources failed", + ); + const createdSession = await createSessionForAgent(ctx, { + agent: coordinatorName, + environmentId, + title: `${prefix}-session`, + metadata, + }); + sessionId = createdSession.session.id; + console.log(JSON.stringify({ stage: "created", sessionId, prefix })); + await sendRemoteSessionEvents(ctx, sessionId, [ + { + role: "user", + type: "message", + content: [ + { + type: "text", + text: "Delegate 17 + 25 to your worker Agent in a new child thread. Wait for its reply and report the answer.", + }, + ], + }, + ]); + const deadline = Date.now() + 180_000; + let threads: SessionThread[] = []; + while (Date.now() < deadline) { + threads = await threadPages(ctx, sessionId); + const current = await getSession(ctx, sessionId); + if (threads.length && current.status === "idle" && threads.every((thread) => thread.status !== "running")) break; + await Bun.sleep(3000); + } + assert(threads.length, "Coordinator created no child Agent thread within the probe deadline"); + assert( + (await getSession(ctx, sessionId)).status === "idle", + "Coordinator did not finish within the probe deadline", + ); + assert( + threads.every( + (thread) => thread.id.startsWith("sthr_") && thread.session_id === sessionId && thread.parent_thread_id, + ), + "Thread list lost child identity or parent/session linkage", + ); + console.log( + JSON.stringify({ + stage: "threads", + count: threads.length, + summaries: threads.map(({ id, parent_thread_id, agent, status }) => ({ id, parent_thread_id, agent, status })), + }), + ); + for (const thread of threads) await verifyThreadHistory(ctx, sessionId, thread); + console.log(JSON.stringify({ stage: "verified", sessionId, threads: threads.length })); + } finally { + if (created) { + try { + cleaned = await cleanup(ctx, sessionId); + } catch (error) { + console.log(JSON.stringify({ stage: "cleanup_error", ...safeError(error) })); + } + } + if (!created || cleaned) rmSync(directory, { recursive: true, force: true }); + else { + console.log(JSON.stringify({ stage: "cleanup_incomplete", statePath, sessionId })); + process.exitCode = 1; + } + } +} + +await main().catch((error) => { + console.error(JSON.stringify({ stage: "failed", ...safeError(error) })); + process.exitCode = 1; +}); diff --git a/packages/sdk/tests/unit/bailian-event-accumulator.test.ts b/packages/sdk/tests/unit/bailian-event-accumulator.test.ts new file mode 100644 index 0000000..19abb8c --- /dev/null +++ b/packages/sdk/tests/unit/bailian-event-accumulator.test.ts @@ -0,0 +1,241 @@ +import { describe, expect, test } from "bun:test"; +import { BailianEventAccumulator } from "../../src/internal/providers/bailian/event-accumulator.ts"; + +const start = (id: string, type = "message") => ({ + object: "message", + id, + type, + role: "assistant", + status: "in_progress", +}); +const delta = (id: string, text: string, index = 0, append = true) => ({ + object: "content", + msg_id: id, + type: "text", + text, + index, + delta: append, + status: append ? "in_progress" : "completed", +}); +const finish = (id: string, content?: unknown[]) => ({ + object: "message", + id, + status: "completed", + ...(content === undefined ? {} : { content }), +}); + +describe("Bailian cumulative snapshots", () => { + test("appends repeated deltas, replaces snapshots, and does not mutate earlier outputs", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("m")); + const first = stream.push(delta("m", "哈"))!; + expect(stream.push(delta("m", "哈"))?.content).toBe("哈哈"); + const frame = delta("m", "你好", 0, false); + const replaced = stream.push(frame)!; + expect(replaced.content).toBe("你好"); + expect(replaced.raw).toBe(frame); + expect(first.snapshot?.content?.[0]?.text).toBe("哈"); + expect(replaced.snapshot?.metadata?.event_status).toBe("in_progress"); + expect(stream.push(finish("m"))?.snapshot?.metadata?.event_status).toBe("completed"); + expect(stream.push(delta("m", "late"))).toBeUndefined(); + expect(stream.push(start("m"))).toBeUndefined(); + }); + + test("explicit empty text and arrays clear content while omitted content preserves it", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("empty-text")); + stream.push(delta("empty-text", "old")); + expect(stream.push(delta("empty-text", "", 0, false))?.content).toBe(""); + expect(stream.push(finish("empty-text"))?.snapshot?.content).toEqual([{ type: "text", text: "" }]); + stream.push(start("empty-array")); + stream.push(delta("empty-array", "old")); + expect(stream.push(finish("empty-array", []))?.snapshot?.content).toEqual([]); + }); + + test("keeps block index order and independent message/thread identities", () => { + const stream = new BailianEventAccumulator(); + stream.push({ + ...start("a"), + thread_id: "thread-a", + created_at: "2026-10-16T00:00:00Z", + metadata: { custom: true }, + }); + stream.push({ ...start("b", "reasoning"), thread_id: "thread-b" }); + stream.push(delta("a", "B", 1)); + stream.push(delta("b", "Thinking")); + stream.push(delta("a", "A", 0)); + expect(stream.push(delta("a", "C", 1))?.content).toBe("ABC"); + const finalA = stream.push(finish("a"))!; + expect(finalA.snapshot).toMatchObject({ + event_id: "a", + role: "assistant", + created_at: "2026-10-16T00:00:00Z", + metadata: { session_thread_id: "thread-a", custom: true }, + }); + const finalB = stream.push(finish("b"))!; + expect(finalB.raw_type).toBe("reasoning"); + expect(finalB.content).toBe("Thinking"); + expect(finalB.session_thread_id).toBe("thread-b"); + }); + + test("buffers content before message identity and lets a final snapshot supersede it", () => { + const stream = new BailianEventAccumulator(); + expect(stream.push(delta("a", "early"))).toBeUndefined(); + const initial = stream.push(start("a", "reasoning"))!; + expect(initial.type).toBe("thinking"); + expect(initial.content).toBe("early"); + stream.push(delta("b", "discard")); + const final = stream.push({ + ...finish("b", [{ type: "text", text: "authoritative" }]), + type: "message", + role: "assistant", + })!; + expect(final.content).toBe("authoritative"); + expect(final.raw_type).toBe("message"); + }); + + test("retains completed reasoning with no content", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("r", "reasoning")); + const final = stream.push(finish("r"))!; + expect(final.snapshot?.content).toBeUndefined(); + expect(final.snapshot?.metadata?.event_status).toBe("completed"); + }); + + test("reconciles history, suppresses completed replay, and accepts authoritative corrections", () => { + const stream = new BailianEventAccumulator(); + stream.push({ ...start("m"), metadata: { known: true } }); + stream.push(delta("m", "partial")); + const raw = { ...finish("m", [{ type: "text", text: "final" }]), type: "message" }; + expect(stream.seed(raw)?.content).toBe("final"); + expect(stream.push(raw)).toBeUndefined(); + expect(stream.seed({ ...raw, content: [{ type: "text", text: "corrected" }] })?.snapshot?.metadata?.known).toBe( + true, + ); + expect(stream.push(delta("m", "late"))).toBeUndefined(); + }); + + test("reset drops interrupted baselines and waits for a new authoritative identity", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("m")); + stream.push(delta("m", "old half")); + stream.resetPartials(); + expect(stream.push(delta("m", "new tail"))).toBeUndefined(); + const restored = stream.seed({ + ...finish("m", [{ type: "text", text: "full restored message" }]), + type: "message", + }); + expect(restored?.content).toBe("full restored message"); + expect(stream.push(delta("m", "duplicate tail"))).toBeUndefined(); + }); + + test("does not present an unbased resumed tail as a completed message", () => { + const stream = new BailianEventAccumulator(); + stream.resetPartials(); + stream.push(delta("m", "only a tail")); + expect(() => stream.push({ ...finish("m"), type: "message" })).toThrow("missing an authoritative content snapshot"); + expect(stream.seed({ ...finish("m", [{ type: "text", text: "entire message" }]), type: "message" })?.content).toBe( + "entire message", + ); + }); + + test("requires explicit history content for interrupted text, but permits contentless reasoning", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("text")); + stream.push(delta("text", "known half")); + stream.push(start("reasoning", "reasoning")); + stream.resetPartials(); + expect(() => stream.seed({ ...finish("text"), type: "message" })).toThrow( + "missing an authoritative content snapshot", + ); + expect(stream.seed({ ...finish("reasoning"), type: "reasoning" })?.snapshot?.content).toBeUndefined(); + expect(stream.seed({ ...finish("text", []), type: "message" })?.snapshot?.content).toEqual([]); + }); + + test("a sparse restarted identity cannot turn a resumed tail into a complete message", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("m")); + stream.push(delta("m", "old first block", 0)); + stream.push(delta("m", "old second block", 1)); + stream.resetPartials(); + expect(stream.push(start("m"))).toBeUndefined(); + expect(stream.push(delta("m", "tail", 1))).toBeUndefined(); + expect(stream.push(delta("m", "complete second block", 1, false))).toBeUndefined(); + expect(() => stream.push(finish("m"))).toThrow("missing an authoritative content snapshot"); + expect( + stream.push( + finish("m", [ + { type: "text", text: "full first" }, + { type: "text", text: "full second" }, + ]), + )?.content, + ).toBe("full firstfull second"); + }); + + test("retains pending IDs across reset so recovery can repair older concurrent messages", () => { + const stream = new BailianEventAccumulator(); + stream.push(start("older")); + stream.push(delta("older", "partial")); + stream.push(delta("orphan", "partial")); + stream.push(start("reasoning", "reasoning")); + stream.seed({ ...finish("newer", [{ type: "text", text: "done" }]), type: "message" }); + expect(stream.pendingMessageIds().sort()).toEqual(["older", "orphan", "reasoning"]); + stream.resetPartials(); + stream.resetPartials(); + expect(stream.pendingMessageIds().sort()).toEqual(["older", "orphan", "reasoning"]); + stream.seed({ ...finish("older", [{ type: "text", text: "recovered" }]), type: "message" }); + stream.seed({ ...finish("reasoning"), type: "reasoning" }); + expect(stream.pendingMessageIds()).toEqual(["orphan"]); + }); + + test("correlates concurrent tool results by call_id, including artifacts with omitted tool name", () => { + const stream = new BailianEventAccumulator(); + const call = (id: string, name: string) => ({ + object: "message", + id, + type: "tool_call", + status: "completed", + content: [{ type: "data", data: { call_id: id, name, arguments: {} } }], + }); + stream.push(call("call-artifact", "mark_artifacts")); + stream.push(call("call-search", "search")); + const output = (id: string, result: unknown) => ({ + object: "message", + id: `output-${id}`, + type: "tool_call_output", + status: "completed", + content: [{ type: "data", data: { call_id: id, output: result } }], + }); + expect(stream.push(output("call-search", { answer: 1 }))?.tool_name).toBe("search"); + const artifact = stream.push( + output("call-artifact", { marked: [{ file_id: "file-1", path: "/out/report" }], failed: [] }), + )!; + expect(artifact.tool_name).toBe("mark_artifacts"); + expect(artifact.snapshot?.metadata?.artifacts).toEqual([ + { file_id: "file-1", path: "/out/report", filename: "report" }, + ]); + expect(stream.push(output("unknown-call", { marked: [{ file_id: "file-2" }] }))?.artifact).toBeUndefined(); + }); + + test("reports malformed frames and bounded orphan buffers without payload leakage", () => { + const stream = new BailianEventAccumulator({ maxEntries: 2 }); + expect(() => stream.push({ ...delta("m", "secret"), index: -1 })).toThrow("invalid index"); + expect(() => stream.push({ ...delta("m", "secret"), msg_id: undefined })).toThrow("missing msg_id"); + stream.push(delta("m", "1")); + stream.push(delta("m", "2")); + expect(() => stream.push(delta("m", "secret"))).toThrow("orphan content buffer exceeded"); + stream.clear(); + expect(stream.push(delta("m", "again"))).toBeUndefined(); + }); + + test("evicts completed entries rather than active messages and retains unknown no-id events", () => { + const stream = new BailianEventAccumulator({ maxEntries: 2 }); + stream.seed({ id: "old", type: "message", content: [] }); + stream.push(start("active")); + stream.push(start("next")); + expect(stream.push(delta("active", "still tracked"))?.content).toBe("still tracked"); + expect(() => stream.push(start("overflow"))).toThrow("active message buffer exceeded"); + const unknown = stream.push({ type: "future", data: { retained: true } }); + expect(unknown?.snapshot).toEqual({ type: "future", metadata: { data: { retained: true } } }); + }); +}); diff --git a/packages/sdk/tests/unit/bailian-event-frames.test.ts b/packages/sdk/tests/unit/bailian-event-frames.test.ts new file mode 100644 index 0000000..f507cb2 --- /dev/null +++ b/packages/sdk/tests/unit/bailian-event-frames.test.ts @@ -0,0 +1,154 @@ +import { describe, expect, test } from "bun:test"; +import { createBailianSessionEventNormalizer } from "../../src/session-events.ts"; + +// Shapes observed on the BMA Session stream on 2026-10-28; IDs and content are synthetic. +const start = (id: string, type: string, fields = {}) => ({ + type: "event_start", + event: { id, type, ...fields }, + object: "message", + status: "in_progress", +}); +const delta = (id: string, text: string, reasoning = false, index = 0) => ({ + type: "event_delta", + event_id: id, + delta: reasoning + ? { type: "reasoning_delta", index, reasoning: text } + : { type: "content_delta", index, content: { type: "text", text } }, + object: "content", + status: "in_progress", +}); +const complete = (id: string, type: string, text: string) => ({ + object: "message", + status: "completed", + id, + type, + role: "assistant", + thread_id: "thread-main", + created_at: "2026-10-28T12:00:00.000Z", + content: [{ type: "text", text }], +}); + +describe("public normalizer BMA mixed stream envelopes", () => { + test("accumulates reasoning and message deltas, then accepts final identity and independent idle", () => { + const normalizer = createBailianSessionEventNormalizer({ includeRaw: true }); + const initial = normalizer.push(start("reason", "reasoning"))!; + expect(initial).toMatchObject({ event_id: "reason", type: "reasoning", metadata: { event_status: "in_progress" } }); + expect(initial.role).toBeUndefined(); + expect(initial.metadata?.thread_id).toBeUndefined(); + const raw = delta("reason", "想", true); + const first = normalizer.push(raw)!; + expect(first.content).toEqual([{ type: "text", text: "想" }]); + expect(first.metadata?.raw).toEqual(raw); + expect(normalizer.push(delta("reason", "想", true))?.content).toEqual([{ type: "text", text: "想想" }]); + expect(first.content).toEqual([{ type: "text", text: "想" }]); + expect(normalizer.push(complete("reason", "reasoning", "完整推理"))).toMatchObject({ + event_id: "reason", + role: "assistant", + content: [{ type: "text", text: "完整推理" }], + metadata: { event_status: "completed", thread_id: "thread-main" }, + }); + normalizer.push(start("answer", "message")); + expect(normalizer.push(delta("answer", "你"))?.content).toEqual([{ type: "text", text: "你" }]); + expect(normalizer.push(delta("answer", "好"))?.content).toEqual([{ type: "text", text: "你好" }]); + expect(normalizer.push(complete("answer", "message", "你好!"))?.content).toEqual([ + { type: "text", text: "你好!" }, + ]); + expect(normalizer.push(delta("answer", "迟到"))).toBeUndefined(); + expect( + normalizer.push({ + object: "message", + status: "completed", + id: "status", + type: "session_status", + content: [{ type: "data", data: { session_status: "idle", stop_reason: "end_turn" } }], + })?.metadata, + ).toMatchObject({ status: "idle", stop_reason: "end_turn" }); + }); + + test("buffers orphan deltas by event ID and index while retaining optional start fields", () => { + const normalizer = createBailianSessionEventNormalizer(); + expect(normalizer.push(delta("message", "B", false, 1))).toBeUndefined(); + expect(normalizer.push(delta("reason", "", true))).toBeUndefined(); + expect(normalizer.push(start("reason", "reasoning"))?.content).toEqual([{ type: "text", text: "" }]); + expect( + normalizer.push({ + ...start("message", "message", { + role: "assistant", + thread_id: "thread-child", + created_at: "2026-10-28T12:00:00.000Z", + metadata: { inner: true }, + }), + metadata: { outer: true }, + }), + ).toMatchObject({ + event_id: "message", + role: "assistant", + created_at: "2026-10-28T12:00:00.000Z", + metadata: { thread_id: "thread-child", outer: true, inner: true }, + }); + expect(normalizer.push(delta("message", "A"))?.content).toEqual([ + { type: "text", text: "A" }, + { type: "text", text: "B" }, + ]); + }); + + test("history remains authoritative and stream envelopes cannot seed history", () => { + const normalizer = createBailianSessionEventNormalizer(); + normalizer.seed(complete("final", "message", "history")); + expect(normalizer.push(start("final", "message"))).toBeUndefined(); + expect(normalizer.push(delta("final", "older"))).toBeUndefined(); + expect(() => normalizer.seed(start("invalid", "message"))).toThrow("history must contain complete events"); + expect(() => normalizer.seed(delta("invalid", "older"))).toThrow("history must contain complete events"); + normalizer.seed({ ...complete("pending", "reasoning", "partial"), status: "in_progress" }); + expect(normalizer.push(start("pending", "reasoning"))).toBeUndefined(); + expect(normalizer.push(delta("pending", "tail", true))).toBeUndefined(); + expect(normalizer.push(complete("pending", "reasoning", "restored"))?.content).toEqual([ + { type: "text", text: "restored" }, + ]); + }); + + test("nested content fields survive both orphan buffering and direct deltas", () => { + const normalizer = createBailianSessionEventNormalizer(); + const content = { + type: "vendor_card", + id: "block-id", + event_id: "block-event", + object: "vendor", + status: "ready", + delta: false, + data: { text: "hello" }, + vendor: { enabled: true }, + }; + const frame = { + ...delta("message", "unused"), + delta: { type: "content_delta", index: 0, content }, + }; + expect(normalizer.push(frame)).toBeUndefined(); + expect(normalizer.push(start("message", "message"))?.content).toEqual([content]); + expect(normalizer.push(frame)?.content).toEqual([content]); + expect(normalizer.push({ ...complete("message", "message", "unused"), content: [content] })?.content).toEqual([ + content, + ]); + }); + + test("rejects malformed and excessive envelopes without echoing provider content", () => { + const normalizer = createBailianSessionEventNormalizer({ maxEntries: 1 }); + for (const frame of [ + start("", "reasoning"), + { ...start("m", "reasoning"), event: "secret-provider-body" }, + { ...delta("m", "secret-provider-body"), event_id: "" }, + delta("m", "secret-provider-body", false, -1), + { ...delta("m", "secret-provider-body"), delta: { type: "reasoning_delta", index: 0, reasoning: 1 } }, + ]) { + try { + normalizer.push(frame); + throw new Error("Expected protocol rejection"); + } catch (error) { + expect(error).toMatchObject({ code: "BAILIAN_EVENT_PROTOCOL_ERROR" }); + expect(String(error)).not.toContain("secret-provider-body"); + } + } + expect(normalizer.push(delta("orphan", "first"))).toBeUndefined(); + expect(() => normalizer.push(delta("orphan", "second"))).toThrow("orphan content buffer exceeded"); + }); +}); diff --git a/packages/sdk/tests/unit/bailian-event-normalizer.test.ts b/packages/sdk/tests/unit/bailian-event-normalizer.test.ts new file mode 100644 index 0000000..6ac449e --- /dev/null +++ b/packages/sdk/tests/unit/bailian-event-normalizer.test.ts @@ -0,0 +1,202 @@ +import { describe, expect, test } from "bun:test"; +import { createBailianSessionEventNormalizer } from "../../src/session-events.ts"; + +const start = (id: string, type = "message") => ({ + object: "message", + id, + type, + role: "assistant", + status: "in_progress", +}); +const delta = (id: string, text: string, index = 0, append = true) => ({ + object: "content", + msg_id: id, + type: "text", + text, + index, + delta: append, +}); +const finish = (id: string, content?: unknown[]) => ({ + object: "message", + id, + status: "completed", + ...(content === undefined ? {} : { content }), +}); +const text = (value: string) => [{ type: "text", text: value }]; + +describe("public browser Bailian normalizer", () => { + test("maps interleaved incremental frames to independent cumulative snapshots", () => { + const normalizer = createBailianSessionEventNormalizer({ redact: false, truncate: false }); + expect(normalizer.push(delta("a", "B", 1))).toBeUndefined(); + normalizer.push({ ...start("a"), thread_id: "thread-a" }); + normalizer.push(start("b", "reasoning")); + const first = normalizer.push(delta("a", "A"))!; + expect(first.content).toEqual([...text("A"), ...text("B")]); + expect(normalizer.push(delta("a", "A"))?.content).toEqual([...text("AA"), ...text("B")]); + expect(normalizer.push(delta("b", "thinking"))).toMatchObject({ + event_id: "b", + type: "reasoning", + content: text("thinking"), + }); + expect(normalizer.push(finish("a", text("final")))).toMatchObject({ + event_id: "a", + content: text("final"), + metadata: { event_status: "completed", session_thread_id: "thread-a" }, + }); + expect(first.content).toEqual([...text("A"), ...text("B")]); + expect(normalizer.push(delta("a", "late"))).toBeUndefined(); + normalizer.push(start("empty")); + normalizer.push(delta("empty", "old")); + expect(normalizer.push(finish("empty", []))?.content).toEqual([]); + expect(normalizer.push({ type: "future", payload: { preserved: true } })).toMatchObject({ + type: "future", + metadata: { payload: { preserved: true } }, + }); + }); + + test("shows unfinished history but never appends a buffered tail or trusts a single replacement block", () => { + const normalizer = createBailianSessionEventNormalizer(); + const historical = { + ...start("m"), + thread_id: "thread-1", + created_at: "2026-10-20T00:00:00Z", + content: [...text("old first block"), ...text("old second block")], + }; + expect(normalizer.seed(historical)).toMatchObject({ + event_id: "m", + role: "assistant", + content: historical.content, + metadata: { event_status: "in_progress", session_thread_id: "thread-1" }, + }); + expect(normalizer.push(delta("m", "tail", 1))).toBeUndefined(); + expect(normalizer.push(delta("m", "complete second", 1, false))).toBeUndefined(); + expect(normalizer.push({ ...start("m"), content: text("older buffered snapshot") })).toBeUndefined(); + expect(() => normalizer.push(finish("m"))).toThrow("missing an authoritative content snapshot"); + expect(normalizer.push(finish("m", [...text("full first"), ...text("full second")]))).toMatchObject({ + content: [...text("full first"), ...text("full second")], + metadata: { event_status: "completed", session_thread_id: "thread-1" }, + }); + expect(normalizer.push(finish("m", text("older completion")))).toBeUndefined(); + }); + + test("locks completed history text against older buffered snapshots but allows same-ID state updates", () => { + const normalizer = createBailianSessionEventNormalizer(); + normalizer.seed({ id: "m", type: "message", content: text("history final") }); + expect(normalizer.push({ ...start("m"), content: text("stale") })).toBeUndefined(); + expect(normalizer.push({ ...finish("m", text("stale completed")), type: "message" })).toBeUndefined(); + expect(normalizer.seed({ ...start("m"), content: text("stale history") })).toBeUndefined(); + const status = { + ...finish("state"), + type: "session_status", + content: [{ type: "data", data: { session_status: "running" } }], + }; + expect(normalizer.seed(status)?.metadata?.status).toBe("running"); + expect( + normalizer.push({ ...status, content: [{ type: "data", data: { session_status: "idle" } }] })?.metadata?.status, + ).toBe("idle"); + }); + + test("preserves unfinished history running and approval identity without falsely completing it", () => { + const normalizer = createBailianSessionEventNormalizer(); + expect( + normalizer.seed({ + ...start("state", "session_status"), + content: [ + { type: "data", data: { session_status: "running", pending_batch_id: "batch", pending_call_ids: ["call"] } }, + ], + }), + ).toMatchObject({ + metadata: { + event_status: "in_progress", + status: "running", + pending_batch_id: "batch", + pending_call_ids: ["call"], + }, + }); + expect( + normalizer.push({ ...finish("state"), content: [{ type: "data", data: { session_status: "idle" } }] })?.metadata, + ).toMatchObject({ + event_status: "completed", + status: "idle", + }); + expect(() => normalizer.seed({ ...start(""), content: [] })).toThrow("missing its event ID"); + expect(() => normalizer.seed(delta("state", "invalid history"))).toThrow("history must contain complete events"); + }); + + test("correlates history tool calls with live artifacts while retaining unknown content", () => { + const normalizer = createBailianSessionEventNormalizer({ redact: false, truncate: false }); + normalizer.seed({ + ...finish("tool"), + type: "tool_call", + content: [{ type: "data", data: { call_id: "c1", name: "mark_artifacts", arguments: { files: ["f1"] } } }], + }); + const result = normalizer.push({ + ...finish("output"), + type: "tool_call_output", + content: [ + { + type: "data", + data: { call_id: "c1", output: { marked: [{ file_id: "f1", path: "/out/report.html" }], failed: [] } }, + }, + { type: "future_block", custom: true }, + ], + })!; + expect(result.metadata).toMatchObject({ + tool_name: "mark_artifacts", + call_id: "c1", + artifacts: [{ file_id: "f1", path: "/out/report.html", filename: "report.html" }], + }); + expect(result.content?.[1]).toEqual({ type: "future_block", custom: true }); + }); + + test("keeps sanitizer defaults and opt-in full fidelity on both history and incremental output", () => { + const raw = { ...finish("secret", text(`token=synthetic-value ${"x".repeat(4100)}`)), type: "message" }; + const defaults = createBailianSessionEventNormalizer().seed(raw)!; + expect(defaults.metadata).toMatchObject({ redacted: true, truncated: true }); + expect(defaults.metadata?.raw).toBeUndefined(); + expect(defaults.content?.[0]?.text).not.toContain("synthetic-value"); + const complete = createBailianSessionEventNormalizer({ redact: false, truncate: false }); + expect(complete.seed(raw)?.content).toEqual(raw.content); + complete.push(start("live")); + expect(complete.push(delta("live", raw.content![0]!.text as string))?.content).toEqual(raw.content); + const rawOutput = createBailianSessionEventNormalizer({ includeRaw: true }).seed(raw)!; + expect(rawOutput.metadata?.raw).toBeDefined(); + expect(JSON.stringify(rawOutput.metadata?.raw)).not.toContain("synthetic-value"); + }); + + test("bounds retained history and orphan frames, isolates subscriptions and clears recovery state", () => { + const first = createBailianSessionEventNormalizer({ maxEntries: 2 }); + const second = createBailianSessionEventNormalizer(); + first.seed({ ...finish("m", text("completed")), type: "message" }); + first.seed({ ...start("pending"), content: text("half") }); + expect(() => first.push(start("overflow"))).toThrow("message buffer exceeded"); + second.push(start("m")); + expect(second.push(delta("m", "independent"))?.content).toEqual(text("independent")); + first.clear(); + first.push(start("m")); + expect(first.push(delta("m", "fresh"))?.content).toEqual(text("fresh")); + first.clear(); + first.push(delta("orphan", "one")); + first.push(delta("orphan", "two")); + expect(() => first.push(delta("orphan", "synthetic-secret"))).toThrow("orphan content buffer exceeded its limit."); + first.clear(); + first.push(start("blocks")); + first.push(delta("blocks", "a", 0)); + first.push(delta("blocks", "b", 1)); + expect(() => first.push(delta("blocks", "c", 2))).toThrow("content block buffer exceeded"); + expect(() => createBailianSessionEventNormalizer({ maxEntries: 0 })).toThrow(RangeError); + }); + + test("bundles the public subpath for browsers without SDK Node modules", async () => { + const result = await Bun.build({ + entrypoints: [new URL("../../src/session-events.ts", import.meta.url).pathname], + target: "browser", + minify: false, + }); + expect(result.success).toBe(true); + const bundled = await result.outputs[0]!.text(); + expect(bundled).toContain("createBailianSessionEventNormalizer"); + expect(bundled).not.toMatch(/from ["'](?:node:|fs|path|crypto|http|https)["']/); + expect(bundled).not.toContain("process.env"); + }); +}); diff --git a/packages/sdk/tests/unit/bailian-event-snapshot.test.ts b/packages/sdk/tests/unit/bailian-event-snapshot.test.ts new file mode 100644 index 0000000..a544467 --- /dev/null +++ b/packages/sdk/tests/unit/bailian-event-snapshot.test.ts @@ -0,0 +1,204 @@ +import { describe, expect, test } from "bun:test"; +import { toSessionEvent } from "../../src/internal/providers/bailian/event-mapper.ts"; +import { BailianEventProtocolError } from "../../src/internal/providers/bailian/snapshot-mapper.ts"; +import { SessionEventSchema } from "../../src/internal/types/dto.ts"; + +const snapshot = (raw: Record) => toSessionEvent(raw, { event_format: "snapshot" }); + +describe("Bailian structured event mapping", () => { + test("legacy callers retain their exact output while snapshot mode preserves complete message identity", () => { + const raw = { + object: "message", + id: "msg-1", + type: "reasoning", + status: "completed", + role: "assistant", + created_at: "2026-10-16T00:00:00Z", + thread_id: "thread-1", + content: [{ type: "text", text: "Thinking" }], + }; + expect(toSessionEvent(raw)).toEqual({ + type: "thinking", + raw_type: "reasoning", + id: "msg-1", + role: "assistant", + raw, + }); + const event = snapshot(raw); + expect(event.content).toBe("Thinking"); + expect(event.session_thread_id).toBe("thread-1"); + expect(event.snapshot).toEqual({ + event_id: "msg-1", + type: "reasoning", + role: "assistant", + created_at: raw.created_at, + content: raw.content, + metadata: { event_status: "completed", thread_id: "thread-1", session_thread_id: "thread-1" }, + }); + expect(SessionEventSchema.safeParse(event.snapshot).success).toBe(true); + }); + + test("keeps unknown multimodal blocks and event-specific data without fabricating content", () => { + const raw = { + type: "future_evaluation", + score: 0.7, + metadata: { custom: { valid: true } }, + content: [ + { type: "image", image_url: { url: "https://example.test/image" } }, + { type: "future", data: { score: 1 } }, + ], + }; + const event = snapshot(raw); + expect(event.type).toBe("unknown"); + expect(event.snapshot?.type).toBe("future_evaluation"); + expect(event.snapshot?.content).toEqual(raw.content); + expect(event.snapshot?.metadata).toEqual({ custom: { valid: true }, score: 0.7 }); + expect(snapshot({ type: "reasoning", status: "in_progress" }).snapshot).toEqual({ + type: "reasoning", + metadata: { event_status: "in_progress" }, + }); + }); + + test("separates message lifecycle from session status and preserves approval variants", () => { + const stopReason = { type: "requires_action", event_ids: ["event-1"], call_ids: ["call-1"] }; + const data = { + session_status: "idle", + stop_reason: stopReason, + pending_batch_id: "batch-1", + pending_call_ids: ["call-1"], + }; + const event = snapshot({ + object: "message", + type: "session_status", + status: "completed", + content: [{ type: "data", data }], + }); + expect(event.status).toBe("idle"); + expect(event.stop_reason).toBe("requires_action"); + expect(event.snapshot?.metadata).toEqual({ + event_status: "completed", + status: "idle", + stop_reason: stopReason, + pending_batch_id: "batch-1", + pending_call_ids: ["call-1"], + }); + expect(event.snapshot?.content?.[0]?.data).toEqual(data); + }); + + test("does not mistake a completed status-message lifecycle for a completed session", () => { + const raw = { object: "message", type: "session_status", status: "completed" }; + expect(toSessionEvent(raw).status).toBe("completed"); + const mapped = snapshot(raw); + expect(mapped.status).toBeUndefined(); + expect(mapped.snapshot?.metadata).toEqual({ event_status: "completed" }); + const explicit = snapshot({ ...raw, status: "in_progress", session_status: "running" }); + expect(explicit.status).toBe("running"); + expect(explicit.snapshot?.metadata).toMatchObject({ event_status: "in_progress", status: "running" }); + const metadataStatus = snapshot({ ...raw, metadata: { status: "idle" } }); + expect(metadataStatus.status).toBe("idle"); + expect(metadataStatus.snapshot?.metadata).toEqual({ event_status: "completed", status: "idle" }); + const legacyEnvelope = snapshot({ type: "session_status", status: "idle" }); + expect(legacyEnvelope.status).toBe("idle"); + expect(legacyEnvelope.snapshot?.metadata).toEqual({ status: "idle" }); + }); + + test("keeps structured arguments, failures and MCP metadata in all tool variants", () => { + for (const type of ["tool_call", "function_call", "mcp_call"]) { + const data = { + name: "search", + call_id: "call-1", + arguments: { query: "topic" }, + server_label: "docs", + evaluated_permission: "ask", + }; + const event = snapshot({ + type, + content: [ + { type: "text", text: "Calling" }, + { type: "data", data }, + ], + }); + expect(event.tool_name).toBe("search"); + expect(event.tool_input).toBe('{"query":"topic"}'); + expect(event.snapshot?.metadata).toMatchObject({ + tool_name: "search", + tool_input: { query: "topic" }, + call_id: "call-1", + server_label: "docs", + evaluated_permission: "ask", + }); + const output = snapshot({ + type: `${type}_output`, + is_error: true, + content: [{ type: "data", data: { call_id: "call-1", output: { reason: "denied" } } }], + }); + expect(output.snapshot?.is_error).toBe(true); + expect(output.snapshot?.content?.[0]?.data).toEqual({ call_id: "call-1", output: { reason: "denied" } }); + } + }); + + test("retains nested errors, root aliases, and routing fields", () => { + const error = snapshot({ + type: "error", + error: { code: "denied", message: "Access denied", detail: { retry: false } }, + }); + expect(error.snapshot).toMatchObject({ + code: "denied", + message: "Access denied", + metadata: { error: { code: "denied", message: "Access denied", detail: { retry: false } } }, + }); + expect(error.content).toBe("Access denied"); + expect(error.snapshot?.is_error).toBe(true); + const routed = snapshot({ + type: "thread_message_sent", + from_thread_id: "parent", + to_thread_id: "child", + content: [{ type: "data", data: { session_thread_id: "child" } }], + }); + expect(routed.snapshot?.role).toBe("user"); + expect(routed.snapshot?.metadata).toMatchObject({ + from_thread_id: "parent", + to_thread_id: "child", + session_thread_id: "child", + }); + }); + + test("derives artifact descriptors only from identified successful tool results", () => { + const output = { + marked: [ + { file_id: " file-1 ", path: "/out/report.pdf", description: "Report" }, + { file_id: "" }, + { file_id: "file-2", filename: "data.csv" }, + ], + failed: [{ path: "/out/missing" }], + }; + const raw = { + type: "tool_call_output", + content: [{ type: "data", data: { name: "mark_artifacts", output: JSON.stringify(output) } }], + }; + const event = snapshot(raw); + expect(event.snapshot?.metadata?.artifacts).toEqual([ + { file_id: "file-1", path: "/out/report.pdf", filename: "report.pdf", description: "Report" }, + { file_id: "file-2", filename: "data.csv" }, + ]); + expect(event.artifact).toEqual({ file_id: "file-1", filename: "report.pdf" }); + expect(event.snapshot?.content).toEqual(raw.content); + expect(snapshot({ ...raw, is_error: true }).snapshot?.metadata?.artifacts).toBeUndefined(); + expect( + snapshot({ ...raw, content: [{ type: "data", data: { output } }] }).snapshot?.metadata?.artifacts, + ).toBeUndefined(); + }); + + test("clones structured output and rejects frames that require stream context", () => { + const raw = { type: "message", content: [{ type: "image", data: { nested: [1] } }], metadata: { nested: [2] } }; + const event = snapshot(raw); + (event.snapshot!.content![0]!.data as { nested: number[] }).nested.push(3); + (event.snapshot!.metadata!.nested as number[]).push(4); + expect(raw.content[0]!.data.nested).toEqual([1]); + expect(raw.metadata.nested).toEqual([2]); + expect(() => snapshot({ object: "content", type: "text", text: "secret", msg_id: "msg-1" })).toThrow( + BailianEventProtocolError, + ); + expect(() => snapshot({ status: "completed" })).toThrow("missing its type"); + }); +}); diff --git a/packages/sdk/tests/unit/bailian-history-snapshot.test.ts b/packages/sdk/tests/unit/bailian-history-snapshot.test.ts new file mode 100644 index 0000000..25ecbdc --- /dev/null +++ b/packages/sdk/tests/unit/bailian-history-snapshot.test.ts @@ -0,0 +1,96 @@ +import { afterEach, expect, test } from "bun:test"; +import { BailianAdapter } from "../../src/internal/providers/bailian/adapter.ts"; +import { type FetchLike, setDefaultFetch } from "../../src/internal/transport.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +const call = { + object: "message", + id: "call-event", + type: "tool_call", + status: "completed", + content: [ + { type: "data", data: { call_id: "call-1", name: "mark_artifacts", arguments: { paths: ["/out/report.pdf"] } } }, + ], +}; +const output = { + object: "message", + id: "output-event", + type: "tool_call_output", + status: "completed", + content: [ + { + type: "data", + data: { call_id: "call-1", output: { marked: [{ file_id: "file-1", path: "/out/report.pdf" }], failed: [] } }, + }, + ], +}; + +function requestUrl(input: Parameters[0]): URL { + return new URL(input instanceof Request ? input.url : input.toString()); +} + +for (const order of ["asc", "desc"] as const) { + test(`snapshot history correlates tools in ${order} order without forwarding SDK options`, async () => { + const events = order === "asc" ? [call, output] : [output, call]; + let request: URL | undefined; + setDefaultFetch(async (input) => { + request = requestUrl(input); + return Response.json({ data: events, next_page: "opaque + cursor" }); + }); + const adapter = new BailianAdapter("test-key", undefined, "https://bailian.test/api/v1/agentstudio"); + const result = await adapter.listSessionEvents("session-1", { + event_format: "snapshot", + order, + limit: 20, + page_token: "previous + cursor", + }); + expect(result.events.map((event) => event.id)).toEqual(events.map((event) => event.id)); + const toolOutput = result.events.find((event) => event.id === "output-event")!; + expect(toolOutput.tool_name).toBe("mark_artifacts"); + expect(toolOutput.snapshot?.metadata?.tool_name).toBe("mark_artifacts"); + expect(toolOutput.snapshot?.metadata?.artifacts).toEqual([ + { file_id: "file-1", path: "/out/report.pdf", filename: "report.pdf" }, + ]); + expect(toolOutput.snapshot?.content).toEqual(output.content); + expect(toolOutput.raw).toEqual(output); + expect(result.has_more).toBe(true); + expect(result.next_page).toBe("opaque + cursor"); + expect(Object.fromEntries(request!.searchParams)).toEqual({ limit: "20", order, page: "previous + cursor" }); + }); +} + +test("legacy history retains its output and snapshot correlation does not persist across pages or sessions", async () => { + const adapter = new BailianAdapter("test-key", undefined, "https://bailian.test/api/v1/agentstudio"); + let requests = 0; + setDefaultFetch(async () => + Response.json({ data: ++requests === 1 ? [output, call] : requests === 2 ? [call] : [output], next_page: null }), + ); + const legacy = await adapter.listSessionEvents("session-1"); + expect(legacy.events[0]?.tool_name).toBe(""); + expect(legacy.events[0]?.snapshot).toBeUndefined(); + await adapter.listSessionEvents("session-1", { event_format: "snapshot" }); + for (const sessionId of ["session-1", "session-2"]) { + const page = await adapter.listSessionEvents(sessionId, { event_format: "snapshot", page_token: "next" }); + expect(page.events[0]?.tool_name).toBe(""); + expect(page.events[0]?.snapshot?.metadata?.artifacts).toBeUndefined(); + expect(page.events[0]?.snapshot?.content).toEqual(output.content); + } +}); + +test("ambiguous call identities do not infer a tool name or artifacts", async () => { + setDefaultFetch(async () => + Response.json({ + data: [ + call, + { ...call, id: "conflicting-call", content: [{ type: "data", data: { call_id: "call-1", name: "search" } }] }, + output, + ], + next_page: null, + }), + ); + const adapter = new BailianAdapter("test-key", undefined, "https://bailian.test/api/v1/agentstudio"); + const result = await adapter.listSessionEvents("session-1", { event_format: "snapshot" }); + expect(result.events[2]?.tool_name).toBe(""); + expect(result.events[2]?.snapshot?.metadata?.artifacts).toBeUndefined(); +}); diff --git a/packages/sdk/tests/unit/bailian-managed-api.test.ts b/packages/sdk/tests/unit/bailian-managed-api.test.ts index 31cbd87..e7257e9 100644 --- a/packages/sdk/tests/unit/bailian-managed-api.test.ts +++ b/packages/sdk/tests/unit/bailian-managed-api.test.ts @@ -230,7 +230,89 @@ describe("Bailian session API additions", () => { }); }); -test("operation capabilities distinguish Managed Agents Thread from deprecated Assistant Thread", () => { +describe("Bailian session runtime resources", () => { + const resource = { + id: "sesrsc_1", + type: "file", + file_id: "file_internal_copy", + memory_store_id: null, + access: null, + instructions: null, + name: null, + description: null, + mount_path: "/mnt/session/uploads/report.csv", + created_at: "2026-11-02T18:19:52+08:00", + updated_at: "2026-11-02T18:19:52+08:00", + request_id: "req_1", + }; + + test("mounts a running-session file, mapping the sandbox path to the /uploads wire prefix", async () => { + const calls = installJsonFetch([resource]); + const mounted = await adapter().mountSessionResource("sesn_1", { + type: "file", + file_id: "file_original", + mount_path: "/mnt/session/uploads/report.csv", + }); + + expect(calls[0]!.method).toBe("POST"); + expect(calls[0]!.url).toBe(`${BASE}/sessions/sesn_1/resources`); + expect(calls[0]!.body).toEqual({ + type: "file", + file_id: "file_original", + mount_path: "/uploads/report.csv", + }); + expect(mounted.id).toBe("sesrsc_1"); + expect(mounted.type).toBe("file"); + expect(mounted.file_id).toBe("file_internal_copy"); + expect(mounted.mount_path).toBe("/mnt/session/uploads/report.csv"); + expect(mounted.attributes.request_id).toBe("req_1"); + }); + + test("mount accepts an already wire-shaped /uploads path and rejects foreign roots", async () => { + const calls = installJsonFetch([resource]); + await adapter().mountSessionResource("sesn_1", { + type: "file", + file_id: "file_original", + mount_path: "/uploads/a/b.txt", + }); + expect(calls[0]!.body).toEqual(expect.objectContaining({ mount_path: "/uploads/a/b.txt" })); + + await expect( + adapter().mountSessionResource("sesn_1", { + type: "file", + file_id: "file_original", + mount_path: "/mnt/session/other/x.txt", + }), + ).rejects.toThrow("/uploads/"); + }); + + test("lists, gets and unmounts session resources", async () => { + const calls = installJsonFetch([ + { data: [resource], next_page: "P2" }, + resource, + { id: "sesrsc_1", type: "session_resource_deleted", request_id: "req_2" }, + ]); + + const page = await adapter().listSessionResources("sesn_1", { limit: 10, page: "P1" }); + const single = await adapter().getSessionResource("sesn_1", "sesrsc_1"); + await adapter().unmountSessionResource("sesn_1", "sesrsc_1"); + + const listUrl = new URL(calls[0]!.url); + expect(calls[0]!.url).toBe(`${BASE}/sessions/sesn_1/resources?limit=10&page=P1`); + expect(listUrl.searchParams.get("limit")).toBe("10"); + expect(listUrl.searchParams.get("page")).toBe("P1"); + expect(page.data[0]?.id).toBe("sesrsc_1"); + expect(page.data[0]?.file_id).toBe("file_internal_copy"); + expect(page.next_page).toBe("P2"); + expect(calls[1]!.url).toBe(`${BASE}/sessions/sesn_1/resources/sesrsc_1`); + expect(single.id).toBe("sesrsc_1"); + expect(single.mount_path).toBe("/mnt/session/uploads/report.csv"); + expect(calls[2]!.method).toBe("DELETE"); + expect(calls[2]!.url).toBe(`${BASE}/sessions/sesn_1/resources/sesrsc_1`); + }); +}); + +test("operation capabilities expose thread reads and keep unimplemented thread mutations unsupported", () => { const capabilities = getManagedAgentProviderCapabilities("bailian"); expect(capabilities.operations["agent.create"]?.supported).toBe(true); expect(capabilities.operations["environment.create"]?.supported).toBe(true); @@ -239,6 +321,9 @@ test("operation capabilities distinguish Managed Agents Thread from deprecated A expect(capabilities.operations["vault.credential.create"]?.supported).toBe(true); expect(capabilities.operations["deployment.create"]?.supported).toBe(true); expect(capabilities.operations["session.event.list"]?.supported).toBe(true); - expect(capabilities.operations["session_thread.list"]?.supported).toBe(false); + expect(capabilities.operations["session_thread.list"]?.supported).toBe(true); + expect(capabilities.operations["session_thread.events"]?.supported).toBe(true); + expect(capabilities.operations["session_thread.get"]?.supported).toBe(false); + expect(capabilities.operations["session_thread.archive"]?.supported).toBe(false); expect(capabilities.operations["model.list"]?.supported).toBe(false); }); diff --git a/packages/sdk/tests/unit/bailian-session-stream.test.ts b/packages/sdk/tests/unit/bailian-session-stream.test.ts new file mode 100644 index 0000000..71d1dee --- /dev/null +++ b/packages/sdk/tests/unit/bailian-session-stream.test.ts @@ -0,0 +1,633 @@ +import { afterEach, expect, test } from "bun:test"; +import { BailianAdapter } from "../../src/internal/providers/bailian/adapter.ts"; +import { type FetchLike, setDefaultFetch } from "../../src/internal/transport.ts"; +import type { ProviderSessionEvent } from "../../src/internal/types/session-event.ts"; + +const BASE = "https://bailian.test/api/v1/agentstudio"; +const encoder = new TextEncoder(); +afterEach(() => setDefaultFetch(undefined)); + +function adapter(): BailianAdapter { + return new BailianAdapter("test-secret-key", undefined, BASE); +} + +function message(id: string, text = id, status = "completed"): Record { + return { object: "message", id, type: "message", role: "assistant", status, content: [{ type: "text", text }] }; +} + +function feed(initial: Record[] = [], closed = false) { + let controller!: ReadableStreamDefaultController; + let cancelled = false; + const response = new Response( + new ReadableStream({ + start(value) { + controller = value; + for (const item of initial) value.enqueue(encoder.encode(`data: ${JSON.stringify(item)}\n\n`)); + if (closed) value.close(); + }, + cancel() { + cancelled = true; + }, + }), + ); + return { + response, + push: (raw: Record) => controller.enqueue(encoder.encode(`data: ${JSON.stringify(raw)}\n\n`)), + close: () => controller.close(), + cancelled: () => cancelled, + }; +} + +function iterator(options: Parameters[1] = {}) { + return adapter().streamSessionEvents("session-test", options)[Symbol.asyncIterator](); +} + +async function take(stream: AsyncIterator, count: number): Promise { + const events: ProviderSessionEvent[] = []; + for (let index = 0; index < count; index += 1) { + const next = await stream.next(); + if (next.done) throw new Error("Unexpected end of test stream"); + events.push(next.value); + } + return events; +} + +function url(input: Parameters[0]): URL { + return new URL(input instanceof Request ? input.url : input.toString()); +} + +function abortablePending(signal?: AbortSignal | null): Promise { + return new Promise((_resolve, reject) => { + const abort = () => reject(new DOMException("Cancelled test request", "AbortError")); + if (signal?.aborted) abort(); + else signal?.addEventListener("abort", abort, { once: true }); + }); +} + +test("Bailian legacy defaults keep complete-event mapping and omit new query parameters", async () => { + const requests: URL[] = []; + setDefaultFetch(async (input) => { + requests.push(url(input)); + return feed([message("one")], true).response; + }); + const stream = iterator(); + const [event] = await take(stream, 1); + expect(event?.snapshot).toBeUndefined(); + expect(event?.content).toBe("one"); + expect((await stream.next()).done).toBe(true); + expect(requests[0]?.search).toBe(""); +}); + +test("Bailian explicit deltas produce cumulative snapshots and only send event_deltas[]", async () => { + let request: URL | undefined; + const frames = [ + message("one", "", "in_progress"), + { object: "content", msg_id: "one", type: "text", index: 0, delta: true, text: "你" }, + { object: "content", msg_id: "one", type: "text", index: 0, delta: true, text: "好" }, + message("one", "你好"), + ]; + const source = feed(frames); + setDefaultFetch(async (input) => { + request = url(input); + return source.response; + }); + const stream = iterator({ event_deltas: ["message", "reasoning", "message"] }); + try { + const events = await take(stream, 4); + expect(events.map((event) => event.snapshot?.content?.[0]?.text)).toEqual(["", "你", "你好", "你好"]); + expect(events.map((event) => event.id)).toEqual(["one", "one", "one", "one"]); + expect(request?.searchParams.getAll("event_deltas[]")).toEqual(["message", "reasoning"]); + expect([...request!.searchParams.keys()]).toEqual(["event_deltas[]", "event_deltas[]"]); + } finally { + await stream.return?.(); + } + expect(source.cancelled()).toBe(true); +}); + +test("stale unfinished history cannot reopen an already delivered complete answer", async () => { + const answer = message("answer", "FINAL ANSWER"); + const idle = { + object: "message", + id: "idle", + type: "session_status", + status: "completed", + content: [{ type: "data", data: { session_status: "idle" } }], + }; + let connections = 0; + setDefaultFetch(async (input) => { + if (url(input).pathname.endsWith("/stream")) { + return ++connections === 1 ? feed([answer], true).response : feed().response; + } + return Response.json({ data: [message("answer", "partial", "in_progress"), idle], next_page: null }); + }); + const stream = iterator({ event_format: "snapshot", reconnect: true, connectTimeoutMs: 50 }); + try { + const events = await take(stream, 2); + expect(events.map((event) => [event.id, event.content, event.status])).toEqual([ + ["answer", "FINAL ANSWER", undefined], + ["idle", undefined, "idle"], + ]); + expect(connections).toBe(2); + } finally { + await stream.return?.(); + } +}); + +test("BMA envelopes survive EOF recovery and only complete on the authoritative message", async () => { + const start = { + type: "event_start", + event: { id: "pending", type: "reasoning" }, + object: "message", + status: "in_progress", + }; + const delta = { + type: "event_delta", + event_id: "pending", + delta: { type: "reasoning_delta", index: 0, reasoning: "partial" }, + object: "content", + status: "in_progress", + }; + const final = { ...message("pending", "complete reasoning"), type: "reasoning", thread_id: "thread-main" }; + const idle = { + object: "message", + status: "completed", + id: "status", + type: "session_status", + content: [{ type: "data", data: { session_status: "idle", stop_reason: "end_turn" } }], + }; + const resumed = feed([start, delta, final, idle]); + let connections = 0; + setDefaultFetch(async (input) => { + if (url(input).pathname.endsWith("/stream")) { + return ++connections === 1 ? feed([message("marker"), start, delta], true).response : resumed.response; + } + return Response.json({ data: [message("marker"), final], next_page: null }); + }); + const abort = new AbortController(); + const stream = iterator({ event_deltas: ["reasoning", "message"], reconnect: true, signal: abort.signal }); + const guard = setTimeout(() => abort.abort(), 1500); + try { + const events = await take(stream, 5); + expect(events.map((event) => event.id)).toEqual(["marker", "pending", "pending", "pending", "status"]); + expect(events[1]?.snapshot).toMatchObject({ type: "reasoning", metadata: { event_status: "in_progress" } }); + expect(events[2]?.content).toBe("partial"); + expect(events[2]?.raw).toEqual(delta); + expect(events[3]?.snapshot).toMatchObject({ + content: [{ type: "text", text: "complete reasoning" }], + metadata: { event_status: "completed", thread_id: "thread-main" }, + }); + expect(events[4]?.status).toBe("idle"); + expect(connections).toBe(2); + } finally { + clearTimeout(guard); + abort.abort(); + await stream.return?.(); + } +}); + +test("reconnect paginates more than 100 events with opaque cursors and deduplicates live overlap", async () => { + const history = Array.from({ length: 102 }, (_, index) => message(`e${index.toString().padStart(3, "0")}`)); + const cursor = "opaque page + / = ?"; + const requests: URL[] = []; + let connections = 0; + const resumed = feed([history[101]!]); + setDefaultFetch(async (input) => { + const request = url(input); + requests.push(request); + if (request.pathname.endsWith("/stream")) + return ++connections === 1 ? feed([history[0]!], true).response : resumed.response; + if (!request.searchParams.has("page")) return Response.json({ data: history.slice(0, 100), next_page: cursor }); + expect(request.searchParams.get("page")).toBe(cursor); + return Response.json({ data: history.slice(100), next_page: null }); + }); + const stream = iterator({ event_format: "snapshot", reconnect: true }); + try { + const events = await take(stream, 102); + resumed.push(message("e102")); + events.push(...(await take(stream, 1))); + expect(events.map((event) => event.id)).toEqual( + Array.from({ length: 103 }, (_, index) => `e${index.toString().padStart(3, "0")}`), + ); + expect(connections).toBe(2); + const historyRequests = requests.filter((request) => !request.pathname.endsWith("/stream")); + expect(historyRequests).toHaveLength(2); + expect( + historyRequests.every( + (request) => request.searchParams.get("limit") === "100" && request.searchParams.get("order") === "asc", + ), + ).toBe(true); + expect(requests.every((request) => !request.searchParams.has("after_id"))).toBe(true); + } finally { + await stream.return?.(); + } +}); + +test("recovery preserves delivered snapshot comparisons across paginated history eviction and live overlap", async () => { + const state = (value: string) => ({ + object: "message", + id: "state", + type: "session_status", + status: "completed", + content: [{ type: "data", data: { session_status: value } }], + }); + const history = [ + ...Array.from({ length: 1024 }, (_, index) => message(`old-${index}`)), + state("idle"), + message("marker"), + message("answer", "final answer"), + ]; + const resumed = feed([state("idle"), message("answer", "final answer"), message("tail")]); + let connections = 0; + let pages = 0; + setDefaultFetch(async (input) => { + const request = url(input); + if (request.pathname.endsWith("/stream")) + return ++connections === 1 ? feed([state("running"), message("marker")], true).response : resumed.response; + pages++; + const offset = Number(request.searchParams.get("page") ?? "0"); + return Response.json({ + data: history.slice(offset, offset + 100), + next_page: offset + 100 < history.length ? String(offset + 100) : null, + }); + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", reconnect: true, signal: abort.signal }); + const guard = setTimeout(() => abort.abort(), 1500); + try { + const events = await take(stream, 5); + expect(events.map((event) => [event.id, event.status])).toEqual([ + ["state", "running"], + ["marker", undefined], + ["answer", undefined], + ["state", "idle"], + ["tail", undefined], + ]); + expect(connections).toBe(2); + expect(pages).toBe(11); + } finally { + clearTimeout(guard); + abort.abort(); + await stream.return?.(); + } +}); + +test("initial after_id history does not make skipped status IDs eligible for later recovery", async () => { + const state = (value: string) => ({ + object: "message", + id: "old-state", + type: "session_status", + status: "completed", + content: [{ type: "data", data: { session_status: value } }], + }); + const first = feed(); + const resumed = feed([state("idle"), message("tail")]); + let connections = 0; + setDefaultFetch(async (input) => { + if (url(input).pathname.endsWith("/stream")) return ++connections === 1 ? first.response : resumed.response; + return Response.json({ + data: [state(connections === 1 ? "running" : "idle"), message("marker"), message("first")], + next_page: null, + }); + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", after_id: "marker", reconnect: true, signal: abort.signal }); + const guard = setTimeout(() => abort.abort(), 1500); + try { + expect((await stream.next()).value?.id).toBe("first"); + first.close(); + expect((await stream.next()).value?.id).toBe("tail"); + expect(connections).toBe(2); + } finally { + clearTimeout(guard); + abort.abort(); + await stream.return?.(); + } +}); + +for (const latestState of ["idle", "running"]) { + test(`history retry preserves the latest ${latestState} status without losing or replaying stale idle`, async () => { + const state = (value: string) => ({ + object: "message", + id: "state", + type: "session_status", + status: "completed", + content: [{ type: "data", data: { session_status: value } }], + }); + const oldHistory = + latestState === "running" ? Array.from({ length: 1024 }, (_, index) => message(`old-${index}`)) : []; + let connections = 0; + let pages = 0; + setDefaultFetch(async (input) => { + const request = url(input); + if (request.pathname.endsWith("/stream")) { + connections++; + if (connections === 1) return feed([state("running"), message("marker")], true).response; + return feed(connections === 2 ? [] : [state(latestState), message("answer"), message("tail")]).response; + } + pages++; + if (request.searchParams.get("page") === "answer-page") + return connections === 2 + ? new Response("temporarily unavailable", { status: 503 }) + : Response.json({ data: [message("answer")], next_page: null }); + const history = [...oldHistory, state(connections === 2 ? "idle" : latestState), message("marker")]; + const offset = Number(request.searchParams.get("page") ?? "0"); + return Response.json({ + data: history.slice(offset, offset + 100), + next_page: offset + 100 < history.length ? String(offset + 100) : "answer-page", + }); + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", reconnect: true, signal: abort.signal }); + const guard = setTimeout(() => abort.abort(), 2000); + try { + const events = await take(stream, latestState === "idle" ? 5 : 4); + expect(events.map((event) => [event.id, event.status])).toEqual([ + ["state", "running"], + ["marker", undefined], + ["answer", undefined], + ...(latestState === "idle" ? [["state", latestState]] : []), + ["tail", undefined], + ]); + expect(connections).toBe(3); + expect(pages).toBe(latestState === "running" ? 24 : 4); + } finally { + clearTimeout(guard); + abort.abort(); + await stream.return?.(); + } + }); +} + +for (const scenario of ["missing-marker", "repeated-cursor", "missing-cursor"] as const) { + test(`history recovery rejects ${scenario} without retrying or leaking provider data`, async () => { + let requests = 0; + const source = feed(); + setDefaultFetch(async (input) => { + requests++; + if (url(input).pathname.endsWith("/stream")) return source.response; + if (scenario === "repeated-cursor") return Response.json({ data: [], next_page: "same-cursor" }); + if (scenario === "missing-cursor") return Response.json({ data: [], has_more: true }); + return Response.json({ data: [message("other")], next_page: null }); + }); + const error = await iterator({ event_format: "snapshot", after_id: "marker", reconnect: true }) + .next() + .catch((value) => value); + expect(error.message).toContain( + scenario === "missing-marker" + ? "marker was not found" + : scenario === "repeated-cursor" + ? "repeated cursor" + : "missing a pagination cursor", + ); + expect(requests).toBe(scenario === "repeated-cursor" ? 3 : 2); + expect(source.cancelled()).toBe(true); + }); +} + +for (const scenario of ["auth", "malformed"] as const) { + test(`snapshot stream does not retry ${scenario} failures`, async () => { + let requests = 0; + setDefaultFetch(async () => { + requests++; + return scenario === "auth" + ? new Response("provider-secret", { status: 401 }) + : new Response("data: secret-malformed\n\n"); + }); + const error = await iterator({ event_format: "snapshot", reconnect: true }) + .next() + .catch((value) => value); + expect(error).toMatchObject({ code: scenario === "auth" ? "http" : "protocol", retryable: false }); + expect(String(error)).not.toContain("secret"); + expect(requests).toBe(1); + }); +} + +test("explicit abort during retry backoff stops before another connection", async () => { + let requests = 0; + let ready!: () => void; + const connected = new Promise((resolve) => { + ready = resolve; + }); + setDefaultFetch(async () => { + requests++; + return feed([], true).response; + }); + const abort = new AbortController(); + const pending = iterator({ event_format: "snapshot", reconnect: true, signal: abort.signal, onReady: ready }).next(); + await connected; + await new Promise((resolve) => setTimeout(resolve, 20)); + abort.abort(); + await expect(pending).rejects.toMatchObject({ name: "AbortError" }); + expect(requests).toBe(1); +}); + +test("explicit abort cancels history fetch and releases its live subscription", async () => { + const source = feed(); + let querying!: () => void; + const historyStarted = new Promise((resolve) => { + querying = resolve; + }); + setDefaultFetch(async (input, init) => { + if (url(input).pathname.endsWith("/stream")) return source.response; + querying(); + return abortablePending(init?.signal); + }); + const abort = new AbortController(); + const pending = iterator({ event_format: "snapshot", after_id: "marker", signal: abort.signal }).next(); + await historyStarted; + abort.abort(); + await expect(pending).rejects.toMatchObject({ name: "AbortError" }); + expect(source.cancelled()).toBe(true); +}); + +test("abort discards buffered live snapshots and never reconnects", async () => { + let drained!: () => void; + const framesRead = new Promise((resolve) => { + drained = resolve; + }); + let sent = false; + let cancelled = false; + let requests = 0; + const response = new Response( + new ReadableStream( + { + pull(controller) { + if (sent) { + drained(); + return; + } + sent = true; + controller.enqueue( + encoder.encode( + [message("first"), message("second")].map((raw) => `data: ${JSON.stringify(raw)}\n\n`).join(""), + ), + ); + }, + cancel() { + cancelled = true; + }, + }, + // The next pull happens only after both frames have reached the subscription buffer. + { highWaterMark: 0 }, + ), + ); + setDefaultFetch(async () => { + requests++; + return response; + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", reconnect: true, signal: abort.signal }); + try { + expect((await stream.next()).value?.id).toBe("first"); + await framesRead; + abort.abort(); + await expect(stream.next()).rejects.toMatchObject({ name: "AbortError" }); + } finally { + await stream.return?.(); + } + expect(cancelled).toBe(true); + expect(requests).toBe(1); +}); + +test("abort stops a partially delivered history page and releases its live subscription", async () => { + const source = feed(); + let requests = 0; + setDefaultFetch(async (input) => { + requests++; + if (url(input).pathname.endsWith("/stream")) return source.response; + return Response.json({ data: [message("marker"), message("first"), message("second")], next_page: "next" }); + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", after_id: "marker", reconnect: true, signal: abort.signal }); + try { + expect((await stream.next()).value?.id).toBe("first"); + abort.abort(); + await expect(stream.next()).rejects.toMatchObject({ name: "AbortError" }); + } finally { + await stream.return?.(); + } + expect(source.cancelled()).toBe(true); + // Cancellation must neither advance pagination nor establish a replacement stream. + expect(requests).toBe(2); +}); + +test("content completion before message completion cannot become the reconnect marker", async () => { + let connections = 0; + const partial = [ + message("one", "partial", "in_progress"), + { object: "content", msg_id: "one", index: 0, type: "text", delta: false, status: "completed", text: "full" }, + ]; + const resumed = feed(); + setDefaultFetch(async (input) => { + if (url(input).pathname.endsWith("/stream")) + return ++connections === 1 ? feed(partial, true).response : resumed.response; + return Response.json({ data: [message("one", "full")], next_page: null }); + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", reconnect: true, signal: abort.signal }); + const guard = setTimeout(() => abort.abort(), 1000); + try { + const events = await take(stream, 3); + expect(events[2]?.snapshot?.metadata?.event_status).toBe("completed"); + expect(events[2]?.snapshot?.content?.[0]?.text).toBe("full"); + } finally { + clearTimeout(guard); + abort.abort(); + await stream.return?.(); + } +}); + +test("recovery buffer overflow interrupts a pending history request", async () => { + const source = feed(); + let querying!: () => void; + const historyStarted = new Promise((resolve) => { + querying = resolve; + }); + setDefaultFetch(async (input, init) => { + if (url(input).pathname.endsWith("/stream")) return source.response; + querying(); + return abortablePending(init?.signal); + }); + const abort = new AbortController(); + const pending = iterator({ event_format: "snapshot", after_id: "marker", signal: abort.signal }) + .next() + .catch((value) => value); + await historyStarted; + for (let index = 0; index < 1025; index++) source.push(message(`overflow-${index}`)); + const guard = setTimeout(() => abort.abort(), 1000); + try { + const error = await pending; + expect(error.message).toContain("buffer exceeded its limit"); + } finally { + clearTimeout(guard); + abort.abort(); + } + expect(source.cancelled()).toBe(true); +}); + +test("recovery repairs an older partial message even when a newer message completed first", async () => { + let connections = 0; + const resumed = feed(); + setDefaultFetch(async (input) => { + if (url(input).pathname.endsWith("/stream")) { + connections++; + return connections === 1 + ? feed([message("older", "partial", "in_progress"), message("newer", "done")], true).response + : resumed.response; + } + return Response.json({ data: [message("older", "repaired"), message("newer", "done")], next_page: null }); + }); + const abort = new AbortController(); + const stream = iterator({ event_format: "snapshot", reconnect: true, signal: abort.signal }); + const guard = setTimeout(() => abort.abort(), 1000); + try { + const events = await take(stream, 3); + expect(events.map((event) => event.id)).toEqual(["older", "newer", "older"]); + expect(events[2]?.snapshot?.content?.[0]?.text).toBe("repaired"); + expect(events[2]?.snapshot?.metadata?.event_status).toBe("completed"); + } finally { + clearTimeout(guard); + abort.abort(); + await stream.return?.(); + } +}); + +for (const scenario of ["auth", "malformed"] as const) { + test(`history recovery does not retry ${scenario} responses or expose their contents`, async () => { + let requests = 0; + const source = feed(); + setDefaultFetch(async (input) => { + requests++; + if (url(input).pathname.endsWith("/stream")) return source.response; + return scenario === "auth" + ? new Response("provider-secret", { status: 403 }) + : new Response("invalid secret JSON"); + }); + const error = await iterator({ event_format: "snapshot", after_id: "marker", reconnect: true }) + .next() + .catch((value) => value); + expect(error).toMatchObject({ code: scenario === "auth" ? "http" : "protocol", retryable: false }); + expect(String(error)).not.toContain("secret"); + expect(requests).toBe(2); + expect(source.cancelled()).toBe(true); + }); +} + +test("abort interrupts history even when the injected fetch ignores AbortSignal", async () => { + const source = feed(); + let querying!: () => void; + const historyStarted = new Promise((resolve) => { + querying = resolve; + }); + setDefaultFetch(async (input) => { + if (url(input).pathname.endsWith("/stream")) return source.response; + querying(); + return new Promise(() => {}); + }); + const abort = new AbortController(); + const pending = iterator({ event_format: "snapshot", after_id: "marker", signal: abort.signal }).next(); + await historyStarted; + abort.abort(); + await expect(pending).rejects.toMatchObject({ name: "AbortError" }); + expect(source.cancelled()).toBe(true); +}); diff --git a/packages/sdk/tests/unit/bailian-subagent-tool-permissions.test.ts b/packages/sdk/tests/unit/bailian-subagent-tool-permissions.test.ts new file mode 100644 index 0000000..3dbb9da --- /dev/null +++ b/packages/sdk/tests/unit/bailian-subagent-tool-permissions.test.ts @@ -0,0 +1,69 @@ +import { describe, expect, test } from "bun:test"; +import { collectConfigReferences, validateProjectConfig } from "../../src/internal/core/validate-config.ts"; +import { buildPlan } from "../../src/internal/planner/planner.ts"; +import type { AgentDecl, AgentToolsDecl, ProjectConfig } from "../../src/internal/types/config.ts"; + +function configuration(tools: AgentToolsDecl, self = false): ProjectConfig { + const member: AgentDecl = { model: "auto", instructions: "Worker", tools }; + return { + version: "1", + providers: { bailian: {}, qoder: {} }, + defaults: { provider: "bailian" }, + agents: { + lead: { + model: "auto", + instructions: "Coordinator", + ...(self ? { tools } : {}), + multiagent: { type: "coordinator", agents: self ? [{ type: "self" }] : ["worker"] }, + }, + ...(!self ? { worker: member } : {}), + }, + }; +} + +describe("百炼子 Agent 的有效工具审批校验", () => { + test.each([ + { builtin: ["bash"], default_permission: "ask" }, + { builtin: ["bash"], permissions: { Bash: "ask" } }, + ] satisfies AgentToolsDecl[])("拒绝成员工具的有效 ask 策略:%j", (tools) => { + const diagnostics = validateProjectConfig(configuration(tools)); + expect(diagnostics).toContainEqual( + expect.objectContaining({ + severity: "error", + code: "bailian.agent.multiagent.tool_permissions.unsupported", + resource: { type: "agent", name: "lead", provider: "bailian" }, + }), + ); + expect(diagnostics.find((item) => item.code.includes("multiagent.tool_permissions"))?.message).toContain("worker"); + }); + + test("Self 作为子 Agent 委派时同样拒绝有效 ask", () => { + const diagnostics = validateProjectConfig(configuration({ builtin: ["bash"], default_permission: "ask" }, true)); + expect(diagnostics.map((item) => item.code)).toContain("bailian.agent.multiagent.tool_permissions.unsupported"); + }); + + test.each([ + { builtin: ["bash"], default_permission: "ask", permissions: { Bash: "allow" } }, + { builtin: [], default_permission: "ask" }, + { builtin: ["bash"] }, + ] satisfies AgentToolsDecl[])("允许实际不需审批的成员:%j", (tools) => { + expect(validateProjectConfig(configuration(tools))).toEqual([]); + }); + + test("主 Agent 可审批,Provider 过滤与仅引用校验保持独立", () => { + const config = configuration({ builtin: ["bash"], permissions: { bash: "ask" } }); + expect(validateProjectConfig(config, { providers: ["qoder"] })).toEqual([]); + expect(collectConfigReferences(config)).toEqual([]); + config.agents!.lead!.multiagent = undefined; + expect(validateProjectConfig(config)).toEqual([]); + }); + + test("plan 对实际存在的成员生成阻断诊断", async () => { + const config = configuration({ builtin: ["bash"], permissions: { bash: "ask" } }); + const plan = await buildPlan(config, { resources: [] }); + expect(plan.actions.map((action) => action.address.name).sort()).toEqual(["lead", "worker"]); + expect(plan.diagnostics).toContainEqual( + expect.objectContaining({ severity: "error", code: "bailian.agent.multiagent.tool_permissions.unsupported" }), + ); + }); +}); diff --git a/packages/sdk/tests/unit/bailian-tool-permissions.test.ts b/packages/sdk/tests/unit/bailian-tool-permissions.test.ts new file mode 100644 index 0000000..3a3e25f --- /dev/null +++ b/packages/sdk/tests/unit/bailian-tool-permissions.test.ts @@ -0,0 +1,193 @@ +import { afterEach, describe, expect, test } from "bun:test"; +import { validateProjectConfig } from "../../src/internal/core/validate-config.ts"; +import { resolveProjectConfigFromObject } from "../../src/internal/parser/index.ts"; +import { BailianAdapter } from "../../src/internal/providers/bailian/adapter.ts"; +import { setDefaultFetch } from "../../src/internal/transport.ts"; +import type { AgentDecl, ProjectConfig } from "../../src/internal/types/config.ts"; +import "../../src/internal/providers/bailian/index.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +const adapter = () => new BailianAdapter("sk-fixture", undefined, "https://provider.example.test/api/v1/agentstudio"); +const refs = { skill_ids: [] }; + +describe("Bailian builtin-tool approval contract", () => { + test.each([ + "allow", + "ask", + ] as const)("validates and sends default %s with tool overrides on create and update", async (permission) => { + const override = permission === "ask" ? "allow" : "ask"; + const agent: AgentDecl = { + model: "qwen3.7-max", + instructions: "Approval test", + tools: { + builtin: ["read", "write"], + default_permission: permission, + permissions: { Read: override }, + }, + }; + const config: ProjectConfig = { + version: "1", + providers: { bailian: {} }, + defaults: { provider: "bailian" }, + agents: { assistant: agent }, + }; + expect(validateProjectConfig(config).filter((item) => item.severity === "error")).toEqual([]); + const posts: Record[] = []; + setDefaultFetch(async (_input, init) => { + if (!init?.method || init.method === "GET") return Response.json({ id: "agent_test", version: 1 }); + const body = JSON.parse(String(init.body)) as Record; + posts.push(body); + return Response.json({ ...body, id: "agent_test", version: 2 }); + }); + const provider = adapter(); + await provider.createAgent("assistant", agent, refs); + await provider.updateAgent("agent_test", "assistant", agent, refs); + expect(posts).toHaveLength(2); + for (const body of posts) { + expect(body.tools).toEqual([ + { + type: "builtin_toolkit", + default_config: { enabled: false, permission_policy: { type: `always_${permission}` } }, + configs: [ + { name: "read", enabled: true, permission_policy: { type: `always_${override}` } }, + { name: "write", enabled: true }, + ], + }, + ]); + } + expect(posts[1]?.version).toBe(1); + const desired = provider.normalizeDesiredResource("agent", "assistant", agent, refs); + const noOverride = provider.normalizeDesiredResource( + "agent", + "assistant", + { + ...agent, + tools: { builtin: ["read", "write"], default_permission: permission }, + }, + refs, + ); + expect(desired).not.toEqual(noOverride); + const explicit = provider.normalizeDesiredResource( + "agent", + "assistant", + { + ...agent, + tools: { ...agent.tools!, permissions: { Read: override, write: permission } }, + }, + refs, + ); + expect(desired).toEqual(explicit); + }); + + test.each([ + { defaultPermission: "ask", permissions: { bash: "allow" } }, + { defaultPermission: "allow", permissions: { bash: "ask" } }, + { defaultPermission: undefined, permissions: { bash: "ask" } }, + ] as const)("导出并再次发布保留默认策略和单工具覆盖:%j", async ({ defaultPermission, permissions }) => { + const original: AgentDecl = { + model: "auto", + instructions: "Approval round trip", + tools: { builtin: ["read", "bash"], default_permission: defaultPermission, permissions }, + }; + let remote: Record; + const published: Record[] = []; + setDefaultFetch(async (_input, init) => { + if (!init?.method || init.method === "GET") return Response.json({ data: [remote] }); + const body = JSON.parse(String(init.body)) as Record; + published.push(body); + remote = { ...body, id: "agent_fixture", version: 1 }; + return Response.json(remote); + }); + const provider = adapter(); + await provider.createAgent("assistant", original, refs); + const [exported] = await provider.exportResources("agent"); + const loaded = await resolveProjectConfigFromObject( + { version: "1", providers: { bailian: {} }, agents: { assistant: exported!.decl } }, + { projectName: "approval-round-trip", resolveEnv: false }, + ); + const restored = loaded.config.agents!.assistant!; + expect(restored.tools).toEqual(original.tools); + await provider.createAgent("assistant", restored, refs); + expect(published[1]?.tools).toEqual(published[0]?.tools); + }); + + test("导出保留显式禁用全部工具,不把禁用项的审批覆盖重新启用", async () => { + setDefaultFetch(async () => + Response.json({ + data: [ + { + id: "agent_fixture", + name: "assistant", + model: { id: "auto" }, + system: "", + tools: [ + { + type: "builtin_toolkit", + default_config: { enabled: false, permission_policy: { type: "always_ask" } }, + configs: [{ name: "bash", enabled: false, permission_policy: { type: "always_allow" } }], + }, + ], + }, + ], + }), + ); + const [exported] = await adapter().exportResources("agent"); + expect(exported?.decl.tools).toEqual({ builtin: [], default_permission: "ask" }); + }); + + test("无法枚举默认启用的工具时,拒绝有损导出审批策略", async () => { + setDefaultFetch(async () => + Response.json({ + data: [ + { + id: "agent_fixture", + name: "assistant", + model: { id: "auto" }, + system: "", + tools: [ + { + type: "builtin_toolkit", + default_config: { enabled: true, permission_policy: { type: "always_ask" } }, + configs: [], + }, + ], + }, + ], + }), + ); + await expect(adapter().exportResources("agent")).rejects.toThrow("sync.agent.tool_permissions.implicit_tools"); + }); + + test("keeps allow-only baselines unchanged and detects remote approval drift", async () => { + const provider = adapter(); + const agent: AgentDecl = { model: "qwen3.7-max", instructions: "", tools: { builtin: ["read"] } }; + const desired = provider.normalizeDesiredResource("agent", "assistant", agent, refs) as Record; + expect(desired.tools).toEqual({ builtin: ["read"] }); + const readComparable = async (toolkit: Record) => { + setDefaultFetch(async () => + Response.json({ + id: "agent_test", + name: "assistant", + model: { id: "qwen3.7-max" }, + system: "", + tools: [toolkit], + }), + ); + return (await provider.readComparableResource("agent", "agent_test", "assistant"))?.comparable; + }; + const allowed = await readComparable({ type: "builtin_toolkit", configs: [{ name: "read", enabled: true }] }); + const explicit = await readComparable({ + type: "builtin_toolkit", + default_config: { permission_policy: { type: "always_ask" } }, + configs: [{ name: "read", enabled: true, permission_policy: { type: "always_allow" } }], + }); + expect(allowed).toEqual(explicit); + const approval = await readComparable({ + type: "builtin_toolkit", + default_config: { permission_policy: { type: "always_ask" } }, + configs: [{ name: "read", enabled: true }], + }); + expect(approval).not.toEqual(allowed); + }); +}); diff --git a/packages/sdk/tests/unit/bailian-usage.test.ts b/packages/sdk/tests/unit/bailian-usage.test.ts new file mode 100644 index 0000000..2c7a7e3 --- /dev/null +++ b/packages/sdk/tests/unit/bailian-usage.test.ts @@ -0,0 +1,139 @@ +import { afterEach, expect, test } from "bun:test"; +import { createManagedApiContext, listModelUsage, listToolUsage } from "../../src/index.ts"; +import { type FetchLike, setDefaultFetch } from "../../src/internal/transport.ts"; +import type { UsageScope } from "../../src/internal/types/usage.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +const baseUrl = "https://bailian.test/api/v1/agentstudio"; +const context = () => createManagedApiContext({ providers: { bailian: { api_key: "test", base_url: baseUrl } } }); + +const workspaceScope: UsageScope = { type: "workspace", workspace_ids: ["ws_one"] }; +const timeRange = { start_time: 1791730260000, end_time: 1792335080000 }; + +const modelPage = { + items: [ + { + workspace_id: "ws_one", + model_name: "qwen3-max", + call_count: 14, + failed_count: 2, + tokens: { + input_tokens: 268080, + output_tokens: 7506, + cache_read_tokens: 164000, + cache_creation_tokens: 0, + total_tokens: 275500, + cache_hit_ratio: 0.61194, + }, + }, + ], + total: 1, + total_call_count: 14, + page_no: 1, + page_size: 20, + data_updated_at: 1792328000000, +}; + +const toolPage = { + items: [{ workspace_id: "ws_one", tool_name: "file-parser", source: "mcp", call_count: 4, failed_count: 2 }], + total: 1, + total_call_count: 6, + page_no: 1, + page_size: 20, + data_updated_at: 1792328000000, +}; + +function urlOf(input: Parameters[0]) { + return new URL(input instanceof Request ? input.url : input.toString()); +} + +test("model usage posts a top-level body on the resource path and unwraps the data page", async () => { + let path = ""; + const bodies: unknown[] = []; + setDefaultFetch(async (input, init) => { + path = urlOf(input).pathname; + bodies.push(JSON.parse(String(init?.body ?? "{}"))); + return Response.json({ data: modelPage }); + }); + const page = await listModelUsage(context(), { + scope: workspaceScope, + time_range: timeRange, + page_no: 2, + page_size: 50, + sort_by: "input_tokens", + sort_order: "asc", + }); + expect(path).toBe("/api/v1/agentstudio/usage/models"); + expect(page).toEqual(modelPage); + expect(bodies[0]).toEqual({ + scope: workspaceScope, + time_range: timeRange, + page_no: 2, + page_size: 50, + sort_by: "input_tokens", + sort_order: "asc", + }); +}); + +test("tool usage forwards source/tool filters and tolerates a bare page without the data envelope", async () => { + let path = ""; + let body: Record | undefined; + setDefaultFetch(async (input, init) => { + path = urlOf(input).pathname; + body = JSON.parse(String(init?.body ?? "{}")); + return Response.json(toolPage); + }); + const page = await listToolUsage(context(), { + scope: { type: "agent", agent_id: "agent_one" }, + time_range: timeRange, + source: "mcp", + tool_name: "file-parser", + }); + expect(path).toBe("/api/v1/agentstudio/usage/tools"); + expect(body).toEqual({ + scope: { type: "agent", agent_id: "agent_one" }, + time_range: timeRange, + source: "mcp", + tool_name: "file-parser", + }); + expect(page).toEqual(toolPage); +}); + +test("usage requests reject cross-field violations before any HTTP call", async () => { + let requests = 0; + setDefaultFetch(async () => { + requests += 1; + return Response.json({ data: modelPage }); + }); + const ctx = context(); + await expect( + listModelUsage(ctx, { scope: { type: "session", session_id: "sesn_one" }, time_range: timeRange }), + ).rejects.toThrow("forbids time_range"); + await expect(listModelUsage(ctx, { scope: { type: "agent", agent_id: "agent_one" } })).rejects.toThrow( + "requires time_range", + ); + await expect( + listModelUsage(ctx, { scope: { type: "workspace", workspace_ids: [] }, time_range: timeRange }), + ).rejects.toThrow("non-empty workspace_ids"); + await expect(listToolUsage(ctx, { scope: workspaceScope, time_range: timeRange, page_size: 101 })).rejects.toThrow( + "between 1 and 100", + ); + expect(requests).toBe(0); +}); + +test("unsupported providers reject usage operations before making a request", async () => { + const ctx = createManagedApiContext({ providers: { claude: { api_key: "test" } } }); + let requests = 0; + setDefaultFetch(async () => { + requests += 1; + return Response.json({ data: modelPage }); + }); + await expect(listModelUsage(ctx, { scope: workspaceScope, time_range: timeRange })).rejects.toThrow( + "does not support model usage listing", + ); + await expect(listToolUsage(ctx, { scope: workspaceScope, time_range: timeRange })).rejects.toThrow( + "does not support tool usage listing", + ); + expect(requests).toBe(0); +}); diff --git a/packages/sdk/tests/unit/bailian-webhook.test.ts b/packages/sdk/tests/unit/bailian-webhook.test.ts index f33902e..02e6314 100644 --- a/packages/sdk/tests/unit/bailian-webhook.test.ts +++ b/packages/sdk/tests/unit/bailian-webhook.test.ts @@ -260,7 +260,11 @@ describe("Bailian webhook wire contract", () => { expect(calls).toHaveLength(1); expect(calls[0]?.url).toBe(`${BASE_URL}${scenario.path}`); expect(calls[0]?.init?.method).toBe(scenario.method); - expect(calls[0]?.init?.headers).toEqual({ "Content-Type": "application/json", Authorization: "Bearer sk-test" }); + expect(calls[0]?.init?.headers).toEqual({ + "Content-Type": "application/json", + Authorization: "Bearer sk-test", + "x-dashscope-agentstudio-source-config": "openagentpack", + }); expect(calls[0]?.init?.signal).toBe(controller.signal); expect(calls[0]?.init?.body).toBe(scenario.body === undefined ? undefined : JSON.stringify(scenario.body)); }); diff --git a/packages/sdk/tests/unit/bailian.test.ts b/packages/sdk/tests/unit/bailian.test.ts index 17f361b..12bd574 100644 --- a/packages/sdk/tests/unit/bailian.test.ts +++ b/packages/sdk/tests/unit/bailian.test.ts @@ -1,5 +1,6 @@ import { afterEach, describe, expect, test } from "bun:test"; import { BailianAdapter } from "../../src/internal/providers/bailian/adapter.ts"; +import { BailianClient } from "../../src/internal/providers/bailian/client.ts"; import { bailianConfigSchema } from "../../src/internal/providers/bailian/config.ts"; import { mapAgent, mapEnvironment, mapInitialEvents, mapSession } from "../../src/internal/providers/bailian/mapper.ts"; import type { ResolvedAgentRefs } from "../../src/internal/providers/interface.ts"; @@ -54,6 +55,23 @@ describe("bailianConfigSchema", () => { }); }); +describe("BailianClient source-config header", () => { + test("every MA request carries x-dashscope-agentstudio-source-config", async () => { + const client = new BailianClient({ apiKey: "sk-test", baseUrl: "https://bailian.test/api/v1/agentstudio" }); + const captured: Headers[] = []; + globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => { + captured.push(new Headers(init?.headers)); + return Response.json({ id: "agent_x", name: "Agents/x" }); + }) as typeof fetch; + + await client.get("/agents/agent_x"); + + expect(captured).toHaveLength(1); + expect(captured[0]?.get("x-dashscope-agentstudio-source-config")).toBe("openagentpack"); + expect(captured[0]?.get("Authorization")).toBe("Bearer sk-test"); + }); +}); + describe("BailianAdapter archived agents", () => { test("does not treat an archived agent id as an updatable resource", async () => { const adapter = new BailianAdapter("sk-test", "ws-test", "https://bailian.test/api/v1/agentstudio"); diff --git a/packages/sdk/tests/unit/multiagent-comparable.test.ts b/packages/sdk/tests/unit/multiagent-comparable.test.ts index f2de102..310bdc7 100644 --- a/packages/sdk/tests/unit/multiagent-comparable.test.ts +++ b/packages/sdk/tests/unit/multiagent-comparable.test.ts @@ -10,6 +10,15 @@ function roster(members: ResolvedMultiagentRoster["members"]): ResolvedMultiagen } describe("canonicalizeDesiredRoster", () => { + test("keeps native Self separate from an external member whose id is self", () => { + const desired = canonicalizeDesiredRoster( + roster([{ type: "self" }, { resource_type: "agent", remote_id: "self" }]), + ); + expect(desired).toEqual({ type: "coordinator", member_ids: ["self"], self: true }); + const raw = { type: "coordinator", agents: [{ type: "self" }, { type: "agent", id: "self" }] }; + expect(canonicalizeRemoteRoster(raw, "managed", true)).toEqual({ supported: true, roster: desired }); + expect(canonicalizeRemoteRoster(raw, "forward", true)).toEqual({ supported: false }); + }); test("emits sorted unique member ids", () => { const canonical = canonicalizeDesiredRoster( roster([ @@ -27,6 +36,20 @@ describe("canonicalizeDesiredRoster", () => { }); describe("canonicalizeRemoteRoster", () => { + test("Bailian Self accepts unset null identity placeholders but refuses real identity overrides", () => { + const remote = (member: unknown) => + canonicalizeRemoteRoster({ type: "coordinator", agents: [member] }, "managed", true); + expect(remote({ type: "self", id: null, version: null })).toEqual({ + supported: true, + roster: { type: "coordinator", member_ids: [], self: true }, + }); + for (const member of [ + { type: "self", id: "agent_other" }, + { type: "self", version: 1 }, + { type: "self", unknown: null }, + ]) + expect(remote(member)).toEqual({ supported: false }); + }); test("managed reads id and ignores remote member versions", () => { const result = canonicalizeRemoteRoster( { diff --git a/packages/sdk/tests/unit/multiagent-resolver.test.ts b/packages/sdk/tests/unit/multiagent-resolver.test.ts index 2c592bb..f6e33a3 100644 --- a/packages/sdk/tests/unit/multiagent-resolver.test.ts +++ b/packages/sdk/tests/unit/multiagent-resolver.test.ts @@ -168,7 +168,9 @@ describe("materialization-aware reference resolution", () => { const refs = resolveTemplateRefs("lead", forwardConfig, "qoder", state); - expect(refs.multiagent?.members.every((member) => member.resource_type === "template")).toBe(true); + expect(refs.multiagent?.members.every((member) => !("type" in member) && member.resource_type === "template")).toBe( + true, + ); expect(refs.environment_id).toBe("env_dev"); }); }); diff --git a/packages/sdk/tests/unit/multiagent-self.test.ts b/packages/sdk/tests/unit/multiagent-self.test.ts new file mode 100644 index 0000000..d1a90a0 --- /dev/null +++ b/packages/sdk/tests/unit/multiagent-self.test.ts @@ -0,0 +1,119 @@ +import { afterEach, describe, expect, it } from "bun:test"; +import { mkdtemp, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { + createProjectRuntime, + executePlannedProject, + planProjectContext, + resolveProjectConfigFromObject, + StateManager, + setDefaultFetch, + validateProjectConfig, +} from "../../src/index.ts"; + +const roots: string[] = []; +afterEach(async () => { + setDefaultFetch(undefined); + await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }))); +}); + +const configuration = (agents: unknown[], provider = "bailian") => ({ + version: "1", + project: "sdk-self-contract", + providers: { + [provider]: { api_key: "unit-provider-key", base_url: "https://provider.example.test/api/v1/agentstudio" }, + }, + agents: { + coordinator: { name: "协调者", model: "auto", instructions: "", multiagent: { type: "coordinator", agents } }, + }, +}); +const resolve = (agents: unknown[], provider = "bailian") => + resolveProjectConfigFromObject(configuration(agents, provider), { + projectName: "sdk-self-contract", + resolveEnv: false, + }); + +describe("Bailian 原生 Self 的公开 SDK 合同", () => { + it("Self 单独使用可校验,不是普通 Agent 的自引用或额外资源", async () => { + const loaded = await resolve([{ type: "self" }]); + expect(validateProjectConfig(loaded.config).filter((item) => item.severity === "error")).toEqual([]); + expect(loaded.config.agents?.coordinator?.multiagent?.agents).toEqual([{ type: "self" }]); + const ordinarySelfReference = await resolve(["coordinator"]); + expect(validateProjectConfig(ordinarySelfReference.config).map((item) => item.code)).toContain( + "config.agent.multiagent.self", + ); + }); + it.each( + [ + [{ type: "self" }, { type: "self" }], + [{ type: "self", id: "agent_other" }], + [{ type: "self", agent_id: "agent_other" }], + [{ type: "self", version: 2 }], + ].map((agents) => ({ agents })), + )("拒绝重复或携带其他身份/版本的 Self:%j", async ({ agents }) => { + await expect(resolve(agents)).rejects.toThrow(); + }); + it.each(["qoder", "claude", "ark"])("%s 不支持未经验证的 Self 能力", async (provider) => { + const loaded = await resolve([{ type: "self" }], provider); + expect(validateProjectConfig(loaded.config).map((item) => item.code)).toContain( + `${provider}.agent.multiagent.self.unsupported`, + ); + }); + it("计划不写远端,发布发送原生 Self;回读、导出无损且无漂移,移除 Self 后可更新", async () => { + const root = await mkdtemp(join(tmpdir(), "kit-sdk-self-")); + roots.push(root); + const loaded = await resolve([{ type: "self" }, { agent_id: "agent_existing" }]); + const state = StateManager.initialize(join(root, "state.json")); + const context = createProjectRuntime({ projectName: loaded.projectName, config: loaded.config, state }); + let remote: Record | undefined; + const writes: { method: string; path: string; body: Record }[] = []; + setDefaultFetch(async (input, init) => { + const url = new URL(String(input)); + const method = init?.method ?? "GET"; + if (method !== "GET") { + const body = JSON.parse(String(init?.body)) as Record; + writes.push({ method, path: url.pathname, body }); + remote = { ...body, id: "agent_root", version: writes.length }; + return Response.json(remote); + } + if (url.pathname.endsWith("/agents")) + return Response.json({ + data: [remote, { id: "agent_existing", name: "外部成员", model: { id: "auto" }, system: "" }].filter(Boolean), + }); + if (url.pathname.endsWith("/agents/agent_root")) return Response.json(remote); + throw new Error(`Unexpected SDK request: ${method} ${url.pathname}`); + }); + + const planned = await planProjectContext(context, { refresh: false }); + expect(planned.plan.diagnostics.filter((item) => item.severity === "error")).toEqual([]); + expect(planned.plan.actions.map((action) => ({ action: action.action, name: action.address.name }))).toEqual([ + { action: "create", name: "coordinator" }, + ]); + expect(writes).toHaveLength(0); + await executePlannedProject(planned); + expect(writes).toHaveLength(1); + expect(writes[0]?.body.multiagent).toEqual({ + type: "coordinator", + agents: [{ type: "self" }, { type: "agent", id: "agent_existing" }], + }); + expect(state.listResources().map((resource) => resource.address.name)).toEqual(["coordinator"]); + + const unchanged = await planProjectContext(context, { refresh: true }); + expect(unchanged.plan.actions.map((action) => action.action)).toEqual(["no-op"]); + const exported = await context.providers.get("bailian")!.exportResources!("agent"); + expect(exported.map((entry) => entry.decl.multiagent)).toContainEqual( + loaded.config.agents?.coordinator?.multiagent, + ); + + context.config.agents!.coordinator!.multiagent!.agents = [{ agent_id: "agent_existing" }]; + const removal = await planProjectContext(context, { refresh: true }); + expect(removal.plan.actions.map((action) => action.action)).toEqual(["update"]); + await executePlannedProject(removal); + expect(writes).toHaveLength(2); + expect(writes[1]?.body.multiagent).toEqual({ + type: "coordinator", + agents: [{ type: "agent", id: "agent_existing" }], + }); + }); +}); diff --git a/packages/sdk/tests/unit/project-versions.test.ts b/packages/sdk/tests/unit/project-versions.test.ts index d78db4d..eb1f5de 100644 --- a/packages/sdk/tests/unit/project-versions.test.ts +++ b/packages/sdk/tests/unit/project-versions.test.ts @@ -109,14 +109,19 @@ describe("shared project versions", () => { test("keeps the version store invisible to an enclosing Git worktree", async () => { const root = await temporaryDirectory(); const configPath = join(root, "agents.yaml"); + // Git hooks export repository-local variables; this fixture owns a different repository. + const { stdout: localEnvironmentKeys } = await execFileAsync("git", ["rev-parse", "--local-env-vars"]); + const env = { ...process.env }; + for (const key of localEnvironmentKeys.trim().split("\n")) delete env[key]; + const gitOptions = { cwd: root, env }; await writeFile(configPath, projectYaml("Initial")); - await execFileAsync("git", ["init", "--initial-branch", "main"], { cwd: root }); - await execFileAsync("git", ["add", "--", "agents.yaml"], { cwd: root }); - const before = await execFileAsync("git", ["status", "--porcelain=v1"], { cwd: root }); + await execFileAsync("git", ["init", "--initial-branch", "main"], gitOptions); + await execFileAsync("git", ["add", "--", "agents.yaml"], gitOptions); + const before = await execFileAsync("git", ["status", "--porcelain=v1"], gitOptions); await enableProjectVersioning(configPath, "Baseline"); - const after = await execFileAsync("git", ["status", "--porcelain=v1"], { cwd: root }); + const after = await execFileAsync("git", ["status", "--porcelain=v1"], gitOptions); expect(after.stdout).toBe(before.stdout); expect(after.stdout).not.toContain(".openagentpack"); }); diff --git a/packages/sdk/tests/unit/redaction.test.ts b/packages/sdk/tests/unit/redaction.test.ts index 1326b7b..c1fa947 100644 --- a/packages/sdk/tests/unit/redaction.test.ts +++ b/packages/sdk/tests/unit/redaction.test.ts @@ -31,4 +31,47 @@ describe("redactSensitiveText", () => { expect(output).not.toContain("LTAI5tABCDEFGHIJKLMNOP"); expect(output).toContain("[redacted]"); }); + + test("preserves only the destination when a signed URL also appears in the label", () => { + const output = redactSensitiveText(`[${SIGNED_OSS_URL}](${SIGNED_OSS_URL})`); + expect(output).toEndWith(`](${SIGNED_OSS_URL})`); + const label = output.slice(0, output.length - SIGNED_OSS_URL.length - 3); + expect(label).not.toContain("LTAI5tPxpiCM2hjmWrFXrym1"); + expect(label).not.toContain("Z35W3GbIYmvq2UH6iBF"); + expect(label).toContain("[redacted]"); + }); + + test("keeps adjacent image and download destinations while redacting ordinary links and labels", () => { + const image = "https://cdn.example.test/render?token=image-secret"; + const document = "https://cdn.example.test/report.pdf?signature=document-secret"; + const ordinary = "https://example.test/api?token=ordinary-secret"; + const output = redactSensitiveText(`![token=label-secret](${image})[PDF](${document})[API](${ordinary})`); + expect(output).toContain(`![token: [redacted]](${image})[PDF](${document})`); + expect(output).not.toContain("label-secret"); + expect(output).not.toContain("ordinary-secret"); + }); + + test("recovers later Markdown labels without preserving malformed destinations", () => { + const nested = `[](http://[label with spaces](${SIGNED_OSS_URL})`; + expect(redactSensitiveText(nested)).toBe(nested); + const input = `[broken](https://example.test/api?token=broken-secret [valid](${SIGNED_OSS_URL})`; + const output = redactSensitiveText(input); + expect(output).not.toContain("broken-secret"); + expect(output).toEndWith(`[valid](${SIGNED_OSS_URL})`); + const invalidNestedLabel = `[outer [inner]](${SIGNED_OSS_URL})`; + expect(redactSensitiveText(invalidNestedLabel)).not.toContain("LTAI5tPxpiCM2hjmWrFXrym1"); + }); + + test.each(["[", "[](http://"])("handles long malformed Markdown beginning with %s", (fragment) => { + const prefix = fragment.repeat(32_768); + expect(redactSensitiveText(`${prefix} token=trailing-secret`)).toBe(`${prefix} token: [redacted]`); + }); + + test("preserves many complete media destinations in one redaction pass", () => { + const input = Array.from( + { length: 4096 }, + (_, index) => `[${index}](https://example.test/${index}.png?token=keep)`, + ).join(""); + expect(redactSensitiveText(input)).toBe(input); + }); }); diff --git a/packages/sdk/tests/unit/remote-agent-abort.test.ts b/packages/sdk/tests/unit/remote-agent-abort.test.ts new file mode 100644 index 0000000..5ea82ce --- /dev/null +++ b/packages/sdk/tests/unit/remote-agent-abort.test.ts @@ -0,0 +1,60 @@ +import { expect, test } from "bun:test"; +import { + createProjectRuntime, + getRemoteAgent, + resolveProjectConfigFromObject, + StateManager, + setDefaultFetch, +} from "../../src/index.ts"; + +test("Bailian Agent name lookup cancels the in-flight HTTP request and rejects pre-aborted work", async () => { + let arrived!: () => void; + const started = new Promise((resolve) => { + arrived = resolve; + }); + let release!: (value: Response) => void; + const response = new Promise((resolve) => { + release = resolve; + }); + const paths: string[] = []; + const server = Bun.serve({ + hostname: "127.0.0.1", + port: 0, + fetch(request) { + const url = new URL(request.url); + paths.push(`${url.pathname}${url.search}`); + arrived(); + return response; + }, + }); + setDefaultFetch(undefined); + try { + const loaded = await resolveProjectConfigFromObject( + { + version: "1", + providers: { + bailian: { api_key: "unit-test", base_url: `http://127.0.0.1:${server.port}/api/v1/agentstudio` }, + }, + agents: {}, + }, + { projectName: "remote-agent-abort" }, + ); + const context = createProjectRuntime({ + ...loaded, + state: StateManager.initialize("/tmp/unused-remote-agent-abort-state.json"), + }); + const abort = new AbortController(); + const pending = getRemoteAgent(context, "agent_worker", { version: 3, signal: abort.signal }); + await started; + abort.abort(); + await expect(pending).rejects.toMatchObject({ name: "AbortError" }); + await expect(getRemoteAgent(context, "agent_worker", { signal: abort.signal })).rejects.toMatchObject({ + name: "AbortError", + }); + expect(paths).toEqual(["/api/v1/agentstudio/agents/agent_worker?version=3"]); + } finally { + release(Response.json({ id: "agent_worker", name: "Worker" })); + await server.stop(true); + setDefaultFetch(undefined); + } +}); diff --git a/packages/sdk/tests/unit/resolve-from-object.test.ts b/packages/sdk/tests/unit/resolve-from-object.test.ts index 2d4f566..cd7c287 100644 --- a/packages/sdk/tests/unit/resolve-from-object.test.ts +++ b/packages/sdk/tests/unit/resolve-from-object.test.ts @@ -110,6 +110,40 @@ test("file-based resolution includes the root agents.yaml source", async () => { expect(loaded.sourcePaths).toContain(loaded.configPath); }); +test("literal text preserves path-like prompts and memory without resolving files", async () => { + const basePath = await mkdtemp(join(tmpdir(), "openagentpack-literal-text-")); + try { + await writeFile(join(basePath, "prompt.md"), "file contents must not replace literal text"); + const raw = { + ...validRawConfig(), + agents: { designer: { ...validRawConfig().agents.designer, instructions: "./prompt.md" } }, + memory_stores: { notes: { description: "notes", entries: [{ key: "seed", content: `/literal \${VALUE}\n` }] } }, + files: { brief: { source: "./brief.txt" } }, + skills: { reviewer: { source: "./reviewer" } }, + }; + const loaded = await resolveProjectConfigFromObject(raw, { + projectName: "server", + basePath, + resolveEnv: false, + textFileReferences: "literal", + }); + expect(loaded.config.agents?.designer?.instructions).toBe("./prompt.md"); + expect(loaded.config.memory_stores?.notes?.entries?.[0]?.content).toBe(`/literal \${VALUE}\n`); + expect(loaded.sourcePaths).toEqual([join(basePath, "brief.txt"), join(basePath, "reviewer")]); + const defaults = await resolveProjectConfigFromObject( + { + ...validRawConfig(), + agents: raw.agents, + }, + { projectName: "server", basePath }, + ); + expect(defaults.config.agents?.designer?.instructions).toBe("file contents must not replace literal text"); + expect(defaults.sourcePaths).toEqual([join(basePath, "prompt.md")]); + } finally { + await rm(basePath, { recursive: true, force: true }); + } +}); + test("rejects permission keys that do not identify an enabled builtin", async () => { const raw = validRawConfig(); (raw.agents.designer as Record).tools = { builtin: ["Read"], permissions: { Bash: "ask" } }; diff --git a/packages/sdk/tests/unit/resource-result-backend.test.ts b/packages/sdk/tests/unit/resource-result-backend.test.ts new file mode 100644 index 0000000..35bc333 --- /dev/null +++ b/packages/sdk/tests/unit/resource-result-backend.test.ts @@ -0,0 +1,89 @@ +import { afterEach, expect, test } from "bun:test"; +import { + InMemoryStateManager, + ResourceRuntimeError, + resolveProjectConfigFromObject, + type StateBackend, + setDefaultFetch, + syncProjectResourcesWithStateBackend, +} from "../../src/index.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +// Protect the public plan/apply/persist workflow when the backend's final commit +// fails after its callback has already finished mutating the Provider. +test.each([ + { resultDetail: "legacy", includeResource: true }, + { resultDetail: "structured", includeResource: true }, + { resultDetail: "structured", includeResource: false }, +] as const)("$resultDetail preserves a final backend commit failure (remote write: $includeResource)", async ({ + resultDetail, + includeResource, +}) => { + const loaded = await resolveProjectConfigFromObject( + { + version: "1", + providers: { + bailian: { api_key: "fixture", base_url: "https://fixture.invalid/api/v1/agentstudio" }, + }, + defaults: { provider: "bailian" }, + environments: includeResource ? { dev: { config: { type: "cloud" } } } : {}, + agents: {}, + }, + { projectName: "backend-contract", resolveEnv: false }, + ); + let created = false; + setDefaultFetch(async (input, init) => { + const request = new Request(input, init); + const path = new URL(request.url).pathname; + if (request.method === "POST" && path.endsWith("/environments")) { + created = true; + return Response.json({ id: "env_created", name: "dev", config: { type: "cloud" } }); + } + if (request.method === "GET" && path.endsWith("/environments/env_created")) { + return Response.json({ id: "env_created", name: "dev", config: { type: "cloud" } }); + } + throw new Error(`Unexpected fixture request: ${request.method} ${path}`); + }); + const commitFailure = new Error("backend commit unavailable"); + let commitAttempted = false; + const state = InMemoryStateManager.empty(); + const stateBackend: StateBackend = { + read: async (_scope, run) => run(state), + write: async (_scope, run) => { + await run(state); + commitAttempted = true; + throw commitFailure; + }, + }; + const result = await syncProjectResourcesWithStateBackend( + { + projectName: "backend-contract", + config: loaded.config, + stateBackend, + stateScope: { projectId: "backend-contract" }, + }, + { refresh: false, resultDetail }, + ).catch((error: unknown) => error); + + expect(created).toBe(includeResource); + expect(commitAttempted).toBe(true); + if (resultDetail === "legacy") { + expect(result).toBe(commitFailure); + return; + } + expect(result).toBeInstanceOf(ResourceRuntimeError); + const failure = result as ResourceRuntimeError; + expect(failure.cause).toBe(commitFailure); + expect(failure.info).toMatchObject({ + code: "resource.state_persist_failed", + phase: "persist_state", + mutationStarted: includeResource, + }); + expect(failure.execution).toMatchObject({ + outcome: includeResource ? "unknown" : "failed", + mutationStarted: includeResource, + partial: false, + results: includeResource ? [{ status: "success", resource: { remoteId: "env_created" } }] : [], + }); +}); diff --git a/packages/sdk/tests/unit/resource-result-contract.test.ts b/packages/sdk/tests/unit/resource-result-contract.test.ts new file mode 100644 index 0000000..4dbe987 --- /dev/null +++ b/packages/sdk/tests/unit/resource-result-contract.test.ts @@ -0,0 +1,259 @@ +import { afterEach, expect, test } from "bun:test"; +import { mkdtemp, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { + ApiError, + executePlannedProject, + InMemoryStateManager, + type ProjectRuntimeContext, + type ProviderAdapter, + planProjectContext, + ResourceRuntimeError, + resolveProjectConfigFromObject, + UserError, +} from "../../src/index.ts"; +import { resourcePlanFingerprint } from "../../src/internal/planner/plan-fingerprint.ts"; + +const temporary: string[] = []; +afterEach(async () => { + await Promise.all(temporary.splice(0).map((path) => rm(path, { recursive: true, force: true }))); +}); + +async function context(extra: Record = {}, overrides: Record = {}) { + const loaded = await resolveProjectConfigFromObject( + { + version: "1", + providers: { bailian: { api_key: "fixture-key" } }, + defaults: { provider: "bailian" }, + environments: { dev: { config: { type: "cloud" } } }, + agents: {}, + ...extra, + }, + { resolveEnv: false, textFileReferences: "literal" }, + ); + const state = InMemoryStateManager.fromJSON({ resources: [] }); + const provider = { + name: "bailian", + findResource: async () => null, + createEnvironment: async (name: string) => ({ id: `env_${name}`, name }), + createAgent: async (name: string) => ({ id: `agent_${name}`, name, version: 1 }), + ...overrides, + } as unknown as ProviderAdapter; + return { + projectName: "contract", + configPath: "/virtual/agents.yaml", + config: loaded.config, + state, + providers: new Map([["bailian", provider]]), + } as ProjectRuntimeContext; +} + +const plan = (runtime: ProjectRuntimeContext, structured = true) => + planProjectContext(runtime, { + provider: "bailian", + refresh: false, + ...(structured ? { resultDetail: "structured" as const } : {}), + }); + +test("default public shapes, legacy failure strings and original thrown errors stay unchanged", async () => { + const response = new ApiError(429, "original service failure", "Bailian API"); + const runtime = await context( + {}, + { + createEnvironment: async () => { + throw response; + }, + }, + ); + const planned = await plan(runtime, false); + expect(Object.hasOwn(planned, "fingerprint")).toBe(false); + const execution = await executePlannedProject(planned); + expect(Object.keys(execution)).toEqual(["results", "partial"]); + expect(Object.keys(execution.results[0]!)).toEqual(["action", "status", "error"]); + expect(execution.results[0]!.error).toBe(response.message); + expect(execution.partial).toBe(true); + const persistenceFailure = new Error("original storage error"); + const second = await context(); + second.state.save = async () => { + throw persistenceFailure; + }; + await expect(executePlannedProject(await plan(second, false))).rejects.toBe(persistenceFailure); + const blocked = await plan(await context(), false); + blocked.destructiveActions = [{ ...blocked.plan.actions[0]!, action: "delete" }]; + await expect(executePlannedProject(blocked)).rejects.toBeInstanceOf(UserError); +}); + +test("structured success reports resource identities and a stable semantic plan fingerprint", async () => { + const runtime = await context(); + const planned = await plan(runtime); + expect(planned.fingerprint).toMatch(/^resource-plan-v1:[a-f0-9]{64}$/); + const changedText = { + ...planned, + plan: { + ...planned.plan, + actions: planned.plan.actions.map((action) => ({ ...action, reason: "localized message" })), + }, + }; + expect(resourcePlanFingerprint(changedText)).toBe(planned.fingerprint!); + const changedTarget = { + ...planned, + plan: { + ...planned.plan, + actions: planned.plan.actions.map((action) => ({ ...action, after: { content_hash: "different" } })), + }, + }; + expect(resourcePlanFingerprint(changedTarget)).not.toBe(planned.fingerprint!); + const execution = await executePlannedProject(planned, { resultDetail: "structured" }); + expect(execution).toMatchObject({ + outcome: "succeeded", + mutationStarted: true, + partial: false, + results: [{ status: "success", resource: { remoteId: "env_dev" } }], + }); + const fingerprint = resourcePlanFingerprint(planned); + const resource = runtime.state.listResources()[0]!; + runtime.state.setResource({ + ...resource, + remote_snapshot: { timestamp: "unrelated", secret: "never in fingerprint" }, + }); + expect(resourcePlanFingerprint(planned)).toBe(fingerprint); + runtime.state.setResource({ ...resource, remote_id: "env_changed", version: 2 }); + expect(resourcePlanFingerprint(planned)).not.toBe(fingerprint); +}); + +test("preflight policy errors have an explicit no-mutation guarantee without changing legacy policy", async () => { + const planned = await plan(await context()); + planned.destructiveActions = [{ ...planned.plan.actions[0]!, action: "delete" }]; + try { + await executePlannedProject(planned, { resultDetail: "structured" }); + throw new Error("expected policy failure"); + } catch (error) { + expect(error).toBeInstanceOf(ResourceRuntimeError); + expect((error as ResourceRuntimeError).info).toMatchObject({ + code: "resource.policy_blocked", + phase: "prepare", + mutationStarted: false, + }); + } +}); + +test("write failures and dependent skips expose safe errors; HTTP retryability never authorizes replay", async () => { + const secret = "private-fixture-value"; + const runtime = await context( + { + agents: { + base: { model: "auto", instructions: "fixture", environment: "dev" }, + main: { model: "auto", instructions: "fixture", multiagent: { type: "coordinator", agents: ["base"] } }, + }, + }, + { + createAgent: async () => { + throw new ApiError(429, secret, "Bailian API"); + }, + }, + ); + const execution = await executePlannedProject(await plan(runtime), { resultDetail: "structured" }); + expect(execution.outcome).toBe("unknown"); + expect(execution.mutationStarted).toBe(true); + const failed = execution.results.find((result) => result.action.address.name === "base")!; + expect(failed.errorInfo).toMatchObject({ + code: "resource.provider_failed", + phase: "execute", + httpStatus: 429, + retryable: true, + mutationStarted: true, + }); + expect(JSON.stringify(failed.errorInfo)).not.toContain(secret); + expect(execution.results.find((result) => result.action.address.name === "main")).toMatchObject({ + status: "skipped", + errorInfo: { code: "resource.dependency_failed", mutationStarted: false }, + }); +}); + +test("a source lost after planning is a preparation failure while independent successful resources remain visible", async () => { + const directory = await mkdtemp(join(tmpdir(), "sdk-result-skill-")); + temporary.push(directory); + await writeFile( + join(directory, "SKILL.md"), + "---\nname: contract-skill\ndescription: fixture skill\n---\nUse fixture.\n", + ); + const runtime = await context({ skills: { review: { source: directory, origin: "custom" } } }); + const planned = await plan(runtime); + await rm(directory, { recursive: true }); + const execution = await executePlannedProject(planned, { resultDetail: "structured" }); + expect(execution.outcome).toBe("partial"); + expect(execution.results.find((result) => result.action.address.type === "environment")).toMatchObject({ + status: "success", + resource: { remoteId: "env_dev" }, + }); + expect(execution.results.find((result) => result.action.address.type === "skill")).toMatchObject({ + status: "failed", + errorInfo: { phase: "prepare", mutationStarted: false }, + }); +}); + +test("state persistence failure carries completed results and remains unknown after remote writes", async () => { + const runtime = await context(); + const original = new Error("storage unavailable"); + runtime.state.save = async () => { + throw original; + }; + try { + await executePlannedProject(await plan(runtime), { resultDetail: "structured" }); + throw new Error("expected persistence failure"); + } catch (error) { + expect(error).toBeInstanceOf(ResourceRuntimeError); + const failure = error as ResourceRuntimeError; + expect(failure.info).toMatchObject({ + code: "resource.state_persist_failed", + phase: "persist_state", + mutationStarted: true, + }); + expect(failure.execution).toMatchObject({ + outcome: "unknown", + results: [{ status: "success", resource: { remoteId: "env_dev" } }], + }); + } +}); + +test("structured feedback failures wait for already-started concurrent writes before returning a report", async () => { + const gate = Promise.withResolvers<{ id: string }>(); + const started = Promise.withResolvers(); + const feedback = Promise.withResolvers(); + const runtime = await context( + { environments: { dev: { config: { type: "cloud" } }, other: { config: { type: "cloud" } } } }, + { + createEnvironment: async (name: string) => { + if (name === "other") { + started.resolve(); + return gate.promise; + } + return { id: "env_dev" }; + }, + }, + ); + let settled = false; + const execution = executePlannedProject(await plan(runtime), { + resultDetail: "structured", + concurrency: 2, + onFeedback: (event) => { + if (event.resource?.name === "dev") { + feedback.resolve(); + throw new Error("feedback failed"); + } + }, + }).catch((error: unknown) => { + settled = true; + return error; + }); + await Promise.all([started.promise, feedback.promise]); + expect(settled).toBe(false); + gate.resolve({ id: "env_other" }); + const error = await execution; + expect(error).toBeInstanceOf(ResourceRuntimeError); + expect((error as ResourceRuntimeError).execution?.results).toHaveLength(2); + expect( + (error as ResourceRuntimeError).execution?.results.find((result) => result.action.address.name === "other"), + ).toMatchObject({ status: "success", resource: { remoteId: "env_other" } }); +}); diff --git a/packages/sdk/tests/unit/resource-result-identity.test.ts b/packages/sdk/tests/unit/resource-result-identity.test.ts new file mode 100644 index 0000000..367acad --- /dev/null +++ b/packages/sdk/tests/unit/resource-result-identity.test.ts @@ -0,0 +1,153 @@ +import { afterEach, expect, test } from "bun:test"; +import { + ApiError, + createProjectRuntime, + executePlannedProject, + InMemoryStateManager, + planProjectContext, + ResourceRuntimeError, + resolveProjectConfigFromObject, + setDefaultFetch, +} from "../../src/index.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +async function vaultRuntime() { + const loaded = await resolveProjectConfigFromObject( + { + version: "1", + providers: { bailian: { api_key: "fixture", base_url: "https://fixture.invalid/api/v1/agentstudio" } }, + defaults: { provider: "bailian" }, + agents: {}, + vaults: { + secrets: { + display_name: "Fixture", + credentials: [ + { + name: "service", + type: "environment_variable", + secret_name: "API_TOKEN", + secret_value: "fixture-private-value", + }, + ], + }, + }, + }, + { resolveEnv: false, textFileReferences: "literal" }, + ); + return createProjectRuntime({ + projectName: "identity", + config: loaded.config, + state: InMemoryStateManager.fromJSON({ resources: [] }), + }); +} + +test.each([ + "legacy", + "structured", +] as const)("%s keeps Vault creation facts without changing legacy failures or marking an incomplete Vault converged", async (detail) => { + const calls: string[] = []; + const body = JSON.stringify({ code: "InvalidCredential", message: "original credential rejection" }); + setDefaultFetch(async (input, init) => { + const path = new URL(String(input)).pathname.replace("/api/v1/agentstudio", ""); + calls.push(`${init?.method ?? "GET"} ${path}`); + if (path === "/vaults") return Response.json({ id: "vault_created", name: "Fixture" }); + if (path === "/vaults/vault_created/credentials") return new Response(body, { status: 400 }); + throw new Error("unexpected fixture request"); + }); + const runtime = await vaultRuntime(); + const planned = await planProjectContext(runtime, { + refresh: false, + resultDetail: detail, + mode: "create-only", + scope: { roots: [{ provider: "bailian", type: "vault", name: "secrets" }] }, + }); + const result = await executePlannedProject(planned, { resultDetail: detail }); + expect(calls).toEqual(["POST /vaults", "POST /vaults/vault_created/credentials"]); + expect(runtime.state.listResources()).toEqual([]); + expect(result.results[0]).toMatchObject({ status: "failed" }); + if (detail === "structured") { + expect(result).toMatchObject({ + outcome: "unknown", + mutationStarted: true, + results: [{ resource: { remoteId: "vault_created" }, errorInfo: { httpStatus: 400, mutationStarted: true } }], + }); + expect(JSON.stringify(result.results[0]?.resource)).not.toContain("fixture-private-value"); + } else { + expect(Object.keys(result)).toEqual(["results", "partial"]); + expect(Object.keys(result.results[0]!)).toEqual(["action", "status", "error"]); + expect(result.results[0]?.error).toBe(new ApiError(400, body, "Bailian API").message); + const original = await runtime.providers + .get("bailian")! + .createVault("Fixture", runtime.config.vaults!.secrets!) + .catch((error) => error); + expect(original).toBeInstanceOf(ApiError); + expect(original).not.toBeInstanceOf(ResourceRuntimeError); + expect(original).toMatchObject({ statusCode: 400, responseBody: body }); + } +}); + +test("structured deletion retains the known resource identity after state removal", async () => { + const runtime = await vaultRuntime(); + runtime.config.vaults = {}; + runtime.state.setResource({ + address: { provider: "bailian", type: "vault", name: "old" }, + remote_id: "vault_deleted", + version: 2, + content_hash: "old", + }); + let deleted: string | undefined; + runtime.providers = new Map([ + [ + "bailian", + { + name: "bailian", + deleteVault: async (id: string) => { + deleted = id; + }, + } as never, + ], + ]); + const planned = await planProjectContext(runtime, { refresh: false, resultDetail: "structured" }); + const result = await executePlannedProject(planned, { policy: "force", resultDetail: "structured" }); + expect(deleted).toBe("vault_deleted"); + expect(runtime.state.listResources()).toEqual([]); + expect(result).toMatchObject({ + outcome: "succeeded", + results: [{ status: "success", resource: { remoteId: "vault_deleted", version: 2 } }], + }); +}); + +test("nested Memory creation does not replace the Store identity in structured results", async () => { + const runtime = await vaultRuntime(); + runtime.config.vaults = {}; + runtime.config.memory_stores = { + notes: { name: "Notes", entries_mode: "initialize", entries: [{ key: "memo", content: "fixture" }] }, + }; + let childCreated = false; + runtime.providers = new Map([ + [ + "bailian", + { + name: "bailian", + createMemoryStore: async () => ({ id: "store_known" }), + deleteMemoryStore: async () => {}, + updateMemoryStore: async () => ({}), + listMemories: async () => ({ data: [] }), + createMemory: async () => { + childCreated = true; + return { id: "memory_child" }; + }, + } as never, + ], + ]); + const result = await executePlannedProject( + await planProjectContext(runtime, { refresh: false, resultDetail: "structured" }), + { resultDetail: "structured" }, + ); + expect(childCreated).toBe(true); + expect(result).toMatchObject({ + outcome: "succeeded", + results: [{ status: "success", resource: { remoteId: "store_known" } }], + }); +}); diff --git a/packages/sdk/tests/unit/session-event-sanitizer-snapshot.test.ts b/packages/sdk/tests/unit/session-event-sanitizer-snapshot.test.ts new file mode 100644 index 0000000..25ef17d --- /dev/null +++ b/packages/sdk/tests/unit/session-event-sanitizer-snapshot.test.ts @@ -0,0 +1,291 @@ +import { expect, test } from "bun:test"; +import type { SessionEvent } from "../../src/internal/types/dto.ts"; +import type { ProviderSessionEvent } from "../../src/internal/types/session-event.ts"; +import { sanitizeSessionEvent, toBailianSessionEvent } from "../../src/session-events.ts"; + +function provider(snapshot: SessionEvent, raw: Record = {}): ProviderSessionEvent { + return { type: "message", raw_type: "message", content: "obsolete fallback", snapshot, raw }; +} + +const longText = `token=synthetic-text ${"x".repeat(4100)}`; +const snapshot: SessionEvent = { + event_id: "msg-1", + type: "message", + role: "assistant", + created_at: "2026-10-16T01:00:00Z", + content: [ + { type: "text", text: longText }, + { + type: "custom", + index: 1, + data: { headers: { api_key: "synthetic-key" }, entries: [false, 2, null, { text: "ordinary" }] }, + }, + ], + metadata: { + event_status: "in_progress", + session_thread_id: "thread-1", + stop_reason: { type: "requires_action", call_ids: ["call-1"] }, + artifacts: [{ file_id: "file-1", filename: "report.html" }], + }, +}; + +for (const redact of [true, false]) { + for (const truncate of [true, false]) { + test(`tool and unknown fields cannot impersonate protocol identities: redact=${redact}, truncate=${truncate}`, () => { + const secret = "api_key=synthetic-code"; + const code = `${secret} ${"x".repeat(17000)}`; + const payload = { + code, + id: secret, + type: secret, + status: secret, + custom_ids: [secret], + nested: { event_id: secret, code: { id: secret } }, + }; + const raw = { + object: "message", + id: "call-event-1", + type: "tool_call", + status: "completed", + content: [{ type: "data", data: { call_id: "call-1", arguments: payload, output: payload, ...payload } }], + metadata: { custom: payload }, + }; + const event = toBailianSessionEvent(raw, { event_format: "snapshot" }); + const before = structuredClone(event); + const expected = (limit: number) => { + const text = redact ? code.replace(secret, "api_key: [redacted]") : code; + const leaf = redact ? "api_key: [redacted]" : secret; + return { + code: truncate ? `${text.slice(0, limit)}\n...[truncated ${text.length - limit} chars]` : text, + id: leaf, + type: leaf, + status: leaf, + custom_ids: [leaf], + nested: { event_id: leaf, code: { id: leaf } }, + }; + }; + const result = sanitizeSessionEvent(event, { redact, truncate, includeRaw: true }); + expect(result.content?.[0]?.data).toEqual({ + call_id: "call-1", + arguments: expected(8000), + output: expected(8000), + ...expected(8000), + }); + expect(result.metadata?.tool_input).toEqual(expected(8000)); + expect(result.metadata?.custom).toEqual(expected(8000)); + expect(result.metadata?.raw).toEqual({ + ...raw, + content: [ + { + type: "data", + data: { + call_id: "call-1", + arguments: expected(16000), + output: expected(16000), + ...expected(16000), + }, + }, + ], + metadata: { custom: expected(16000) }, + }); + expect(result.metadata?.redacted).toBe(redact || undefined); + expect(result.metadata?.truncated).toBe(truncate || undefined); + expect(event).toEqual(before); + if (redact && truncate) expect(result).toEqual(sanitizeSessionEvent(event, { includeRaw: true })); + }); + } +} + +for (const redact of [true, false]) { + for (const truncate of [true, false]) { + test(`snapshot policies are independent: redact=${redact}, truncate=${truncate}`, () => { + const input = provider(structuredClone(snapshot)); + const before = structuredClone(input); + const result = sanitizeSessionEvent(input, { redact, truncate }); + const expectedText = redact ? longText.replace("token=synthetic-text", "token: [redacted]") : longText; + expect(result.content?.[0]?.text).toBe( + truncate ? `${expectedText.slice(0, 4000)}\n...[truncated ${expectedText.length - 4000} chars]` : expectedText, + ); + expect(result.content?.[1]).toEqual({ + type: "custom", + index: 1, + data: { + headers: { api_key: redact ? "[redacted]" : "synthetic-key" }, + entries: [false, 2, null, { text: "ordinary" }], + }, + }); + expect(result.event_id).toBe(snapshot.event_id); + expect(result.created_at).toBe(snapshot.created_at); + expect(result.metadata).toEqual({ + ...snapshot.metadata, + ...(redact ? { redacted: true } : {}), + ...(truncate ? { truncated: true } : {}), + }); + expect(input).toEqual(before); + expect(result.content).not.toBe(input.snapshot?.content); + expect(result.content?.[1]?.data).not.toBe(input.snapshot?.content?.[1]?.data); + expect(result.metadata?.artifacts).not.toBe(input.snapshot?.metadata?.artifacts); + }); + } +} + +test("snapshot defaults keep both policies enabled and empty content is authoritative", () => { + expect(sanitizeSessionEvent(provider(snapshot))).toEqual( + sanitizeSessionEvent(provider(snapshot), { redact: true, truncate: true }), + ); + const event = provider({ + event_id: "msg-empty", + type: "message", + content: [], + metadata: { event_status: "completed" }, + }); + expect(sanitizeSessionEvent(event)).toEqual(event.snapshot); + expect(sanitizeSessionEvent(provider({ type: "reasoning" }))).toEqual({ type: "reasoning" }); +}); + +test("raw is independently opt-in and uses the actual triggering frame", () => { + const raw = { object: "content", msg_id: "msg-1", delta: true, text: "part", data: { token: "synthetic-raw" } }; + const event = provider( + { + type: "message", + content: [{ type: "text", text: "full content" }], + metadata: { raw: { outdated: true }, redacted: true, truncated: true }, + }, + raw, + ); + expect(sanitizeSessionEvent(event, { redact: false, truncate: false }).metadata).toEqual({}); + expect(sanitizeSessionEvent(event, { includeRaw: true }).metadata).toEqual({ + raw: { ...raw, data: { token: "[redacted]" } }, + redacted: true, + }); + const complete = sanitizeSessionEvent(event, { includeRaw: true, redact: false, truncate: false }); + expect(complete.metadata).toEqual({ raw }); + expect(complete.metadata?.raw).not.toBe(raw); + expect(raw.data.token).toBe("synthetic-raw"); +}); + +test("structured secret containers retain their shape and non-secret policy fields remain intact", () => { + const event = provider({ + type: "tool_call", + content: [ + { + type: "data", + data: { + authorization: { bearer: "synthetic-token", scopes: ["synthetic-scope"] }, + api_key: "synthetic-key", + policy: { allowed: true }, + expires: 123, + url: "https://example.test/api?token=synthetic-url&safe=yes", + }, + }, + ], + }); + const data = sanitizeSessionEvent(event).content?.[0]?.data; + expect(data).toEqual({ + authorization: { bearer: "[redacted]", scopes: ["[redacted]"] }, + api_key: "[redacted]", + policy: { allowed: true }, + expires: 123, + url: expect.stringContaining("[redacted]"), + }); +}); + +test("protocol identity slots do not exempt malformed object descendants", () => { + const secret = "api_key=synthetic-nested"; + const nested = { code: secret, type: secret, event_id: secret }; + const event = provider( + { + type: "session_status", + metadata: { + session_thread_id: nested, + pending_call_ids: [nested, [secret]], + stop_reason: { type: nested, call_ids: [nested] }, + error: { code: nested }, + }, + }, + { id: nested, msg_id: [secret], stop_reason: secret, error: { code: nested } }, + ); + const result = sanitizeSessionEvent(event, { includeRaw: true }); + expect(JSON.stringify(result)).not.toContain(secret); + expect(result.metadata?.pending_call_ids).toEqual([ + { code: "api_key: [redacted]", type: "api_key: [redacted]", event_id: "api_key: [redacted]" }, + ["api_key: [redacted]"], + ]); + expect(result.metadata?.redacted).toBe(true); +}); + +test("structured truncation preserves objects, identities, and tool/document/raw length policies", () => { + const id = `msg-token=synthetic-identity ${"i".repeat(4100)}`; + const toolText = "t".repeat(8100); + const document = `\`\`\`html\n${"d".repeat(32100)}`; + const rawText = "r".repeat(16100); + const event = provider( + { + event_id: id, + type: "message", + content: [ + { type: "text", index: 7, text: document }, + { type: "data", data: { output: { text: toolText } } }, + ], + code: id, + metadata: { + event_status: "completed", + pending_call_ids: [id], + session_thread_id: id, + stop_reason: { type: "requires_action", call_ids: [id], event_ids: [id] }, + error: { code: id }, + artifacts: [{ file_id: id }], + artifact: { file_id: id }, + nested: [{ description: "n".repeat(4100) }], + }, + }, + { msg_id: id, error: { code: id }, payload: { text: rawText } }, + ); + const result = sanitizeSessionEvent(event, { includeRaw: true }); + expect(result.event_id).toBe(id); + expect(result.code).toBe(id); + expect(result.metadata?.pending_call_ids).toEqual([id]); + expect(result.metadata?.session_thread_id).toBe(id); + expect(result.metadata?.stop_reason).toEqual({ type: "requires_action", call_ids: [id], event_ids: [id] }); + expect(result.metadata?.error).toEqual({ code: id }); + expect(result.metadata?.artifacts).toEqual([{ file_id: id }]); + expect(result.metadata?.artifact).toEqual({ file_id: id }); + expect(result.metadata?.event_status).toBe("completed"); + expect(result.content?.[0]?.index).toBe(7); + expect(result.content?.[0]?.text).toBe( + `${document.slice(0, 32000)}\n...[truncated ${document.length - 32000} chars]`, + ); + expect(result.content?.[1]?.data).toEqual({ + output: { text: `${toolText.slice(0, 8000)}\n...[truncated 100 chars]` }, + }); + expect(result.metadata?.nested).toEqual([{ description: `${"n".repeat(4000)}\n...[truncated 100 chars]` }]); + expect(result.metadata?.raw).toEqual({ + msg_id: id, + error: { code: id }, + payload: { text: `${rawText.slice(0, 16000)}\n...[truncated 100 chars]` }, + }); + expect(result.metadata?.truncated).toBe(true); + expect(result.metadata?.redacted).toBeUndefined(); + expect(sanitizeSessionEvent(event, { redact: false, truncate: false, includeRaw: true })).toEqual({ + ...event.snapshot, + metadata: { ...event.snapshot?.metadata, raw: event.raw }, + }); +}); + +test("error message and nested error details use snapshot policies without replacing error identity", () => { + const event = provider({ + type: "error", + code: "PERMISSION_DENIED", + is_error: true, + message: "token=synthetic-message", + metadata: { error: { code: "DENIED", credential: "synthetic-credential" } }, + }); + const result = sanitizeSessionEvent({ ...event, type: "error" }); + expect(result).toEqual({ + type: "error", + code: "PERMISSION_DENIED", + is_error: true, + message: "token: [redacted]", + metadata: { error: { code: "DENIED", credential: "[redacted]" }, redacted: true }, + }); +}); diff --git a/packages/sdk/tests/unit/session-event-sanitizer.test.ts b/packages/sdk/tests/unit/session-event-sanitizer.test.ts index 84deca3..6cc1c05 100644 --- a/packages/sdk/tests/unit/session-event-sanitizer.test.ts +++ b/packages/sdk/tests/unit/session-event-sanitizer.test.ts @@ -1,11 +1,16 @@ import { expect, test } from "bun:test"; -import { sanitizeSessionEvent } from "../../src/internal/core/session-event-sanitizer.ts"; import type { ProviderSessionEvent } from "../../src/internal/types/session-event.ts"; +import { + type SessionEventSanitizerOptions, + sanitizeSessionEvent, + sanitizeSessionEvents, +} from "../../src/session-events.ts"; test("surfaces the artifact descriptor onto metadata.artifact", () => { const event: ProviderSessionEvent = { type: "unknown", raw_type: "agent.artifact_delivered", + raw: {}, artifact: { file_id: "file_123", filename: "report.html", content_type: "text/html", size: 45771 }, }; const result = sanitizeSessionEvent(event); @@ -23,9 +28,163 @@ test("omits metadata.artifact when the event carries none", () => { const event: ProviderSessionEvent = { type: "message", raw_type: "agent.message", + raw: {}, role: "assistant", content: "hello", }; const result = sanitizeSessionEvent(event); expect(result.metadata?.artifact).toBeUndefined(); }); + +const sensitiveEvent: ProviderSessionEvent = { + type: "tool_use", + raw_type: "tool_call", + tool_name: "example_tool", + tool_input: "api_key=synthetic-input", + raw: { detail: "token=synthetic-raw" }, +}; + +const enabledPolicies: { label: string; options?: SessionEventSanitizerOptions }[] = [ + { label: "omitted options" }, + { label: "empty options", options: {} }, + { label: "explicit true", options: { redact: true } }, +]; + +for (const { label, options } of enabledPolicies) { + test(`redacts event text and its tool input metadata with ${label}`, () => { + const result = sanitizeSessionEvent(sensitiveEvent, options); + expect(result.content).toEqual([{ type: "text", text: "api_key: [redacted]" }]); + expect(result.metadata?.tool_input).toBe("api_key: [redacted]"); + expect(result.metadata?.redacted).toBe(true); + expect(result.metadata?.raw).toBeUndefined(); + }); +} + +test("reports redaction when only the tool input metadata changes", () => { + const result = sanitizeSessionEvent({ ...sensitiveEvent, content: "ordinary text" }); + expect(result.content).toEqual([{ type: "text", text: "ordinary text" }]); + expect(result.metadata?.tool_input).toBe("api_key: [redacted]"); + expect(result.metadata?.redacted).toBe(true); +}); + +test("disabling redaction preserves tool text and metadata without opting into raw", () => { + const result = sanitizeSessionEvent(sensitiveEvent, { redact: false }); + expect(result.content).toEqual([{ type: "text", text: sensitiveEvent.tool_input }]); + expect(result.metadata?.tool_input).toBe(sensitiveEvent.tool_input); + expect(result.metadata?.redacted).toBeUndefined(); + expect(result.metadata?.raw).toBeUndefined(); +}); + +test("optional raw follows the redaction policy without mutating the provider event", () => { + const before = structuredClone(sensitiveEvent); + const enabled = sanitizeSessionEvent(sensitiveEvent, { includeRaw: true }); + const disabled = sanitizeSessionEvent(sensitiveEvent, { includeRaw: true, redact: false }); + expect(enabled.metadata?.raw).toEqual({ detail: "token: [redacted]" }); + expect(disabled.metadata?.raw).toEqual(sensitiveEvent.raw); + expect(disabled.metadata?.redacted).toBeUndefined(); + expect(sensitiveEvent).toEqual(before); +}); + +test("batch redaction is local to each call and also controls error messages", () => { + const error: ProviderSessionEvent = { + type: "error", + raw_type: "error", + content: "token=synthetic-error", + raw: {}, + }; + const [tool, failure] = sanitizeSessionEvents([sensitiveEvent, error], { redact: false }); + expect(tool?.metadata?.tool_input).toBe(sensitiveEvent.tool_input); + expect(failure?.content).toEqual([{ type: "text", text: error.content }]); + expect(failure?.message).toBe(error.content); + expect(failure?.is_error).toBe(true); + expect(failure?.metadata?.redacted).toBeUndefined(); + const [defaultFailure] = sanitizeSessionEvents([error]); + expect(defaultFailure?.message).toBe("token: [redacted]"); + expect(defaultFailure?.metadata?.redacted).toBe(true); +}); + +test("disabling redaction keeps the existing truncation policy", () => { + const content = `api_key=synthetic-long ${"x".repeat(4100)}`; + const result = sanitizeSessionEvent({ type: "message", raw_type: "message", content, raw: {} }, { redact: false }); + expect(result.content).toEqual([ + { type: "text", text: `${content.slice(0, 4000)}\n...[truncated ${content.length - 4000} chars]` }, + ]); + expect(result.metadata?.truncated).toBe(true); + expect(result.metadata?.redacted).toBeUndefined(); +}); + +test("long malformed HTML prefixes remain bounded and cannot reuse an earlier closing bracket", () => { + const content = `>${" { + const cases = [ + { content: `${"x".repeat(3990)}tail`, cut: 3990 }, + { content: `${"x".repeat(4100)}`, cut: 4000 }, + ]; + for (const { content, cut } of cases) { + const result = sanitizeSessionEvent({ type: "message", raw_type: "message", content, raw: {} }, { redact: false }); + expect(result.content).toEqual([ + { type: "text", text: `${content.slice(0, cut)}\n...[truncated ${content.length - cut} chars]` }, + ]); + expect(result.metadata?.truncated).toBe(true); + } +}); + +const longContentCases: { label: string; type: ProviderSessionEvent["type"]; content: string; limit: number }[] = [ + { label: "message", type: "message", content: "x".repeat(4100), limit: 4000 }, + { label: "tool", type: "tool_result", content: "x".repeat(8100), limit: 8000 }, + { label: "document", type: "message", content: `\`\`\`mermaid\n${"x".repeat(32100)}`, limit: 32000 }, +]; + +for (const { label, type, content, limit } of longContentCases) { + test(`keeps the default ${label} limit and allows complete content explicitly`, () => { + const event: ProviderSessionEvent = { type, raw_type: type, content, raw: {} }; + const original = sanitizeSessionEvent(event); + expect(original.content).toEqual([ + { type: "text", text: `${content.slice(0, limit)}\n...[truncated ${content.length - limit} chars]` }, + ]); + expect(original.metadata?.truncated).toBe(true); + expect(sanitizeSessionEvent(event, { redact: true, truncate: true })).toEqual(original); + const full = sanitizeSessionEvent(event, { redact: false, truncate: false }); + expect(full.content).toEqual([{ type: "text", text: content }]); + expect(full.metadata?.truncated).toBeUndefined(); + expect(full.metadata?.redacted).toBeUndefined(); + }); +} + +test("disabling truncation keeps redaction enabled by default", () => { + const content = `api_key=synthetic-long ${"x".repeat(4100)}`; + const result = sanitizeSessionEvent({ type: "message", raw_type: "message", content, raw: {} }, { truncate: false }); + expect(result.content).toEqual([{ type: "text", text: `api_key: [redacted] ${"x".repeat(4100)}` }]); + expect(result.metadata?.redacted).toBe(true); + expect(result.metadata?.truncated).toBeUndefined(); +}); + +test("batch callers can disable both policies for error text and optional raw", () => { + const content = `token=synthetic-error ${"x".repeat(4100)}`; + const raw = { detail: `token=synthetic-raw ${"x".repeat(16100)}` }; + const event: ProviderSessionEvent = { type: "error", raw_type: "error", content, raw }; + const before = structuredClone(event); + const original = sanitizeSessionEvent(event, { includeRaw: true }); + expect(original.metadata?.truncated).toBe(true); + expect(original.metadata?.redacted).toBe(true); + expect(String(original.metadata?.raw)).not.toContain("synthetic-raw"); + expect(String(original.metadata?.raw)).toContain("...[truncated "); + const [full] = sanitizeSessionEvents([event], { redact: false, truncate: false, includeRaw: true }); + expect(full?.content).toEqual([{ type: "text", text: content }]); + expect(full?.message).toBe(content); + expect(full?.metadata?.raw).toEqual(raw); + expect(full?.metadata?.truncated).toBeUndefined(); + expect(full?.metadata?.redacted).toBeUndefined(); + expect(sanitizeSessionEvent(event, { redact: false, truncate: false }).metadata?.raw).toBeUndefined(); + expect(sanitizeSessionEvent(event, { includeRaw: true })).toEqual(original); + expect(event).toEqual(before); +}); diff --git a/packages/sdk/tests/unit/session-stream-runtime.test.ts b/packages/sdk/tests/unit/session-stream-runtime.test.ts new file mode 100644 index 0000000..b2c0d41 --- /dev/null +++ b/packages/sdk/tests/unit/session-stream-runtime.test.ts @@ -0,0 +1,655 @@ +import { afterEach, describe, expect, test } from "bun:test"; +import { streamMessageEvents } from "../../src/internal/core/session-runtime.ts"; +import { BailianAdapter } from "../../src/internal/providers/bailian/adapter.ts"; +import { ClaudeAdapter } from "../../src/internal/providers/claude/adapter.ts"; +import { setDefaultFetch } from "../../src/internal/transport.ts"; +import type { ProviderSessionEvent } from "../../src/internal/types/session-event.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +function adapter() { + return new BailianAdapter("test", undefined, "https://bailian.example.test"); +} +function status(id: string, value: string, stop_reason?: unknown) { + return { + object: "message", + type: "session_status", + status: "completed", + id, + content: [{ type: "data", data: { session_status: value, stop_reason } }], + }; +} +function encode(raw: unknown): Uint8Array { + return new TextEncoder().encode(`data: ${JSON.stringify(raw)}\n\n`); +} + +describe("streaming send lifecycle", () => { + test("awaits the HTTP subscription before POST, delivers cumulative updates, and stops on idle", async () => { + const calls: string[] = []; + let source!: ReadableStreamDefaultController; + let connect!: () => void; + const gate = new Promise((resolve) => { + connect = resolve; + }); + let cancel = false; + setDefaultFetch(async (_input, init) => { + if (init?.method === "POST") { + calls.push("send"); + source.enqueue(encode(status("running", "running"))); + source.enqueue( + encode({ object: "message", id: "m", type: "message", role: "assistant", status: "in_progress" }), + ); + source.enqueue(encode({ object: "content", msg_id: "m", index: 0, type: "text", delta: true, text: "你" })); + source.enqueue(encode({ object: "content", msg_id: "m", index: 0, type: "text", delta: true, text: "好" })); + source.enqueue( + encode({ + object: "message", + id: "m", + type: "message", + status: "completed", + content: [{ type: "text", text: "你好" }], + }), + ); + source.enqueue(encode(status("idle", "idle"))); + return Response.json({ id: "user" }); + } + calls.push("connecting"); + await gate; + return new Response( + new ReadableStream({ + start(controller) { + source = controller; + }, + cancel() { + cancel = true; + }, + }), + ); + }); + const events: ProviderSessionEvent[] = []; + const reading = (async () => { + for await (const event of streamMessageEvents(adapter(), "s", "hi", { + event_deltas: ["message"], + onReady: () => calls.push("ready"), + })) + events.push(event); + })(); + await new Promise((resolve) => setTimeout(resolve, 5)); + expect(calls).toEqual(["connecting"]); + connect(); + await reading; + expect(calls).toEqual(["connecting", "ready", "send"]); + expect(events.filter((event) => event.id === "m").map((event) => event.snapshot?.content?.[0]?.text)).toEqual([ + undefined, + "你", + "你好", + "你好", + ]); + expect(events.at(-1)?.status).toBe("idle"); + expect(cancel).toBe(true); + }); + + test("connection failure and pre-cancellation never send a message", async () => { + let posts = 0; + setDefaultFetch(async (_input, init) => { + if (init?.method === "POST") posts++; + return new Response("private provider error", { status: 401 }); + }); + const stream = streamMessageEvents(adapter(), "s", "hi", { event_format: "snapshot" })[Symbol.asyncIterator](); + await expect(stream.next()).rejects.toThrow("HTTP 401"); + const controller = new AbortController(); + controller.abort(); + const stopped = streamMessageEvents(adapter(), "s", "hi", { event_format: "snapshot", signal: controller.signal })[ + Symbol.asyncIterator + ](); + await expect(stopped.next()).rejects.toMatchObject({ name: "AbortError" }); + expect(posts).toBe(0); + }); + + test("POST failure cancels the established subscription and does not retry the send", async () => { + let cancelled = false; + let posts = 0; + setDefaultFetch(async (_input, init) => { + if (init?.method === "POST") { + posts++; + return new Response("send failed", { status: 503 }); + } + return new Response( + new ReadableStream({ + cancel() { + cancelled = true; + }, + }), + ); + }); + const stream = streamMessageEvents(adapter(), "s", "hi", { event_format: "snapshot", reconnect: true })[ + Symbol.asyncIterator + ](); + await expect(stream.next()).rejects.toThrow("503"); + expect(posts).toBe(1); + expect(cancelled).toBe(true); + }); + + test("requires_action is delivered intact and ends the single-turn iterator without resending", async () => { + let source!: ReadableStreamDefaultController; + let posts = 0; + setDefaultFetch(async (_input, init) => { + if (init?.method === "POST") { + posts++; + source.enqueue(encode(status("running", "running"))); + source.enqueue(encode(status("approval", "idle", { type: "requires_action", call_ids: ["call-1"] }))); + return Response.json({ id: "user" }); + } + return new Response( + new ReadableStream({ + start(controller) { + source = controller; + }, + }), + ); + }); + const events = []; + for await (const event of streamMessageEvents(adapter(), "s", "hi", { event_format: "snapshot" })) + events.push(event); + expect(events.at(-1)?.snapshot?.metadata?.stop_reason).toEqual({ type: "requires_action", call_ids: ["call-1"] }); + expect(posts).toBe(1); + }); + + test("abort stops observation while POST is still pending, without sending twice", async () => { + const controller = new AbortController(); + let posted!: () => void; + const sent = new Promise((resolve) => { + posted = resolve; + }); + let posts = 0; + let cancelled = false; + setDefaultFetch(async (_input, init) => { + if (init?.method === "POST") { + posts++; + posted(); + return new Promise(() => {}); + } + return new Response( + new ReadableStream({ + cancel() { + cancelled = true; + }, + }), + ); + }); + const iterator = streamMessageEvents(adapter(), "s", "hi", { event_format: "snapshot", signal: controller.signal })[ + Symbol.asyncIterator + ](); + const pending = iterator.next(); + await sent; + controller.abort(); + await expect(pending).rejects.toMatchObject({ name: "AbortError" }); + expect(posts).toBe(1); + expect(cancelled).toBe(true); + }); + + test("unsupported providers reject explicit Bailian mode before sending", () => { + const claude = new ClaudeAdapter("test"); + expect(() => streamMessageEvents(claude, "s", "hi", { event_deltas: ["message"] })).toThrow("only by Bailian"); + }); +}); + +function message(id: string, role: string, text: string) { + return { object: "message", type: "message", id, role, status: "completed", content: [{ type: "text", text }] }; +} + +describe("single-turn snapshot recovery", () => { + for (const delivery of ["buffered", "late", "resumed"] as const) { + test(`repairs an unfinished history page before ending the turn from ${delivery} live events`, async () => { + const user = message("user", "user", "question"); + const running = status("running", "running"); + const answer = message("answer", "assistant", "FINAL ANSWER"); + const partial = { ...answer, status: "in_progress", content: [{ type: "text", text: "partial" }] }; + const recoveredIdle = status("recovered-idle", "idle"); + const resumed = status("resumed-running", "running"); + const latestIdle = status("latest-idle", "idle"); + let first!: ReadableStreamDefaultController; + let live!: ReadableStreamDefaultController; + let connections = 0; + let posts = 0; + let pages = 0; + let historyRead!: () => void; + const historyReady = new Promise((resolve) => { + historyRead = resolve; + }); + const sendFinal = () => { + if (delivery === "resumed") { + // One network chunk still reaches the SDK queue through separate async yields. + queueMicrotask(() => + live.enqueue( + new TextEncoder().encode(`data: ${JSON.stringify(answer)}\n\ndata: ${JSON.stringify(resumed)}\n\n`), + ), + ); + } else for (const raw of [answer, recoveredIdle]) live.enqueue(encode(raw)); + }; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") { + posts++; + first.enqueue(encode(running)); + first.enqueue(encode(partial)); + first.close(); + return Response.json({ id: user.id }); + } + if (String(input).includes("/stream")) { + connections++; + return new Response( + new ReadableStream({ + start(controller) { + if (connections === 1) first = controller; + else live = controller; + }, + }), + ); + } + pages++; + if (pages === 1) return Response.json({ data: [user, running, partial], next_page: "terminal-page" }); + if (delivery !== "late") sendFinal(); + historyRead(); + return Response.json({ data: [recoveredIdle], next_page: null }); + }); + const controller = new AbortController(); + const guard = setTimeout(() => controller.abort(), 1500); + const events: ProviderSessionEvent[] = []; + let finished = false; + const reading = (async () => { + for await (const event of streamMessageEvents(adapter(), "s", "question", { + event_format: "snapshot", + reconnect: true, + signal: controller.signal, + })) { + events.push(event); + if (event.id === resumed.id) { + live.enqueue(encode(message("resumed-answer", "assistant", "RESUMED ANSWER"))); + live.enqueue(encode(latestIdle)); + } + } + finished = true; + })(); + try { + if (delivery === "late") { + await historyReady; + await new Promise((resolve) => setTimeout(resolve, 10)); + expect(finished).toBe(false); + expect(events.some((event) => event.status === "idle")).toBe(false); + sendFinal(); + } + await reading; + expect(events.filter((event) => event.id === answer.id).at(-1)?.content).toBe("FINAL ANSWER"); + expect(events.at(-1)?.id).toBe(delivery === "resumed" ? latestIdle.id : recoveredIdle.id); + if (delivery === "resumed") { + expect(events.some((event) => event.id === recoveredIdle.id)).toBe(false); + expect(events.find((event) => event.id === "resumed-answer")?.content).toBe("RESUMED ANSWER"); + } + expect(posts).toBe(1); + expect(connections).toBe(2); + expect(pages).toBe(2); + } finally { + clearTimeout(guard); + controller.abort(); + await reading.catch(() => {}); + } + }); + } + + for (const missing of ["completion", "status-after-completion"] as const) { + test(`unfinished history without live ${missing} fails instead of yielding a successful terminal state`, async () => { + const user = message("user", "user", "question"); + const partial = { ...message("answer", "assistant", "partial"), status: "in_progress" }; + let posts = 0; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") { + posts++; + return Response.json({ id: user.id }); + } + if (String(input).includes("/stream")) + return new Response( + new ReadableStream({ + start(controller) { + if (missing === "status-after-completion") { + controller.enqueue(encode(status("idle", "idle"))); + controller.enqueue(encode(message("answer", "assistant", "FINAL ANSWER"))); + } + }, + }), + ); + return Response.json({ + data: [user, status("running", "running"), partial, status("idle", "idle")], + next_page: null, + }); + }); + const events: ProviderSessionEvent[] = []; + const reading = (async () => { + for await (const event of streamMessageEvents(adapter(), "s", "question", { + event_format: "snapshot", + after_id: user.id, + connectTimeoutMs: 20, + })) + events.push(event); + })(); + await expect(reading).rejects.toMatchObject({ code: "connect-timeout" }); + expect(events.some((event) => event.status === "idle")).toBe(false); + if (missing === "status-after-completion") expect(events.at(-1)?.content).toBe("FINAL ANSWER"); + expect(posts).toBe(1); + }); + } + + test("a queued final answer and terminal event survive a concurrent transport failure during repair", async () => { + const user = message("user", "user", "question"); + const answer = message("answer", "assistant", "FINAL ANSWER"); + const partial = { ...answer, status: "in_progress", content: [{ type: "text", text: "partial" }] }; + const idle = status("idle", "idle"); + let live!: ReadableStreamDefaultController; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") return Response.json({ id: user.id }); + if (String(input).includes("/stream")) + return new Response( + new ReadableStream({ + start(controller) { + live = controller; + }, + }), + ); + return Response.json({ data: [user, status("running", "running"), partial, idle], next_page: null }); + }); + const stream = streamMessageEvents(adapter(), "s", "question", { event_format: "snapshot", after_id: user.id })[ + Symbol.asyncIterator + ](); + try { + expect((await stream.next()).value?.status).toBe("running"); + live.enqueue(encode(answer)); + live.enqueue(encode(idle)); + live.close(); + // Let the transport consume EOF while the caller is paused on the history event. + await new Promise((resolve) => setTimeout(resolve, 10)); + expect((await stream.next()).value?.content).toBe("FINAL ANSWER"); + expect((await stream.next()).value?.status).toBe("idle"); + expect((await stream.next()).done).toBe(true); + } finally { + await stream.return?.(); + } + }); + + test("legacy session status frames remain complete while repairing a snapshot subscription", async () => { + const user = message("user", "user", "question"); + const answer = message("answer", "assistant", "FINAL ANSWER"); + const partial = { ...answer, status: "in_progress", content: [{ type: "text", text: "partial" }] }; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") return Response.json({ id: user.id }); + if (String(input).includes("/stream")) + return new Response( + new ReadableStream({ + start(controller) { + controller.enqueue(encode(answer)); + controller.enqueue(encode({ id: "live-idle", type: "session_status", status: "idle" })); + }, + }), + ); + return Response.json({ + data: [user, partial, { id: "history-idle", type: "session_status", status: "idle" }], + next_page: null, + }); + }); + const events: ProviderSessionEvent[] = []; + for await (const event of streamMessageEvents(adapter(), "s", "question", { + event_format: "snapshot", + after_id: user.id, + connectTimeoutMs: 50, + })) + events.push(event); + expect(events.map((event) => event.id)).toEqual([answer.id, "live-idle"]); + expect(events[0]?.content).toBe("FINAL ANSWER"); + }); + + for (const phase of ["before-first-event", "at-marker", "before-marker"] as const) { + test(`recovers a changed status ${phase} after repairing the final answer`, async () => { + const laterMarker = phase === "before-marker"; + const user = message("new-user", "user", "question"); + const running = status("current-status", "running"); + const idle = status("current-status", "idle", { type: "end_turn" }); + const marker = message("later-marker", "assistant", "working"); + const answer = message("answer", "assistant", "complete answer"); + let first!: ReadableStreamDefaultController; + let connections = 0; + let posts = 0; + let pages = 0; + let cancelled = false; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") { + posts++; + if (phase !== "before-first-event") { + for (const raw of [ + running, + ...(laterMarker ? [marker] : []), + { ...answer, status: "in_progress", content: [{ type: "text", text: "partial" }] }, + ]) + first.enqueue(encode(raw)); + } + first.close(); + return Response.json({ id: user.id }); + } + if (String(input).includes("/stream")) { + connections++; + return new Response( + new ReadableStream({ + start(controller) { + if (connections === 1) first = controller; + else for (const raw of [idle, answer]) controller.enqueue(encode(raw)); + }, + cancel() { + cancelled = true; + }, + }), + ); + } + pages++; + return new URL(String(input)).searchParams.has("page") + ? Response.json({ data: [answer], next_page: null }) + : Response.json({ + data: [ + message("old-answer", "assistant", "previous turn"), + status("old-status", "idle"), + user, + idle, + ...(laterMarker ? [marker] : []), + ], + next_page: "final-answer", + }); + }); + const controller = new AbortController(); + const guard = setTimeout(() => controller.abort(), 1500); + const events: ProviderSessionEvent[] = []; + try { + for await (const event of streamMessageEvents(adapter(), "s", "question", { + event_format: "snapshot", + reconnect: true, + signal: controller.signal, + })) + events.push(event); + } finally { + clearTimeout(guard); + controller.abort(); + } + expect(events.filter((event) => event.id === "current-status").map((event) => event.status)).toEqual( + phase === "before-first-event" ? ["idle"] : ["running", "idle"], + ); + expect(events.slice(-2).map((event) => [event.id, event.content, event.status])).toEqual([ + ["answer", "complete answer", undefined], + ["current-status", undefined, "idle"], + ]); + expect(events.some((event) => event.id?.startsWith("old-"))).toBe(false); + expect(posts).toBe(1); + expect(connections).toBe(2); + expect(pages).toBe(2); + expect(cancelled).toBe(true); + }); + } + + const cases = [ + { phase: "before-first-event", delivery: "live" }, + { phase: "before-first-event", delivery: "history" }, + { phase: "after-partial", delivery: "history" }, + { phase: "after-running", delivery: "history" }, + { phase: "initial-after-id", delivery: "history" }, + ] as const; + for (const { phase, delivery } of cases) { + test(`${phase}: ignores the previous turn and completes from current ${delivery}`, async () => { + const previous = [ + message("old-user", "user", "old question"), + message("old-answer", "assistant", "OLD ANSWER"), + status("old-idle", "idle", { type: "end_turn" }), + ]; + const user = message("new-user", "user", "new question"); + const running = status("new-running", "running"); + const answer = message("new-answer", "assistant", "NEW ANSWER"); + const idle = status("new-idle", "idle", { type: "end_turn" }); + const initial = + phase === "after-running" + ? [running] + : phase === "after-partial" + ? [{ ...answer, status: "in_progress", content: [{ type: "text", text: "NEW" }] }] + : []; + const history = [...previous, user, ...(delivery === "history" ? [running, answer, idle] : [])]; + let first!: ReadableStreamDefaultController; + let posts = 0; + let connections = 0; + let historyRequests = 0; + let cancelled = false; + let resolvePosted!: () => void; + const posted = new Promise((resolve) => { + resolvePosted = resolve; + }); + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") { + posts++; + resolvePosted(); + if (phase !== "initial-after-id") { + for (const raw of initial) first.enqueue(encode(raw)); + first.close(); // Natural EOF, without a synthetic done event. + } + return Response.json({ id: "new-user" }); + } + if (String(input).includes("/stream")) { + connections++; + return new Response( + new ReadableStream({ + start(controller) { + if (connections === 1) first = controller; + else if (delivery === "live") { + for (const raw of [running, answer, idle]) controller.enqueue(encode(raw)); + } + }, + cancel() { + cancelled = true; + }, + }), + ); + } + historyRequests++; + await posted; + return Response.json({ data: history, next_page: null }); + }); + const events: ProviderSessionEvent[] = []; + for await (const event of streamMessageEvents(adapter(), "s", "new question", { + event_format: "snapshot", + reconnect: true, + ...(phase === "initial-after-id" ? { after_id: "old-user" } : {}), + })) + events.push(event); + expect(events.some((event) => event.id?.startsWith("old-"))).toBe(false); + expect(events.filter((event) => event.id === "new-answer").at(-1)?.content).toBe("NEW ANSWER"); + expect(events.at(-1)?.id).toBe("new-idle"); + expect(events.filter((event) => event.id === "new-idle")).toHaveLength(1); + expect(posts).toBe(1); + expect(connections).toBe(phase === "initial-after-id" ? 1 : 2); + expect(historyRequests).toBe(1); + expect(cancelled).toBe(true); + }); + } + + test("missing send identity fails recovery instead of returning a previous answer", async () => { + let first!: ReadableStreamDefaultController; + let posts = 0; + let cancelled = false; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") { + posts++; + first.close(); + return Response.json({}); + } + if (String(input).includes("/stream")) { + return new Response( + new ReadableStream({ + start(controller) { + first = controller; + }, + cancel() { + cancelled = true; + }, + }), + ); + } + return Response.json({ + data: [message("old-answer", "assistant", "OLD ANSWER"), status("old-idle", "idle")], + next_page: null, + }); + }); + const reading = (async () => { + for await (const _event of streamMessageEvents(adapter(), "s", "hi", { + event_format: "snapshot", + reconnect: true, + })) { + throw new Error("Recovery must not deliver another turn's events."); + } + })(); + await expect(reading).rejects.toThrow("send response did not include an event id"); + expect(posts).toBe(1); + expect(cancelled).toBe(true); + }); +}); + +for (const snapshot of [false, true]) { + test(`${snapshot ? "snapshot live" : "legacy default"} send does not require a send event id or user echo`, async () => { + let source!: ReadableStreamDefaultController; + let posts = 0; + const requests: string[] = []; + const frames = [ + message("answer", "assistant", "answer"), + status("idle", "idle"), + message("after-idle", "assistant", "still listening"), + ]; + setDefaultFetch(async (input, init) => { + if (init?.method === "POST") { + posts++; + for (const raw of frames) source.enqueue(encode(raw)); + source.close(); + return Response.json({}); + } + requests.push(String(input)); + return new Response( + new ReadableStream({ + start: (controller) => { + source = controller; + }, + }), + ); + }); + const events: ProviderSessionEvent[] = []; + for await (const event of streamMessageEvents( + adapter(), + "s", + "hi", + snapshot ? { event_format: "snapshot" } : undefined, + )) + events.push(event); + expect(events.map((event) => event.id)).toEqual(snapshot ? ["answer", "idle"] : ["answer", "idle", "after-idle"]); + expect(events.every((event) => Boolean(event.snapshot) === snapshot)).toBe(true); + expect(requests).toHaveLength(1); + expect(new URL(requests[0]!).search).toBe(""); + expect(posts).toBe(1); + }); +} diff --git a/packages/sdk/tests/unit/session-thread-runtime.test.ts b/packages/sdk/tests/unit/session-thread-runtime.test.ts new file mode 100644 index 0000000..c92b6f6 --- /dev/null +++ b/packages/sdk/tests/unit/session-thread-runtime.test.ts @@ -0,0 +1,172 @@ +import { afterEach, expect, test } from "bun:test"; +import { + createManagedApiContext, + listSessionThreadEvents, + listSessionThreads, + type SessionThread, +} from "../../src/index.ts"; +import { type FetchLike, setDefaultFetch } from "../../src/internal/transport.ts"; +import { sanitizeSessionEvents } from "../../src/session-events.ts"; + +afterEach(() => setDefaultFetch(undefined)); + +const baseUrl = "https://bailian.test/api/v1/agentstudio"; +const context = () => createManagedApiContext({ providers: { bailian: { api_key: "test", base_url: baseUrl } } }); +const child: SessionThread = { + id: "sthr_research", + type: "session_thread", + session_id: "sesn_one", + parent_thread_id: "thrd_main", + agent: { id: "agent_research", version: 3, name: "Researcher" }, + status: "running", + created_at: "2026-10-28T00:00:00Z", + updated_at: "2026-10-28T00:00:01Z", + archived_at: null, +}; + +function urlOf(input: Parameters[0]) { + return new URL(input instanceof Request ? input.url : input.toString()); +} + +test("public thread list preserves child identity, nested Agent, opaque cursor, and unknown status", async () => { + const calls: URL[] = []; + const abort = new AbortController(); + setDefaultFetch(async (input, init) => { + calls.push(urlOf(input)); + expect(init?.signal).toBe(abort.signal); + return Response.json({ + data: [{ ...child, status: "future_status", agent_name: "事件名称" }], + next_page: calls.length === 1 ? "next + / cursor" : null, + }); + }); + const first = await listSessionThreads(context(), "sesn/one", { + limit: 20, + page: "old + cursor", + signal: abort.signal, + }); + expect(calls[0]!.pathname).toBe("/api/v1/agentstudio/sessions/sesn%2Fone/threads"); + expect(Object.fromEntries(calls[0]!.searchParams)).toEqual({ limit: "20", page: "old + cursor" }); + expect(first).toEqual({ + data: [{ ...child, status: "future_status", agent_name: "事件名称" }], + has_more: true, + next_page: "next + / cursor", + }); + const last = await listSessionThreads(context(), "sesn/one", { page: first.next_page, signal: abort.signal }); + expect(calls[1]!.searchParams.get("page")).toBe(first.next_page!); + expect(last.has_more).toBe(false); + expect(last.next_page).toBeUndefined(); +}); + +test("thread snapshots preserve actual owner separately from referenced child and retain complete content", async () => { + const raw = { + id: "evt_forward", + object: "message", + type: "thread_message_sent", + thread_id: "sthr_research", + status: "completed", + created_at: "2026-10-28T00:00:02Z", + metadata: { to_session_thread_id: "sthr_writer", to_agent_name: "Writer" }, + content: [{ type: "data", data: { session_thread_id: "sthr_writer", message: "x".repeat(9000) } }], + }; + let request: URL | undefined; + setDefaultFetch(async (input) => { + request = urlOf(input); + return Response.json({ data: [raw], has_more: true, next_page: "next" }); + }); + const page = await listSessionThreadEvents(context(), "sesn/one", "sthr/research", { + provider: "bailian", + event_format: "snapshot", + limit: 10, + order: "desc", + page: "ignored-alias", + page_token: "current + cursor", + created_at_gte: "2026-10-28T00:00:00Z", + }); + expect(request!.pathname).toBe("/api/v1/agentstudio/sessions/sesn%2Fone/threads/sthr%2Fresearch/events"); + expect(Object.fromEntries(request!.searchParams)).toEqual({ + limit: "10", + order: "desc", + page: "current + cursor", + "created_at[gte]": "2026-10-28T00:00:00Z", + }); + const event = sanitizeSessionEvents(page.events, { redact: false, truncate: false })[0]!; + expect(event.metadata?.thread_id).toBe("sthr_research"); + expect(event.metadata?.session_thread_id).toBe("sthr_writer"); + expect(event.metadata?.to_session_thread_id).toBe("sthr_writer"); + expect(event.content).toEqual(raw.content); + expect(page.events[0]!.raw).toEqual(raw); + expect(page.has_more).toBe(true); + expect(page.next_page).toBe("next"); +}); + +test("thread pages share legacy defaults, snapshot tool correlation, and local type filtering", async () => { + const events = [ + { + id: "evt_call", + object: "message", + type: "tool_call", + thread_id: child.id, + content: [{ type: "data", data: { call_id: "call_one", name: "search", arguments: { query: "test" } } }], + }, + { + id: "evt_output", + object: "message", + type: "tool_call_output", + thread_id: child.id, + content: [{ type: "data", data: { call_id: "call_one", output: "result" } }], + }, + ]; + setDefaultFetch(async (input) => { + expect(urlOf(input).searchParams.has("types")).toBe(false); + return Response.json({ data: events, next_page: "next-page" }); + }); + const legacy = await listSessionThreadEvents(context(), "sesn_one", child.id); + expect(legacy.events[0]?.snapshot).toBeUndefined(); + const page = await listSessionThreadEvents(context(), "sesn_one", child.id, { + event_format: "snapshot", + types: ["tool_call_output"], + }); + expect(page.events).toHaveLength(1); + expect(page.events[0]?.tool_name).toBe("search"); + expect(page.events[0]?.snapshot?.metadata?.tool_name).toBe("search"); + expect(page.next_page).toBe("next-page"); +}); + +for (const operation of ["list", "events"] as const) { + test(`${operation} propagates cancellation to the HTTP request`, async () => { + const abort = new AbortController(); + let reached!: () => void; + const started = new Promise((resolve) => { + reached = resolve; + }); + setDefaultFetch( + async (_input, init) => + new Promise((_resolve, reject) => { + expect(init?.signal).toBe(abort.signal); + init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), { once: true }); + reached(); + }), + ); + const pending = + operation === "list" + ? listSessionThreads(context(), "sesn_one", { signal: abort.signal }) + : listSessionThreadEvents(context(), "sesn_one", child.id, { signal: abort.signal }); + await started; + abort.abort(new Error("request cancelled")); + await expect(pending).rejects.toThrow("request cancelled"); + }); +} + +test("unsupported providers reject thread operations before making a request", async () => { + const ctx = createManagedApiContext({ providers: { qoder: { api_key: "test" } } }); + let requests = 0; + setDefaultFetch(async () => { + requests += 1; + return Response.json({ data: [] }); + }); + await expect(listSessionThreads(ctx, "sesn_one")).rejects.toThrow("does not support session thread listing"); + await expect(listSessionThreadEvents(ctx, "sesn_one", child.id, { event_format: "snapshot" })).rejects.toThrow( + "does not support session thread events", + ); + expect(requests).toBe(0); +}); diff --git a/packages/sdk/tests/unit/sse-transport.test.ts b/packages/sdk/tests/unit/sse-transport.test.ts new file mode 100644 index 0000000..53a1ad5 --- /dev/null +++ b/packages/sdk/tests/unit/sse-transport.test.ts @@ -0,0 +1,295 @@ +import { afterEach, expect, test } from "bun:test"; +import { ApiError, BaseApiClient, SseTransportError } from "../../src/internal/providers/base-client.ts"; +import { SseParser } from "../../src/internal/providers/sse-parser.ts"; + +class TestClient extends BaseApiClient { + protected baseUrl = "https://example.test"; + protected errorPrefix = "test"; + protected paginationStrategy = "page" as const; + protected headers(): Record { + return { Authorization: "Bearer test-provider-key" }; + } +} + +const originalFetch = globalThis.fetch; +afterEach(() => { + globalThis.fetch = originalFetch; +}); + +function mockFetch(implementation: (input: string | URL | Request, init?: RequestInit) => Promise): void { + globalThis.fetch = implementation as typeof fetch; +} + +function byteStream(text: string, split = false): Response { + const bytes = new TextEncoder().encode(text); + return new Response( + new ReadableStream({ + start(controller) { + if (split) for (const byte of bytes) controller.enqueue(new Uint8Array([byte])); + else controller.enqueue(bytes); + controller.close(); + }, + }), + ); +} + +async function collect(stream: AsyncIterable>): Promise[]> { + const events: Record[] = []; + for await (const event of stream) events.push(event); + return events; +} + +for (const ending of ["\n", "\r\n", "\r"]) { + test(`SSE parser supports ${JSON.stringify(ending)} split across network chunks`, async () => { + const frames = [ + ": connected", + "", + "event: heartbeat", + "data: ignored heartbeat payload", + "", + "id: transport-id", + 'data: {"object":"message",', + 'data: "text":"你好 🌍"}', + "", + "", + ].join(ending); + mockFetch(async () => byteStream(frames, true)); + const stream = new TestClient().sse("/events", { strict: true }); + expect((await stream.next()).value).toEqual({ object: "message", text: "你好 🌍" }); + await expect(stream.next()).rejects.toMatchObject({ code: "unexpected-eof", retryable: true }); + }); +} + +test("pure parser keeps transport IDs separate, ignores unknown fields and applies SSE value whitespace", () => { + const parser = new SseParser(); + expect( + parser.push(": comment\r\nretry: 100\r\nid: ignored\0id\r\nevent: update\r\ndata: one\r\ndata: two\r\n\r\n"), + ).toEqual([{ event: "update", data: " one\ntwo", id: undefined }]); + expect(parser.push("data\n\n")).toEqual([{ data: "", event: undefined, id: undefined }]); +}); + +test("legacy SSE preserves identity fallback, tolerant malformed frames and natural EOF", async () => { + mockFetch(async () => + byteStream('data: broken\n\nid: transport\ndata: {"text":"ok"}\n\nid: ignored\ndata: {"id":"message"}\n\n'), + ); + expect(await collect(new TestClient().sse("/events"))).toEqual([{ id: "transport", text: "ok" }, { id: "message" }]); +}); + +for (const json of ["broken", "null", "[]", '"text"']) { + test(`strict SSE rejects invalid event ${json} without leaking frame contents`, async () => { + mockFetch(async () => byteStream(`data: ${json}\n\n`)); + const error = await new TestClient() + .sse("/events", { strict: true }) + .next() + .catch((value) => value); + expect(error).toBeInstanceOf(SseTransportError); + expect(error).toMatchObject({ code: "protocol", retryable: false }); + expect(error.message).toBe("SSE response contains an invalid event"); + }); +} + +test("strict SSE rejects invalid UTF-8 instead of silently altering content", async () => { + mockFetch(async () => new Response(new Uint8Array([0xff]))); + await expect(new TestClient().sse("/events", { strict: true }).next()).rejects.toMatchObject({ code: "protocol" }); +}); + +test("onReady runs before a business frame and iterator return aborts and cancels the response", async () => { + let source!: ReadableStreamDefaultController; + let cancelled = false; + let requestSignal: AbortSignal | undefined; + mockFetch(async (_input, init) => { + requestSignal = init?.signal ?? undefined; + return new Response( + new ReadableStream({ + start(controller) { + source = controller; + }, + cancel() { + cancelled = true; + }, + }), + ); + }); + let connected!: () => void; + const ready = new Promise((resolve) => { + connected = resolve; + }); + const stream = new TestClient().sse("/events", { strict: true, onReady: connected }); + const first = stream.next(); + await ready; + expect(cancelled).toBe(false); + source.enqueue(new TextEncoder().encode('data: {"id":"msg"}\n\n')); + expect((await first).value).toEqual({ id: "msg" }); + await stream.return(undefined); + expect(cancelled).toBe(true); + expect(requestSignal?.aborted).toBe(true); +}); + +for (const status of [400, 401, 403, 429, 500, 503]) { + test(`strict HTTP ${status} exposes safe status and retry classification only`, async () => { + let ready = false; + mockFetch(async () => new Response("provider-secret-key sensitive body", { status })); + const error = await new TestClient() + .sse("/events?key=secret-url", { + strict: true, + onReady: () => { + ready = true; + }, + }) + .next() + .catch((value) => value); + expect(error).toMatchObject({ code: "http", statusCode: status, retryable: status === 429 || status >= 500 }); + expect(String(error)).not.toContain("secret"); + expect(error.responseBody).toBeUndefined(); + expect(error.cause).toBeUndefined(); + expect(ready).toBe(false); + }); +} + +test("legacy HTTP failure retains ApiError status compatibility", async () => { + mockFetch(async () => new Response("missing", { status: 404 })); + const error = await new TestClient() + .sse("/events") + .next() + .catch((value) => value); + expect(error).toBeInstanceOf(ApiError); + expect(error.statusCode).toBe(404); +}); + +test("strict network failure strips provider exception text", async () => { + mockFetch(async () => { + throw new Error("key=secret-provider-key"); + }); + const error = await new TestClient() + .sse("/events", { strict: true }) + .next() + .catch((value) => value); + expect(error).toMatchObject({ code: "network", retryable: true }); + expect(String(error)).not.toContain("secret-provider-key"); + expect(error.cause).toBeUndefined(); +}); + +test("abort before connecting does not make a request or expose the abort reason", async () => { + let requests = 0; + mockFetch(async () => { + requests += 1; + return byteStream(""); + }); + const abort = new AbortController(); + abort.abort(new Error("secret abort reason")); + const error = await new TestClient() + .sse("/events", { strict: true, signal: abort.signal }) + .next() + .catch((value) => value); + expect(error.name).toBe("AbortError"); + expect(String(error)).not.toContain("secret"); + expect(requests).toBe(0); +}); + +test("abort cancels a pending fetch even when custom fetch ignores its signal", async () => { + let requested!: () => void; + const started = new Promise((resolve) => { + requested = resolve; + }); + mockFetch(() => { + requested(); + return new Promise(() => {}); + }); + const abort = new AbortController(); + const next = new TestClient().sse("/events", { strict: true, signal: abort.signal }).next(); + await started; + abort.abort(); + await expect(next).rejects.toMatchObject({ name: "AbortError" }); +}); + +test("abort cancels a pending read and releases the response", async () => { + let cancelled = false; + let connected!: () => void; + const ready = new Promise((resolve) => { + connected = resolve; + }); + mockFetch( + async () => + new Response( + new ReadableStream({ + cancel() { + cancelled = true; + }, + }), + ), + ); + const abort = new AbortController(); + const next = new TestClient().sse("/events", { strict: true, signal: abort.signal, onReady: connected }).next(); + await ready; + abort.abort(); + await expect(next).rejects.toMatchObject({ name: "AbortError" }); + expect(cancelled).toBe(true); +}); + +test("connection and idle timeouts are classified and cancel the request", async () => { + let signal: AbortSignal | null | undefined; + mockFetch((_input, init) => { + signal = init?.signal; + return new Promise(() => {}); + }); + await expect(new TestClient().sse("/events", { strict: true, connectTimeoutMs: 5 }).next()).rejects.toMatchObject({ + code: "connect-timeout", + retryable: true, + }); + expect(signal?.aborted).toBe(true); + let cancelled = false; + mockFetch( + async () => + new Response( + new ReadableStream({ + cancel() { + cancelled = true; + }, + }), + ), + ); + await expect(new TestClient().sse("/events", { strict: true, idleTimeoutMs: 5 }).next()).rejects.toMatchObject({ + code: "idle-timeout", + retryable: true, + }); + expect(cancelled).toBe(true); +}); + +test("comment and heartbeat bytes keep a quiet subscription active", async () => { + let source!: ReadableStreamDefaultController; + mockFetch( + async () => + new Response( + new ReadableStream({ + start(controller) { + source = controller; + }, + }), + ), + ); + const stream = new TestClient().sse("/events", { strict: true, idleTimeoutMs: 60 }); + const next = stream.next(); + for (let index = 0; index < 5; index += 1) { + await new Promise((resolve) => setTimeout(resolve, 20)); + source.enqueue(new TextEncoder().encode(": heartbeat\n\nevent: heartbeat\ndata: {}\n\n")); + } + source.enqueue(new TextEncoder().encode('data: {"id":"msg"}\n\n')); + expect((await next).value).toEqual({ id: "msg" }); + await stream.return(undefined); +}); + +test("strict streams without a response body fail before readiness", async () => { + let ready = false; + mockFetch(async () => new Response(null, { status: 204 })); + await expect( + new TestClient() + .sse("/events", { + strict: true, + onReady: () => { + ready = true; + }, + }) + .next(), + ).rejects.toMatchObject({ code: "protocol", retryable: false }); + expect(ready).toBe(false); +}); diff --git a/packages/sdk/tests/unit/state-persistence-callback.test.ts b/packages/sdk/tests/unit/state-persistence-callback.test.ts new file mode 100644 index 0000000..efcebed --- /dev/null +++ b/packages/sdk/tests/unit/state-persistence-callback.test.ts @@ -0,0 +1,38 @@ +import { expect, test } from "bun:test"; +import { InMemoryStateManager, type StateFile } from "../../src/index.ts"; + +const initial: StateFile = { + resources: [ + { address: { type: "agent", name: "assistant", provider: "bailian" }, remote_id: "agent_1", content_hash: "hash" }, + ], +}; + +test("public memory state detaches imported/exported snapshots and checkpoints at save time", async () => { + const checkpoints: StateFile[] = []; + const state = InMemoryStateManager.fromJSON(initial, async (snapshot) => { + checkpoints.push(snapshot); + }); + state.getResource(initial.resources[0]!.address)!.version = 2; + const first = state.save(); + state.getResource(initial.resources[0]!.address)!.version = 3; + await Promise.all([first, state.save()]); + expect(checkpoints.map((snapshot) => snapshot.resources[0]!.version)).toEqual([2, 3]); + expect(initial.resources[0]!.version).toBeUndefined(); + const exported = state.toJSON(); + exported.resources.length = 0; + expect(state.listResources()).toHaveLength(1); + expect( + InMemoryStateManager.fromJSON(checkpoints[1]!).findResource({ type: "agent", name: "assistant" })?.version, + ).toBe(3); +}); + +test("checkpoint failures propagate and later saves remain usable; default save stays in memory", async () => { + let fail = true; + const state = InMemoryStateManager.empty(() => { + if (fail) throw new Error("storage unavailable"); + }); + await expect(state.save()).rejects.toThrow("storage unavailable"); + fail = false; + await state.save(); + await InMemoryStateManager.empty().save(); +}); diff --git a/packages/sdk/tests/unit/validate-config.test.ts b/packages/sdk/tests/unit/validate-config.test.ts index 53d19ea..502563f 100644 --- a/packages/sdk/tests/unit/validate-config.test.ts +++ b/packages/sdk/tests/unit/validate-config.test.ts @@ -125,7 +125,7 @@ test("limits Agent environment variables to Qoder", () => { expect(diagnostics.some((d) => d.code === "claude.agent.environment_variables.unsupported")).toBe(true); }); -test("rejects tool approval and GitHub Session resources on unsupported providers", () => { +test("accepts Bailian tool approval while rejecting unsupported GitHub Session resources", () => { const config: ProjectConfig = { version: "1", providers: { bailian: {} }, @@ -147,7 +147,7 @@ test("rejects tool approval and GitHub Session resources on unsupported provider }; const diagnostics = validateProjectConfig(config); - expect(diagnostics.some((item) => item.code === "bailian.agent.tool_permissions.unsupported")).toBe(true); + expect(diagnostics.some((item) => item.code === "bailian.agent.tool_permissions.unsupported")).toBe(false); expect(diagnostics.some((item) => item.code === "bailian.agent.session_resource.github_repository.unsupported")).toBe( true, ); diff --git a/patches/@redocly%2Fopenapi-core@1.34.22.patch b/patches/@redocly%2Fopenapi-core@1.34.22.patch new file mode 100644 index 0000000..004aef3 --- /dev/null +++ b/patches/@redocly%2Fopenapi-core@1.34.22.patch @@ -0,0 +1,12 @@ +diff --git a/lib/utils.js b/lib/utils.js +--- a/lib/utils.js ++++ b/lib/utils.js +@@ -39,7 +39,7 @@ exports.getProxyAgent = getProxyAgent; + exports.dequal = dequal; + const fs = require("fs"); + const path_1 = require("path"); +-const minimatch = require("minimatch"); ++const { minimatch } = require("minimatch"); + const js_yaml_1 = require("./js-yaml"); + const env_1 = require("./env"); + const logger_1 = require("./logger"); diff --git a/scripts/release/smoke-packed.ts b/scripts/release/smoke-packed.ts index f56f29e..13efec9 100644 --- a/scripts/release/smoke-packed.ts +++ b/scripts/release/smoke-packed.ts @@ -152,7 +152,7 @@ async function main(): Promise { "node", "--input-type=module", "--eval", - 'await import("@openagentpack/sdk"); await import("@openagentpack/sdk/session-events"); await import("@openagentpack/sdk/scan-lifecycle"); await import("@openagentpack/sdk/file-lifecycle"); const versions = await import("@openagentpack/sdk/project-versions"); const workspace = await import("@openagentpack/sdk/project-workspace"); if (typeof versions.createProjectVersionService !== "function") throw new Error("project-versions export missing"); if (typeof workspace.previewProjectBuild !== "function") throw new Error("project-workspace export missing");', + 'const sdk = await import("@openagentpack/sdk"); for (const method of ["listSessionThreads", "listSessionThreadEvents"]) { if (typeof sdk[method] !== "function") throw new Error(method + " export missing"); } await import("@openagentpack/sdk/session-events"); await import("@openagentpack/sdk/scan-lifecycle"); await import("@openagentpack/sdk/file-lifecycle"); const versions = await import("@openagentpack/sdk/project-versions"); const workspace = await import("@openagentpack/sdk/project-workspace"); if (typeof versions.createProjectVersionService !== "function") throw new Error("project-versions export missing"); if (typeof workspace.previewProjectBuild !== "function") throw new Error("project-workspace export missing");', ], consumer, );