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

package/dist/runtime/runtime.module.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The run runtime: the conversation run lock, this process's event streams, the run queue and its
+ * worker (consumed through `RuntimeWorkersModule`'s processors), the waits (their sweep is the
+ * worker role's `WaitSweepJob`), run
+ * stops, the checkpoints, the org quotas, the step writes and the agent loops. The model provider
+ * registry, the sub-agent dispatch, `usage.report` and the titles have modules of their own (the
+ * tools, models and conversations domains import them without the runtime).
+ */
+export declare class RuntimeModule {
+}

package/dist/runtime/runtime.module.js

@@ -0,0 +1,122 @@
+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;
+};
+import { Module } from "@nestjs/common";
+import { BackgroundModule } from "../background/background.module.js";
+import { BackgroundWake } from "../background/wake.js";
+import { ConversationAccessModule } from "../conversations/access.js";
+import { AttachmentsModule } from "../conversations/attachments.module.js";
+import { EventLogModule } from "../conversations/event-log.js";
+import { TitlesModule } from "../conversations/titles.js";
+import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { IdentityModule } from "../identity/identity.module.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { REDIS } from "../infra/tokens.js";
+import { SkillsModule } from "../skills/skills.module.js";
+import { ToolsModule } from "../tools/tools.module.js";
+import { RunAbort } from "./abort.js";
+import { KyselyCheckpointSaver } from "./checkpointer.js";
+import { ConversationLock } from "./conversation-lock.js";
+import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
+import { ProvidersModule } from "./providers.js";
+import { EVAL_QUOTA, EVAL_QUOTA_PREFIX, OrgQuota, RUN_QUOTA, RUN_QUOTA_PREFIX } from "./quota.js";
+import { RunContextService } from "./run-context.service.js";
+import { RunControl } from "./run-control.js";
+import { RunDrafts } from "./run-drafts.js";
+import { RunFinish } from "./run-finish.js";
+import { RunJobsModule } from "./run-jobs.js";
+import { RunQueue } from "./run-queue.js";
+import { AgentLoops, RunSteps } from "./run-steps.js";
+import { RunWorker } from "./run-worker.js";
+import { StepLogModule } from "./step-log.js";
+import { ConversationStreams } from "./stream.js";
+import { SubagentsModule } from "./subagents/subagents.service.js";
+import { UsageReportModule } from "./usage-report.js";
+import { DecisionResumer, Waits } from "./waits.js";
+/**
+ * The run runtime: the conversation run lock, this process's event streams, the run queue and its
+ * worker (consumed through `RuntimeWorkersModule`'s processors), the waits (their sweep is the
+ * worker role's `WaitSweepJob`), run
+ * stops, the checkpoints, the org quotas, the step writes and the agent loops. The model provider
+ * registry, the sub-agent dispatch, `usage.report` and the titles have modules of their own (the
+ * tools, models and conversations domains import them without the runtime).
+ */
+let RuntimeModule = class RuntimeModule {
+};
+RuntimeModule = __decorate([
+    Module({
+        imports: [
+            EventLogModule,
+            ConversationAccessModule,
+            AttachmentsModule,
+            ExtensionsModule,
+            IdentityModule,
+            SkillsModule,
+            ToolsModule,
+            ProvidersModule,
+            RunJobsModule,
+            SubagentsModule,
+            UsageReportModule,
+            TitlesModule,
+            StepLogModule,
+            BackgroundModule,
+            // the producer side of `wait-timeout` jobs (`MaintenanceProcessor` consumes them)
+            QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
+        ],
+        providers: [
+            ConversationLock,
+            ConversationStreams,
+            RunAbort,
+            KyselyCheckpointSaver,
+            RunFinish,
+            RunQueue,
+            Waits,
+            DecisionResumer,
+            RunControl,
+            RunDrafts,
+            AgentLoops,
+            RunSteps,
+            RunContextService,
+            RunWorker,
+            // a finished background task wakes an idle conversation (background Bash spec §3)
+            BackgroundWake,
+            // one quota per key prefix (the org run quota, the org eval quota)
+            {
+                provide: RUN_QUOTA,
+                inject: [REDIS, LockService],
+                useFactory: (redis, locks) => new OrgQuota(redis, RUN_QUOTA_PREFIX, locks),
+            },
+            {
+                provide: EVAL_QUOTA,
+                inject: [REDIS, LockService],
+                useFactory: (redis, locks) => new OrgQuota(redis, EVAL_QUOTA_PREFIX, locks),
+            },
+        ],
+        exports: [
+            ConversationLock,
+            ConversationStreams,
+            RunAbort,
+            KyselyCheckpointSaver,
+            RunFinish,
+            StepLogModule,
+            RunQueue,
+            Waits,
+            RunControl,
+            RunDrafts,
+            AgentLoops,
+            RunSteps,
+            RunWorker,
+            RUN_QUOTA,
+            EVAL_QUOTA,
+            ProvidersModule,
+            SubagentsModule,
+            UsageReportModule,
+            TitlesModule,
+        ],
+    })
+], RuntimeModule);
+export { RuntimeModule };

package/dist/runtime/step-log.d.ts

@@ -0,0 +1,51 @@
+import type { ToolSpec } from "@capybara-hq/plugin-sdk";
+import { type AppendEvent, EventLog } from "../conversations/event-log.js";
+import type { ConversationEvent } from "../conversations/events.js";
+import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+/** An audit row written with the events (`identity/audit.ts`). */
+export type StepAuditEntry = Parameters<typeof audit>[1];
+/**
+ * The writes of a run step that go to the event log together with another row, each in a
+ * transaction of its own (the caller notifies the log after the commit): a model call with the
+ * tool definitions it sent, a denial with its audit row, and a sub-agent's usage counted on its
+ * parent run. The step functions (`model-call.ts`, `hook-calls.ts`) reach it through their deps.
+ */
+export declare class StepLog {
+    private readonly kdb;
+    private readonly eventLog;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, eventLog: EventLog, txHost: TransactionHost);
+    /**
+     * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
+     * the `subagent_tokens_used` of the tree's budget run (sub-agents spec §8.3, agent map spec §6:
+     * the whole tree counts on one run): `counter.budgetRunId`, the run's own window
+     * (`SubagentParent.budgetRunId`), else the parent run's ({@link budgetRunOf}). A usage event
+     * already in the log (an idempotent hit after a crash) adds nothing, so each call counts exactly
+     * once. Returns what was written (hits included) and the highest new seq (null: nothing new).
+     */
+    appendCounted(conversationId: string, counter: {
+        parentRunId: string;
+        budgetRunId?: string | undefined;
+    }, events: AppendEvent[]): Promise<{
+        written: ConversationEvent[];
+        toSeq: number | null;
+    }>;
+    /** Appends events with their audit row (a hook denial). */
+    appendAudited(conversationId: string, events: AppendEvent[], entry: StepAuditEntry): Promise<ConversationEvent[]>;
+    /**
+     * Appends a `model_call` with the tool definitions its request sent, stored by fingerprint in
+     * `tool_specs` in the same transaction (a request can be rebuilt from the log and the specs).
+     */
+    appendWithSpecs(conversationId: string, specs: readonly {
+        specHash: string;
+        spec: ToolSpec;
+    }[], events: AppendEvent[]): Promise<ConversationEvent[]>;
+}
+/**
+ * The step writes ({@link StepLog}): a module of its own, so the tools domain (the `WebFetch`
+ * extraction's usage and denials) uses them without importing the runtime.
+ */
+export declare class StepLogModule {
+}

package/dist/runtime/step-log.js

@@ -0,0 +1,111 @@
+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 { EventLog, EventLogModule } from "../conversations/event-log.js";
+import { usageTokens } from "../evals/budget.js";
+import { audit } from "../identity/audit.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 { recordToolSpecs } from "../tools/specs.js";
+import { budgetRunOf } from "./subagents/limits.js";
+/**
+ * The writes of a run step that go to the event log together with another row, each in a
+ * transaction of its own (the caller notifies the log after the commit): a model call with the
+ * tool definitions it sent, a denial with its audit row, and a sub-agent's usage counted on its
+ * parent run. The step functions (`model-call.ts`, `hook-calls.ts`) reach it through their deps.
+ */
+let StepLog = class StepLog {
+    kdb;
+    eventLog;
+    txHost;
+    constructor(kdb, eventLog, txHost) {
+        this.kdb = kdb;
+        this.eventLog = eventLog;
+        this.txHost = txHost;
+    }
+    /**
+     * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
+     * the `subagent_tokens_used` of the tree's budget run (sub-agents spec §8.3, agent map spec §6:
+     * the whole tree counts on one run): `counter.budgetRunId`, the run's own window
+     * (`SubagentParent.budgetRunId`), else the parent run's ({@link budgetRunOf}). A usage event
+     * already in the log (an idempotent hit after a crash) adds nothing, so each call counts exactly
+     * once. Returns what was written (hits included) and the highest new seq (null: nothing new).
+     */
+    async appendCounted(conversationId, counter, events) {
+        const t = this.kdb.db;
+        // the conversation row lock the append takes anyway, taken first to read the seq before it
+        const before = await t
+            .selectFrom("conversations")
+            .select("last_seq")
+            .where("id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirstOrThrow();
+        const written = await this.eventLog.appendIn(conversationId, events);
+        const fresh = written.filter((e) => e.seq > Number(before.last_seq));
+        let tokens = 0;
+        for (const e of fresh)
+            if (e.type === "usage")
+                tokens += usageTokens(e.payload);
+        if (tokens > 0) {
+            await t
+                .updateTable("runs")
+                .set({ subagent_tokens_used: sql `subagent_tokens_used + ${tokens}` })
+                .where("id", "=", counter.budgetRunId ?? (await budgetRunOf(t, counter.parentRunId)))
+                .execute();
+        }
+        return { written, toSeq: fresh.length > 0 ? Math.max(...fresh.map((e) => e.seq)) : null };
+    }
+    /** Appends events with their audit row (a hook denial). */
+    async appendAudited(conversationId, events, entry) {
+        const out = await this.eventLog.appendIn(conversationId, events);
+        await audit(this.kdb.db, entry);
+        return out;
+    }
+    /**
+     * Appends a `model_call` with the tool definitions its request sent, stored by fingerprint in
+     * `tool_specs` in the same transaction (a request can be rebuilt from the log and the specs).
+     */
+    async appendWithSpecs(conversationId, specs, events) {
+        await recordToolSpecs(this.kdb.db, specs);
+        return this.eventLog.appendIn(conversationId, events);
+    }
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendCounted", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendAudited", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendWithSpecs", null);
+StepLog = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(TransactionHost))
+], StepLog);
+export { StepLog };
+/**
+ * The step writes ({@link StepLog}): a module of its own, so the tools domain (the `WebFetch`
+ * extraction's usage and denials) uses them without importing the runtime.
+ */
+let StepLogModule = class StepLogModule {
+};
+StepLogModule = __decorate([
+    Module({
+        imports: [EventLogModule],
+        providers: [StepLog],
+        exports: [StepLog],
+    })
+], StepLogModule);
+export { StepLogModule };

package/dist/runtime/stream.controller.d.ts

@@ -1,19 +1,27 @@
-import { type OnModuleDestroy } from "@nestjs/common";
+import type { Logger } from "@capybara-hq/plugin-sdk";
 import type { FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
-import type { ConversationsService } from "../conversations/conversations.service.js";
-import type { ApiTokenService } from "../identity/api-tokens.js";
+import { ConversationAccess } from "../conversations/access.js";
+import { ConversationsService } from "../conversations/conversations.service.js";
+import { ApiTokenService } from "../identity/api-tokens.js";
 import { type Principal } from "../identity/principal.js";
-import type { SessionService } from "../identity/sessions.js";
+import { SessionService } from "../identity/sessions.js";
 import { type OrgContext } from "../orgs/org.guard.js";
-import type { ConversationStreams } from "./stream.js";
+import { type RunDraft, RunDrafts } from "./run-drafts.js";
+import { ConversationStreams } from "./stream.js";
 declare const StreamQuery: z.ZodObject<{
     after: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
+declare const DraftParams: z.ZodObject<{
+    id: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strip>;
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
  * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
  * - 先订阅会话频道、再回放 `after`（或优先的 `Last-Event-ID`）之后的事件：`id: <seq>` / `event: event`；
+ * - after that catch-up, one `event: draft` (`data: {"runId","step","text","thinking"}`) per step of
+ *   the running run whose `assistant_message` is not logged (live drafts, spec 2026-11-07 §3.2);
  *   之后收到 `events` 通知就补读新事件（按 seq 去重），收到增量就发 `event: delta`，收到界面刷新
  *   （插件 `ctx.ui.invalidate`）就发 `event: ui`（`data: {"plugin","contribution"}`）；
  * - 每 `runtime.sseHeartbeatMs` 发 `: ping` 注释；每 `runtime.sseRecheckMs` 复核凭据（会话未吊销 / 令牌仍有效，
@@ -21,14 +29,25 @@ declare const StreamQuery: z.ZodObject<{
  * - 用 `@Res()` + `reply.hijack()` 直接写原始响应，绕开 Nest / Fastify 的响应处理与缓冲。
  *   代理（Web 层）需透传 `x-accel-buffering: no`、`cache-control: no-cache`。
  */
-export declare class ConversationStreamController implements OnModuleDestroy {
+export declare class ConversationStreamController {
     private readonly streams;
     private readonly sessions;
     private readonly tokens;
     private readonly conversations;
-    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, conversations: ConversationsService);
+    private readonly access;
+    private readonly drafts;
+    private readonly log;
+    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, conversations: ConversationsService, access: ConversationAccess, drafts: RunDrafts, log: Pick<Logger, "warn">);
+    /**
+     * The live drafts of one run (spec 2026-11-07 §3.2): `{ drafts: { step, text, thinking }[] }`,
+     * the steps still streaming whose `assistant_message` is not logged (none once the run is no
+     * longer running). What a stream client asks for when a delta's `offset` is past its draft.
+     * The stream's access rule (the conversation is visible to the viewer, else 404
+     * `conversation.not_found`); a run not of this conversation → 404 `run.not_found`.
+     */
+    draft(principal: Principal, org: OrgContext, params: z.infer<typeof DraftParams>): Promise<{
+        drafts: RunDraft[];
+    }>;
     stream(principal: Principal, org: OrgContext, id: string, q: z.infer<typeof StreamQuery>, lastEventId: string | undefined, req: FastifyRequest, reply: FastifyReply): Promise<void>;
-    /** 停机：关闭本进程的全部流，否则 HTTP 关闭要等到这些长连接超时。 */
-    onModuleDestroy(): void;
 }
 export {};

package/dist/runtime/stream.controller.js

@@ -7,14 +7,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Controller, Get, Headers, Inject, Param, Query, Req, Res, } from "@nestjs/common";
+import { Controller, Get, Headers, Inject, Param, Req, Res } from "@nestjs/common";
 import { z } from "zod";
+import { ConversationAccess } from "../conversations/access.js";
+import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
-import { API_TOKENS, CONVERSATION_STREAMS, CONVERSATIONS, SESSIONS } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
+import { ApiTokenService } from "../identity/api-tokens.js";
 import { credentialCheck } from "../identity/credential-check.js";
 import { CurrentPrincipal, requireUser } from "../identity/principal.js";
+import { SessionService } from "../identity/sessions.js";
+import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZParam, ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { RunDrafts } from "./run-drafts.js";
+import { ConversationStreams } from "./stream.js";
 const BEARER_RE = /^Bearer\s+(\S+)$/i;
 const StreamQuery = z.object({
     after: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
@@ -28,10 +35,20 @@ function parseLastEventId(v) {
     }
     return n;
 }
+const DraftParams = z.object({
+    id: z.string().min(1).max(100),
+    runId: z.string().min(1).max(100),
+});
+class ConversationStreamQueryDto extends createZodDto(StreamQuery, "ConversationStreamQuery") {
+}
+class RunDraftParamsDto extends createZodDto(DraftParams, "RunDraftParams") {
+}
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
  * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
  * - 先订阅会话频道、再回放 `after`（或优先的 `Last-Event-ID`）之后的事件：`id: <seq>` / `event: event`；
+ * - after that catch-up, one `event: draft` (`data: {"runId","step","text","thinking"}`) per step of
+ *   the running run whose `assistant_message` is not logged (live drafts, spec 2026-11-07 §3.2);
  *   之后收到 `events` 通知就补读新事件（按 seq 去重），收到增量就发 `event: delta`，收到界面刷新
  *   （插件 `ctx.ui.invalidate`）就发 `event: ui`（`data: {"plugin","contribution"}`）；
  * - 每 `runtime.sseHeartbeatMs` 发 `: ping` 注释；每 `runtime.sseRecheckMs` 复核凭据（会话未吊销 / 令牌仍有效，
@@ -44,11 +61,47 @@ let ConversationStreamController = class ConversationStreamController {
     sessions;
     tokens;
     conversations;
-    constructor(streams, sessions, tokens, conversations) {
+    access;
+    drafts;
+    log;
+    constructor(streams, sessions, tokens, conversations, access, drafts, log) {
         this.streams = streams;
         this.sessions = sessions;
         this.tokens = tokens;
         this.conversations = conversations;
+        this.access = access;
+        this.drafts = drafts;
+        this.log = log;
+    }
+    /**
+     * The live drafts of one run (spec 2026-11-07 §3.2): `{ drafts: { step, text, thinking }[] }`,
+     * the steps still streaming whose `assistant_message` is not logged (none once the run is no
+     * longer running). What a stream client asks for when a delta's `offset` is past its draft.
+     * The stream's access rule (the conversation is visible to the viewer, else 404
+     * `conversation.not_found`); a run not of this conversation → 404 `run.not_found`.
+     */
+    async draft(principal, org, params) {
+        const p = requireUser(principal);
+        if (!(await this.access.isAccessible(org.orgId, params.id, p.account.id))) {
+            throw new ApiError("conversation.not_found", "Conversation not found");
+        }
+        if (!(await this.drafts.runOf(params.id, params.runId))) {
+            throw new ApiError("run.not_found", "Run not found");
+        }
+        let live;
+        try {
+            live = await this.drafts.live(params.id, params.runId);
+        }
+        catch (err) {
+            // a convenience, like the stream's: no drafts rather than an error (the log stays the truth)
+            this.log.warn("cannot read live drafts", {
+                conversationId: params.id,
+                runId: params.runId,
+                err,
+            });
+            live = [];
+        }
+        return { drafts: live.map(({ step, text, thinking }) => ({ step, text, thinking })) };
     }
     async stream(principal, org, id, q, lastEventId, req, reply) {
         const p = requireUser(principal);
@@ -96,27 +149,33 @@ let ConversationStreamController = class ConversationStreamController {
         res.flushHeaders();
         handle.begin();
     }
-    /** 停机：关闭本进程的全部流，否则 HTTP 关闭要等到这些长连接超时。 */
-    onModuleDestroy() {
-        this.streams.closeAll();
-    }
 };
+__decorate([
+    Get(":id/runs/:runId/draft"),
+    OrgAction("agents.use"),
+    __param(0, CurrentPrincipal()),
+    __param(1, CurrentOrg()),
+    __param(2, ZParam(RunDraftParamsDto))
+], ConversationStreamController.prototype, "draft", null);
 __decorate([
     Get(":id/stream"),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("id")),
-    __param(3, Query(new ZodPipe(StreamQuery))),
+    __param(3, ZQuery(ConversationStreamQueryDto)),
     __param(4, Headers("last-event-id")),
     __param(5, Req()),
     __param(6, Res())
 ], ConversationStreamController.prototype, "stream", null);
 ConversationStreamController = __decorate([
     Controller("api/v1/orgs/:orgId/conversations"),
-    __param(0, Inject(CONVERSATION_STREAMS)),
-    __param(1, Inject(SESSIONS)),
-    __param(2, Inject(API_TOKENS)),
-    __param(3, Inject(CONVERSATIONS))
+    __param(0, Inject(ConversationStreams)),
+    __param(1, Inject(SessionService)),
+    __param(2, Inject(ApiTokenService)),
+    __param(3, Inject(ConversationsService)),
+    __param(4, Inject(ConversationAccess)),
+    __param(5, Inject(RunDrafts)),
+    __param(6, Inject(KERNEL_LOGGER))
 ], ConversationStreamController);
 export { ConversationStreamController };

package/dist/runtime/stream.d.ts

@@ -1,7 +1,10 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { KernelConfig } from "../config/schema.js";
-import { type EventLog } from "../conversations/event-log.js";
+import { ConversationAccess } from "../conversations/access.js";
+import { EventLog } from "../conversations/event-log.js";
 import type { CredentialCheck } from "../identity/credential-check.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { GracefulShutdown } from "../infra/lifecycle/graceful-shutdown.service.js";
+import { type LiveDraft, RunDrafts } from "./run-drafts.js";
 /** 一次 SSE 连接的输出端（由 HTTP 层包装原始响应）。 */
 export interface SseOutput {
     write(chunk: string): void;
@@ -21,8 +24,10 @@ export interface ConversationStreamsDeps {
     bus: StreamBus;
     /** 轻量可见性判定：连接建立时与每 `sseRecheckMs` 复核一次。 */
     access(orgId: string, conversationId: string, viewerAccountId: string): Promise<boolean>;
-    config: () => KernelConfig;
+    config: Pick<KernelConfigService, "get">;
     log: Pick<Logger, "warn">;
+    /** The live drafts of the conversation's running run (sent once, after the open catch-up). */
+    drafts(conversationId: string): Promise<LiveDraft[]>;
 }
 export interface StreamParams {
     orgId: string;
@@ -48,16 +53,32 @@ export interface StreamHandle {
  * （订阅、心跳与复核定时器）。
  */
 export declare class ConversationStreams {
-    private readonly d;
     private readonly active;
-    constructor(d: ConversationStreamsDeps);
+    /** Set by {@link closeAll}: streams opened afterwards end as soon as they begin. */
+    private closing;
+    private readonly d;
+    /**
+     * Closes the streams when the shutdown begins (readiness answers 503 from that moment) and
+     * latches: streams opened afterwards end at once, so the HTTP phase of the stop never waits on
+     * an event stream. Without `GracefulShutdown` (a standalone HTTP application, tests only) the
+     * streams end with their connections.
+     */
+    constructor(eventLog: Pick<EventLog, "readAfter">, bus: StreamBus, access: Pick<ConversationAccess, "isAccessible">, config: Pick<KernelConfigService, "get">, log: Pick<Logger, "warn">, drafts: Pick<RunDrafts, "live">, shutdown?: Pick<GracefulShutdown, "signal">);
     /**
      * 复核凭据与可见性，并先订阅会话频道（之后再回放，避免遗漏两者之间提交的事件）。
      * 凭据失效 → 对应的 `auth.*`；不可见 → `conversation.not_found`；订阅失败照常抛出。此时尚未写任何响应，调用方可以按普通错误返回。
      */
     open(p: StreamParams, out: SseOutput): Promise<StreamHandle>;
-    /** 关闭本进程的全部流（停机时调用）。 */
+    /**
+     * Closes every stream of this process (at shutdown) and latches: a stream opened afterwards ends
+     * right after its headers, so a reconnecting client cannot hold the HTTP close open.
+     */
     closeAll(): void;
     /** 当前打开的流数（测试用）。 */
     get size(): number;
 }
+/**
+ * The handle of a stream opened after shutdown began: `begin` (the headers are written) ends the
+ * response at once; the client reconnects with `Last-Event-ID`, to a replica that is still ready.
+ */
+export declare function endedStream(out: SseOutput): StreamHandle;