@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.3

package/dist/conversations/event-log.d.ts

@@ -1,8 +1,8 @@
-import type { Logger } from "@capybara-hq/plugin-sdk";
-import { type Transaction } from "kysely";
-import type { KernelDatabase, KernelDb } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import type { KernelLogger } from "../log.js";
 import { type ConversationEvent, type ConversationEventType } from "./events.js";
-type Trx = Transaction<KernelDatabase>;
 /** 事件日志依赖的总线：内核 bus（命名空间 `kernel`）。 */
 export interface EventBus {
     publish(topic: string, payload: unknown): Promise<void>;
@@ -70,28 +70,35 @@ export type ConversationChange = (typeof CONVERSATION_CHANGES)[number];
  * 会话事件日志：只追加，是 agent 运行的唯一事实来源。
  * seq 由 `conversations.last_seq` 在会话行锁内连续分配（多副本并发写同一会话时串行化）；
  * 幂等键的「先查后写」也在同一把行锁内完成。
+ *
+ * Every published advance (`notify`) is also announced in-process as `conversation.event-appended`
+ * on {@link KernelEvents} (the channel outbound delivery enqueues from it), on this replica, right
+ * after the bus publish, in append order.
  */
 export declare class EventLog {
     private readonly db;
     private readonly bus;
-    private readonly log?;
+    private readonly log;
+    private readonly events;
+    readonly txHost: TransactionHost;
+    constructor(db: KernelDb, bus: EventBus, log: Pick<KernelLogger, "warn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
     /**
-     * 每次发布「日志已推进」之后调用（同步、不等待）：内核用它给有 IM 投递目标的会话排出站任务。
-     * 钩子自己负责吞掉错误。
+     * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
+     * 自开一个独立事务（`requires_new`，与调用方的事务无关），提交后发布 `conv.<id>`。
+     * 要在调用方的事务里追加（与其他写入一起提交），用 {@link appendIn}。
      */
-    private readonly onNotify?;
-    constructor(db: KernelDb, bus: EventBus, log?: Pick<Logger, "warn"> | undefined, 
+    append(conversationId: string, events: AppendEvent[]): Promise<ConversationEvent[]>;
     /**
-     * 每次发布「日志已推进」之后调用（同步、不等待）：内核用它给有 IM 投递目标的会话排出站任务。
-     * 钩子自己负责吞掉错误。
+     * {@link append} inside the caller's transaction (it must hold one: `mandatory`): the events
+     * commit or roll back with the caller's writes, and the caller calls {@link notify} after the
+     * commit with the highest seq it wrote.
      */
-    onNotify?: ((conversationId: string, toSeq: number) => void) | undefined);
+    appendIn(conversationId: string, events: AppendEvent[]): Promise<ConversationEvent[]>;
+    private appendOwn;
     /**
-     * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
-     * 不传 `trx` 时自开事务，提交后发布 `conv.<id>`；传入外部 `trx` 时由调用方在提交后调用 `notify`。
+     * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces
+     * it in-process (`conversation.event-appended`); a failing subscriber is logged by KernelEvents.
      */
-    append(conversationId: string, events: AppendEvent[], trx?: Trx): Promise<ConversationEvent[]>;
-    /** 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。 */
     notify(conversationId: string, toSeq: number): Promise<void>;
     /**
      * Publishes a `changed` frame on the conversation topic (rename, generated title, selection, ...).
@@ -116,7 +123,21 @@ export declare class EventLog {
     latestOfType<T extends ConversationEventType>(conversationId: string, type: T): Promise<Extract<ConversationEvent, {
         type: T;
     }> | undefined>;
+    /**
+     * The file state (`tool_result.view.file`) the latest `Read` / `Write` / `Edit` result of this
+     * conversation recorded for `path` (a normalized sandbox path); null when none did. One index
+     * probe per call: the partial index `conversation_events_file_state_idx` of migration 0063
+     * (conversation_id, view.file.path, seq DESC; tool_result rows only) answers it, also for a path
+     * never read (the query's predicate must keep matching that index's expression).
+     */
+    latestFileState(conversationId: string, path: string): Promise<{
+        size: number;
+        sha256: string;
+    } | null>;
     private validate;
-    private appendIn;
+    /** The append itself, in the context's transaction (both callers open or join one). */
+    private write;
+}
+/** The one {@link EventLog} (infra dependencies only, so every domain can import it). */
+export declare class EventLogModule {
 }
-export {};

package/dist/conversations/event-log.js

@@ -1,5 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Module } from "@nestjs/common";
 import { sql } from "kysely";
 import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { ConversationEventSchema, } from "./events.js";
 /**
  * The JSON stored for an event payload, with every NUL (U+0000) in a string or an object key
@@ -50,53 +65,61 @@ const EVENT_COLUMNS = [
  * 会话事件日志：只追加，是 agent 运行的唯一事实来源。
  * seq 由 `conversations.last_seq` 在会话行锁内连续分配（多副本并发写同一会话时串行化）；
  * 幂等键的「先查后写」也在同一把行锁内完成。
+ *
+ * Every published advance (`notify`) is also announced in-process as `conversation.event-appended`
+ * on {@link KernelEvents} (the channel outbound delivery enqueues from it), on this replica, right
+ * after the bus publish, in append order.
  */
-export class EventLog {
+let EventLog = class EventLog {
     db;
     bus;
     log;
-    onNotify;
-    constructor(db, bus, log, 
-    /**
-     * 每次发布「日志已推进」之后调用（同步、不等待）：内核用它给有 IM 投递目标的会话排出站任务。
-     * 钩子自己负责吞掉错误。
-     */
-    onNotify) {
+    events;
+    txHost;
+    constructor(db, bus, log, events, txHost) {
         this.db = db;
         this.bus = bus;
         this.log = log;
-        this.onNotify = onNotify;
+        this.events = events;
+        this.txHost = txHost;
     }
     /**
      * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
-     * 不传 `trx` 时自开事务，提交后发布 `conv.<id>`；传入外部 `trx` 时由调用方在提交后调用 `notify`。
+     * 自开一个独立事务（`requires_new`，与调用方的事务无关），提交后发布 `conv.<id>`。
+     * 要在调用方的事务里追加（与其他写入一起提交），用 {@link appendIn}。
      */
-    async append(conversationId, events, trx) {
+    async append(conversationId, events) {
         const bodies = events.map((e) => this.validate(e));
-        if (trx)
-            return (await this.appendIn(trx, conversationId, events, bodies)).events;
-        const { events: out, toSeq } = await this.db
-            .transaction()
-            .execute((t) => this.appendIn(t, conversationId, events, bodies));
+        const { events: out, toSeq } = await this.appendOwn(conversationId, events, bodies);
         if (toSeq !== null)
             await this.notify(conversationId, toSeq);
         return out;
     }
-    /** 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。 */
+    /**
+     * {@link append} inside the caller's transaction (it must hold one: `mandatory`): the events
+     * commit or roll back with the caller's writes, and the caller calls {@link notify} after the
+     * commit with the highest seq it wrote.
+     */
+    async appendIn(conversationId, events) {
+        const bodies = events.map((e) => this.validate(e));
+        return (await this.write(conversationId, events, bodies)).events;
+    }
+    async appendOwn(conversationId, events, bodies) {
+        return this.write(conversationId, events, bodies);
+    }
+    /**
+     * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces
+     * it in-process (`conversation.event-appended`); a failing subscriber is logged by KernelEvents.
+     */
     async notify(conversationId, toSeq) {
         const msg = { kind: "events", toSeq };
         try {
             await this.bus.publish(conversationTopic(conversationId), msg);
         }
         catch (err) {
-            this.log?.warn("conversation event notify failed", { conversationId, toSeq, err });
-        }
-        try {
-            this.onNotify?.(conversationId, toSeq);
-        }
-        catch (err) {
-            this.log?.warn("conversation event notify hook failed", { conversationId, err });
+            this.log.warn("conversation event notify failed", { conversationId, toSeq, err });
         }
+        await this.events.emit("conversation.event-appended", { conversationId, toSeq });
     }
     /**
      * Publishes a `changed` frame on the conversation topic (rename, generated title, selection, ...).
@@ -108,7 +131,7 @@ export class EventLog {
             await this.bus.publish(conversationTopic(conversationId), msg);
         }
         catch (err) {
-            this.log?.warn("conversation change publish failed", { conversationId, what, err });
+            this.log.warn("conversation change publish failed", { conversationId, what, err });
         }
     }
     /** 读 `afterSeq` 之后的事件，按 seq 升序，最多 `limit` 条。 */
@@ -168,6 +191,25 @@ export class EventLog {
             .executeTakeFirst();
         return r && toEvent(r);
     }
+    /**
+     * The file state (`tool_result.view.file`) the latest `Read` / `Write` / `Edit` result of this
+     * conversation recorded for `path` (a normalized sandbox path); null when none did. One index
+     * probe per call: the partial index `conversation_events_file_state_idx` of migration 0063
+     * (conversation_id, view.file.path, seq DESC; tool_result rows only) answers it, also for a path
+     * never read (the query's predicate must keep matching that index's expression).
+     */
+    async latestFileState(conversationId, path) {
+        const r = await this.db
+            .selectFrom("conversation_events")
+            .select(sql `payload->'view'->'file'`.as("file"))
+            .where("conversation_id", "=", conversationId)
+            .where("type", "=", "tool_result")
+            .where(sql `payload->'view'->'file'->>'path' = ${path}`)
+            .orderBy("seq", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        return r ? { size: r.file.size, sha256: r.file.sha256 } : null;
+    }
     validate(e) {
         const r = ConversationEventSchema.safeParse({ type: e.type, payload: e.payload });
         if (!r.success) {
@@ -175,7 +217,9 @@ export class EventLog {
         }
         return r.data;
     }
-    async appendIn(t, conversationId, events, bodies) {
+    /** The append itself, in the context's transaction (both callers open or join one). */
+    async write(conversationId, events, bodies) {
+        const t = this.db;
         // 先锁会话行：之后的幂等查询与 seq 分配都在这把锁内，并发 append 依次执行。
         const conv = await t
             .selectFrom("conversations")
@@ -256,4 +300,26 @@ export class EventLog {
             toSeq,
         };
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EventLog.prototype, "appendIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EventLog.prototype, "appendOwn", null);
+EventLog = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(KERNEL_BUS)),
+    __param(2, Inject(KERNEL_LOGGER)),
+    __param(3, Inject(KernelEvents)),
+    __param(4, Inject(TransactionHost))
+], EventLog);
+export { EventLog };
+/** The one {@link EventLog} (infra dependencies only, so every domain can import it). */
+let EventLogModule = class EventLogModule {
+};
+EventLogModule = __decorate([
+    Module({ providers: [EventLog], exports: [EventLog] })
+], EventLogModule);
+export { EventLogModule };

package/dist/conversations/events.d.ts

@@ -86,10 +86,10 @@ export type LogContentBlock = Exclude<ContentBlock, MediaBlock> | (MediaBlock ex
 } : never : never);
 /**
  * Structured view of a builtin tool's result (UI refresh B, spec §5.5 / §5.9): display only, like
- * `display`. `command`: `sandbox_bash` (the model's `description`, the exit code, null when the
+ * `display`. `command`: `Bash` (the model's `description`, the exit code, null when the
  * command was stopped, and whether it timed out; the web shows "Failed" for a non-zero exit even
- * though `isError` stays false); `edit`: `sandbox_edit` / `sandbox_write` (a capped line diff);
- * `read`: `sandbox_read` (the line range shown).
+ * though `isError` stays false); `edit`: `Edit` / `Write` (a capped line diff);
+ * `read`: `Read` (the line range shown).
  */
 export declare const ToolViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"command">;
@@ -103,6 +103,11 @@ export declare const ToolViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     added: z.ZodNumber;
     removed: z.ZodNumber;
     truncated: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodString;
+    }, z.core.$strip>>;
     hunks: z.ZodArray<z.ZodObject<{
         oldStart: z.ZodNumber;
         newStart: z.ZodNumber;
@@ -120,6 +125,11 @@ export declare const ToolViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     path: z.ZodString;
     fromLine: z.ZodOptional<z.ZodNumber>;
     toLine: z.ZodOptional<z.ZodNumber>;
+    file: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "kind">;
 export type ToolView = z.infer<typeof ToolViewSchema>;
 /**
@@ -441,6 +451,11 @@ export declare const ConversationEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             added: z.ZodNumber;
             removed: z.ZodNumber;
             truncated: z.ZodBoolean;
+            file: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+                size: z.ZodNumber;
+                sha256: z.ZodString;
+            }, z.core.$strip>>;
             hunks: z.ZodArray<z.ZodObject<{
                 oldStart: z.ZodNumber;
                 newStart: z.ZodNumber;
@@ -458,6 +473,11 @@ export declare const ConversationEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             path: z.ZodString;
             fromLine: z.ZodOptional<z.ZodNumber>;
             toLine: z.ZodOptional<z.ZodNumber>;
+            file: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+                size: z.ZodNumber;
+                sha256: z.ZodString;
+            }, z.core.$strip>>;
         }, z.core.$strip>], "kind">>;
         card: z.ZodOptional<z.ZodObject<{
             plugin: z.ZodString;

package/dist/conversations/events.js

@@ -75,12 +75,22 @@ const STOP_REASONS = ["end_turn", "tool_use", "max_tokens", "refusal", "other"];
 const EFFORT_ENUM = ["low", "medium", "high", "xhigh", "max"];
 const seqNo = z.number().int().nonnegative();
 const count = z.number().int().nonnegative();
+/**
+ * The state of a file a `Read` / `Write` / `Edit` saw or left (display only, but the kernel reads it
+ * back from the log to decide read-before-write): the full normalized path, the file's full size and
+ * the sha256 of the bytes handled (the first bytes only for a file over `Read`'s byte limit).
+ */
+const FileStateViewSchema = z.object({
+    path: z.string().max(4096),
+    size: count,
+    sha256: z.string().regex(/^[0-9a-f]{64}$/),
+});
 /**
  * Structured view of a builtin tool's result (UI refresh B, spec §5.5 / §5.9): display only, like
- * `display`. `command`: `sandbox_bash` (the model's `description`, the exit code, null when the
+ * `display`. `command`: `Bash` (the model's `description`, the exit code, null when the
  * command was stopped, and whether it timed out; the web shows "Failed" for a non-zero exit even
- * though `isError` stays false); `edit`: `sandbox_edit` / `sandbox_write` (a capped line diff);
- * `read`: `sandbox_read` (the line range shown).
+ * though `isError` stays false); `edit`: `Edit` / `Write` (a capped line diff);
+ * `read`: `Read` (the line range shown).
  */
 export const ToolViewSchema = z.discriminatedUnion("kind", [
     z.object({
@@ -96,6 +106,7 @@ export const ToolViewSchema = z.discriminatedUnion("kind", [
         added: count,
         removed: count,
         truncated: z.boolean(),
+        file: FileStateViewSchema.optional(),
         hunks: z
             .array(z.object({
             oldStart: count,
@@ -114,6 +125,7 @@ export const ToolViewSchema = z.discriminatedUnion("kind", [
         path: z.string().max(TOOL_VIEW_PATH_MAX_CHARS),
         fromLine: count.optional(),
         toLine: count.optional(),
+        file: FileStateViewSchema.optional(),
     }),
 ]);
 const ModelUsageShape = {
@@ -260,13 +272,13 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
              */
             absorbedUpToSeq: seqNo.optional(),
             /**
-             * 本次请求带给模型的工具（按发送顺序：未启用 tool_search 时按 key 排序；启用时为内置工具按 key 排序，
+             * 本次请求带给模型的工具（按发送顺序：未启用 ToolSearch 时按 key 排序；启用时为内置工具按 key 排序，
              * 其后是已加载工具按首次加载顺序）及其定义指纹（`ResolvedTool.specHash`）。
              * 模型不支持工具时为空数组。较早的事件可能没有。
              */
             tools: z.array(z.object({ key: z.string(), specHash: z.string() })).optional(),
             /**
-             * 启用 tool_search 时 system 第二块目录里的工具（按 key 排序）及定义指纹；定义同样存在
+             * 启用 ToolSearch 时 system 第二块目录里的工具（按 key 排序）及定义指纹；定义同样存在
              * `capybara.tool_specs`，目录文本可由它们还原。未启用时不写。
              */
             catalog: z.array(z.object({ key: z.string(), specHash: z.string() })).optional(),
@@ -339,7 +351,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         outputId: z.string().optional(),
         contentTypes: z.array(z.string()).optional(),
         /**
-         * `tool_search` 本次加载的工具 key（没有匹配时不写）。已加载集合 = 会话中全部 tool_result 的
+         * `ToolSearch` 本次加载的工具 key（没有匹配时不写）。已加载集合 = 会话中全部 tool_result 的
          * `loadedTools` 并集（含已被摘要覆盖的部分），构建请求时由日志还原，不放进程内存。
          */
         loadedTools: z.array(z.string()).optional(),
@@ -395,7 +407,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         reason: z.string().max(APPROVAL_DENY_REASON_MAX_CHARS).optional(),
     })),
     /**
-     * 工具调用需要用户输入（`ask_user`、插件工具的 `input_required`、MCP elicitation）：输入请求已建，
+     * 工具调用需要用户输入（`AskUserQuestion`、插件工具的 `input_required`、MCP elicitation）：输入请求已建，
      * run 暂停等待回答。界面据此显示表单卡片（不进模型请求）。
      */
     ev("question_asked", z.object({
@@ -423,7 +435,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         reason: z.enum(["provider_rejected"]),
     })),
     /**
-     * agent 经 `sandbox_deliver` 把沙箱里的文件交付给用户（M5 T8，C3）：字节在对象存储
+     * agent 经 `Deliver` 把沙箱里的文件交付给用户（M5 T8，C3）：字节在对象存储
      * `kernel/<orgId>/<objectKey>`（`objectKey` = `artifacts/<conversationId>/<artifactId>`，相对内核前缀），
      * 这里只有元数据。网页从日志重建产物列表；不进模型请求（模型看到的是同一调用的 tool_result 确认）。
      */
@@ -439,7 +451,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
     /**
      * 本对话此刻生效的技能（M5 T14，Ruling M17）：运行开始时内核解析生效的技能集合（agent 版本选中的组织技能 +
      * agent 自己的技能，未删除，取 current_version），与日志里上一份快照不同才写。模型看到的技能目录只来自这里：
-     * 第一份（在任何 `model_call` 之前）进 system 缓存段，之后的在所在位置渲染为英文变更提醒；`skill_load` 按最新一份
+     * 第一份（在任何 `model_call` 之前）进 system 缓存段，之后的在所在位置渲染为英文变更提醒；`Skill` 按最新一份
      * 把名字解析为 id 与版本。按 name 排序。
      */
     ev("skills_catalog", z.object({
@@ -451,12 +463,12 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
             version: z.number().int().positive(),
             /**
              * 内容来源（对象前缀，T15）：已生成的版本为 `skill_versions.object_prefix`，试用中的草稿为申请的
-             * `object_prefix`。同号的草稿与正式版本靠它区分；`skill_load` 只按它解析。
+             * `object_prefix`。同号的草稿与正式版本靠它区分；`Skill` 只按它解析。
              */
             source: z.string().min(1).max(512),
             /**
              * The catalog item (plugin) name the skill came from (phase B); absent for the org's
-             * own and the agent's skills, and in snapshots written before phase B. `skill_load`
+             * own and the agent's skills, and in snapshots written before phase B. `Skill`
              * resolves `<plugin>:<name>` with it; it is not model-visible otherwise.
              */
             plugin: z.string().min(1).max(64).optional(),
@@ -465,7 +477,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         /**
          * Pinned skills (phase B, spec §9.1) in the agent's order: each a skill of `skills` (same
          * id, version and source) with its SKILL.md body as read at run start or written by
-         * skill_write. Absent means none (every snapshot before phase B).
+         * SkillWrite. Absent means none (every snapshot before phase B).
          */
         pinned: z
             .array(z.object({
@@ -534,7 +546,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         warnings: z.array(z.string()).optional(),
     })),
     /**
-     * Parent log (phase C, spec §14.1): the `agent` call `callId` started (or resumed) the sub-agent
+     * Parent log (phase C, spec §14.1): the `Agent` call `callId` started (or resumed) the sub-agent
      * `subagentId` (its child conversation id) with run `childRunId`. Not model-visible: the model
      * sees the call's tool_call / tool_result pair.
      */
@@ -550,7 +562,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         tierFallback: z.boolean().optional(),
         /**
          * Phase D: the seq of the person's fork invocation this dispatch runs (`callId` is
-         * `skill-<seq>`, step 0, no tool call); absent for an `agent` call.
+         * `skill-<seq>`, step 0, no tool call); absent for an `Agent` call.
          */
         invokedSeq: seqNo.optional(),
     })),

package/dist/conversations/files.d.ts

@@ -1,5 +1,6 @@
-import type { KernelDb } from "../db/kernel-schema.js";
-import type { StorageService } from "../storage/storage.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { StorageService } from "../storage/storage.service.js";
+import { ConversationAccess } from "./access.js";
 /**
  * A conversation's file outputs (UI refresh B, spec §5.8 / §5.9): the files the agent delivered
  * (`artifact_created`), grouped by `sourcePath` into versions, newest first. Read from the log on
@@ -44,17 +45,16 @@ export interface FileContent {
     originalType: string;
     truncated: boolean;
 }
-export interface ConversationFilesDeps {
-    db: KernelDb;
-    storage: Pick<StorageService, "kernel">;
-    /** Same visibility as the event stream (`ConversationsService.isAccessible`). */
-    isAccessible(orgId: string, conversationId: string, viewerAccountId: string): Promise<boolean>;
-}
 /** Storage HEADs a files list sends at once (review M1). */
 export declare const HEAD_CONCURRENCY = 8;
 export declare class ConversationFiles {
-    private readonly d;
-    constructor(d: ConversationFilesDeps);
+    private readonly db;
+    private readonly storage;
+    /** Same visibility as the event stream. */
+    private readonly access;
+    constructor(db: KernelDb, storage: Pick<StorageService, "kernel">, 
+    /** Same visibility as the event stream. */
+    access: Pick<ConversationAccess, "isAccessible">);
     private checkAccess;
     /** Every delivery of the conversation in log order. */
     private deliveries;

package/dist/conversations/files.js

@@ -1,6 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { StorageService } from "../storage/storage.service.js";
 import { UUID_RE } from "../ui/registry.js";
+import { ConversationAccess } from "./access.js";
 import { isInlineArtifactType, isTextArtifactType } from "./artifacts.js";
 /**
  * A conversation's file outputs (UI refresh B, spec §5.8 / §5.9): the files the agent delivered
@@ -65,20 +78,26 @@ async function mapLimit(xs, limit, fn) {
     await Promise.all(Array.from({ length: Math.min(limit, xs.length) }, worker));
     return out;
 }
-export class ConversationFiles {
-    d;
-    constructor(d) {
-        this.d = d;
+let ConversationFiles = class ConversationFiles {
+    db;
+    storage;
+    access;
+    constructor(db, storage, 
+    /** Same visibility as the event stream. */
+    access) {
+        this.db = db;
+        this.storage = storage;
+        this.access = access;
     }
     async checkAccess(orgId, conversationId, viewer) {
         if (!UUID_RE.test(conversationId))
             throw conversationNotFound();
-        if (!(await this.d.isAccessible(orgId, conversationId, viewer)))
+        if (!(await this.access.isAccessible(orgId, conversationId, viewer)))
             throw conversationNotFound();
     }
     /** Every delivery of the conversation in log order. */
     async deliveries(conversationId) {
-        const rows = await this.d.db
+        const rows = await this.db
             .selectFrom("conversation_events")
             .select(["payload", "created_at"])
             .where("conversation_id", "=", conversationId)
@@ -115,7 +134,7 @@ export class ConversationFiles {
             start = at + 1;
         }
         const page = ordered.slice(start, start + opts.limit);
-        const store = this.d.storage.kernel(orgId);
+        const store = this.storage.kernel(orgId);
         const files = await mapLimit(page, HEAD_CONCURRENCY, async (g) => {
             const latest = g.at(-1);
             const head = await store.head(latest.objectKey);
@@ -152,7 +171,7 @@ export class ConversationFiles {
         await this.checkAccess(orgId, conversationId, viewer);
         if (!UUID_RE.test(fileId))
             throw artifactNotFound();
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("conversation_events")
             .select("payload")
             .where("conversation_id", "=", conversationId)
@@ -180,7 +199,7 @@ export class ConversationFiles {
         await this.checkAccess(orgId, conversationId, viewer);
         if (!UUID_RE.test(fileId))
             throw artifactNotFound();
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("conversation_events")
             .select("payload")
             .where("conversation_id", "=", conversationId)
@@ -195,7 +214,7 @@ export class ConversationFiles {
             throw new ApiError("conversation.artifact_not_previewable", "Only text files have content");
         }
         const max = Math.min(limit, FILE_CONTENT_MAX_BYTES);
-        const got = await this.d.storage
+        const got = await this.storage
             .kernel(orgId)
             .get(a.objectKey, { range: { start: 0, end: max - 1 } });
         if (!got)
@@ -210,4 +229,11 @@ export class ConversationFiles {
         const base = (a.contentType.split(";")[0] ?? "").trim().toLowerCase();
         return { body, contentType: "text/plain; charset=utf-8", originalType: base, truncated };
     }
-}
+};
+ConversationFiles = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(StorageService)),
+    __param(2, Inject(ConversationAccess))
+], ConversationFiles);
+export { ConversationFiles };

package/dist/conversations/idem-keys.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 用户消息的幂等键：客户端的 `clientMessageId` 加前缀，与运行流水线自用的幂等键分开，
+ * 避免客户端恰好选中内部键而命中别的事件。
+ */
+export declare const userMessageIdemKey: (clientMessageId: string) => string;

package/dist/conversations/idem-keys.js

@@ -0,0 +1,5 @@
+/**
+ * 用户消息的幂等键：客户端的 `clientMessageId` 加前缀，与运行流水线自用的幂等键分开，
+ * 避免客户端恰好选中内部键而命中别的事件。
+ */
+export const userMessageIdemKey = (clientMessageId) => `msg:${clientMessageId}`;

package/dist/conversations/job-ids.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The maintenance job scheduler ids the attachment cleanup had before becoming `@LockedCron` /
+ * `@LockedInterval` jobs (retired at worker start, `RETIRED_SCHEDULER_IDS`). A leaf module.
+ */
+/** The retired BullMQ repeatable scheduler of the cleanup (removed from Redis at worker start). */
+export declare const ATTACHMENT_CLEANUP_SCHEDULER_ID = "attachment-cleanup-hourly";

package/dist/conversations/job-ids.js

@@ -0,0 +1,6 @@
+/**
+ * The maintenance job scheduler ids the attachment cleanup had before becoming `@LockedCron` /
+ * `@LockedInterval` jobs (retired at worker start, `RETIRED_SCHEDULER_IDS`). A leaf module.
+ */
+/** The retired BullMQ repeatable scheduler of the cleanup (removed from Redis at worker start). */
+export const ATTACHMENT_CLEANUP_SCHEDULER_ID = "attachment-cleanup-hourly";