agentenkit 0.1.0

package/dist/ports/bus.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bus.js.map

package/dist/ports/bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus.js","sourceRoot":"","sources":["../../src/ports/bus.ts"],"names":[],"mappings":""}

package/dist/ports/kv.d.ts

@@ -0,0 +1,16 @@
+/** Hot key-value port: thread state cache, HITL handoff keys, seq & attempt
+ *  counters, per-thread run locks (§3.2). Backed by Redis in the reference
+ *  adapters — any KV works. */
+export interface Kv {
+    get(key: string): Promise<string | null>;
+    /** Returns true iff the value was written. With `onlyIfNotExists` (SET NX),
+     *  returns false when the key already existed — this is the atomic
+     *  primitive behind the per-thread run lock (§3.4). */
+    set(key: string, value: string, opts?: {
+        exSeconds?: number;
+        onlyIfNotExists?: boolean;
+    }): Promise<boolean>;
+    del(key: string): Promise<void>;
+    incr(key: string): Promise<number>;
+}
+//# sourceMappingURL=kv.d.ts.map

package/dist/ports/kv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv.d.ts","sourceRoot":"","sources":["../../src/ports/kv.ts"],"names":[],"mappings":"AAAA;;+BAE+B;AAC/B,MAAM,WAAW,EAAE;IACjB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC;;2DAEuD;IACvD,GAAG,CACD,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACvD,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACpC"}

package/dist/ports/kv.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kv.js.map

package/dist/ports/kv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv.js","sourceRoot":"","sources":["../../src/ports/kv.ts"],"names":[],"mappings":""}

package/dist/ports/queue.d.ts

@@ -0,0 +1,18 @@
+import type { RunJob } from '../core/types.js';
+export interface EnqueueOptions {
+    /** Hold the job for this many seconds before delivering it: the HITL expiry
+     *  (§2.5) and a job blocked by an older run's lock (§2.8).
+     *
+     *  An adapter that cannot delay may deliver immediately — both callers treat
+     *  an early arrival as a no-op — but it must NOT throw, or a park would fail
+     *  the run that scheduled it. Note the shape of the reference adapter: QStash
+     *  supports delays on publish only and rejects them on queue enqueue, so
+     *  QStashQueue publishes delayed jobs and queues the rest. */
+    delaySeconds?: number;
+}
+/** Durable dispatch port (§2.8). Delivery is at-least-once — the engine's
+ *  state guard + Storage.threads.claimState make double dispatch a no-op. */
+export interface Queue {
+    enqueue(job: RunJob, opts?: EnqueueOptions): Promise<void>;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/ports/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/ports/queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,WAAW,cAAc;IAC7B;;;;;;;kEAO8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;6EAC6E;AAC7E,MAAM,WAAW,KAAK;IACpB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D"}

package/dist/ports/queue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queue.js.map

package/dist/ports/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/ports/queue.ts"],"names":[],"mappings":""}

package/dist/ports/runtime.d.ts

@@ -0,0 +1,260 @@
+import type { ToolSet } from 'ai';
+import type { AgentEvent, AgentConfig, AgentKind, ContextUsage, ExecutionState, MessageDTO, ProviderOptions, ResolvedModel, RunJob, RunRecord, SubagentsConfig, ThreadDTO, UsageTotals } from '../core/types.js';
+import type { Storage } from './storage.js';
+import type { AdminStore, RunFilter, StepRecord } from './admin.js';
+import type { AgentRunState, BoundStorage } from '../core/state.js';
+import type { FollowOptions, SseOptions, SseStream } from '../core/follow.js';
+export type { AdminStore, NewStepRecord, RunFilter, StepRecord } from './admin.js';
+export type { AgentRunState, BoundStorage, StorageContext } from '../core/state.js';
+import type { EventBus } from './bus.js';
+import type { Queue } from './queue.js';
+import type { Kv } from './kv.js';
+import type { ExecuteInput, ExecuteOutcome } from '../core/engine.js';
+import type { AdminOverview, RunDetail, RunStats, ThreadDetail, ThreadSummary } from '../core/admin.js';
+export type { AdminOverview, RunDetail, RunStats, } from '../core/admin.js';
+export type { ExecuteInput, ExecuteOutcome } from '../core/engine.js';
+export type { AgentKind, ProviderOptions, ResolvedModel, RunJob, SubagentsConfig } from '../core/types.js';
+/** The ports bundle — everything in core/ receives this and nothing else.
+ *
+ *  `storage` is the caller's implementation with THIS run's context already
+ *  bound (§2.10), so core keeps calling `messages.append(threadId, msg)` while
+ *  the implementation still receives the state. `admin` is the platform's own
+ *  operational store (§2.9) — never the caller's. */
+export interface RuntimePorts {
+    storage: BoundStorage;
+    admin: AdminStore;
+    bus: EventBus;
+    queue: Queue;
+    kv: Kv;
+    /** User-provided model resolution (§3.3): models can live in any shape on
+     *  the consumer side — the platform only ever sees `ResolvedModel`. */
+    resolveModel(modelName: string): ResolvedModel;
+    config: AgentConfig;
+}
+export interface RuntimeOptions {
+    storage: Storage;
+    /** Where operational history goes (§2.9). Omitted, it is chosen from the
+     *  environment: Postgres when AGENTIC_KIT_ADMIN_DATABASE_URL is set, SQLite
+     *  on disk otherwise. Pass one to decide for yourself. */
+    admin?: AdminStore;
+    bus: EventBus;
+    queue: Queue;
+    kv: Kv;
+    /** Models can come in any shape — config files, a database, provider SDKs.
+     *  The platform only ever sees the resolved `ResolvedModel`. */
+    resolveModel(modelName: string): ResolvedModel;
+    config?: Partial<AgentConfig>;
+}
+export interface RunInput {
+    /** Omit to create a fresh thread first (threads.create, §3.2) */
+    threadId?: string;
+    prompt: string;
+    /** Carried through this whole run (§2.10): every storage call, every tool,
+     *  every nested run. Persisted on the dispatch, so a worker picking the job
+     *  up later — or resuming it after an approval — sees the same thing. The
+     *  platform never reads it. */
+    state?: AgentRunState;
+    /** Edit + resend (§5.1): replace this user message with `prompt` and drop
+     *  every message after it, then answer again from that point. Must name a
+     *  message in this thread whose role is 'user'. Omit for a normal turn. */
+    editMessageId?: string;
+    /** Registry key or provider instance reference — resolved via
+     *  `AgentCore.resolveModel`. Overrides the spec default. */
+    model?: string;
+    /** Max cumulative tokens (input + output) for this run — overrides
+     *  spec.tokenBudget / config (§2.1 safety cap). Flows to the worker
+     *  via RunJob.tokenBudget. */
+    tokenBudget?: number;
+    /** Additional provider-specific options, passed through to the provider
+     *  from the AI SDK (§3.1). Merged over the spec default: the execute
+     *  input wins per provider namespace. */
+    providerOptions?: ProviderOptions;
+}
+export interface RunResult {
+    accepted: boolean;
+    threadId: string;
+    /** This run's id (§2.1) — the same one carried by the enqueued job. An
+     *  in-process worker must pass it back, or its dispatch has no identity. */
+    runId?: string;
+    state?: ExecutionState;
+    error?: string;
+}
+export interface StopResult {
+    accepted: boolean;
+    error?: string;
+}
+export interface DeleteThreadResult {
+    accepted: boolean;
+    error?: string;
+}
+export interface RespondInput {
+    threadId: string;
+    toolCallId: string;
+    approved: boolean;
+    payload?: unknown;
+    /** The run state (§2.10) for the storage calls answering makes. The RESUMED
+     *  run rebuilds its own state from the park's ticket — this is only for the
+     *  reads and writes `respond` itself performs. */
+    state?: AgentRunState;
+}
+export interface RespondResult {
+    delivered: boolean;
+    error?: string;
+}
+/** What a thread has spent, and how full its context is (§2.6, §4). */
+export interface ThreadUsage {
+    /** Every run segment's tokens, summed. */
+    tokens: UsageTotals;
+    /** What the next run's prompt would carry before compaction. */
+    context: ContextUsage;
+    /** The model the budget was measured against. */
+    model: string;
+}
+/** Durable state used to hydrate a client before it starts live event replay. */
+export interface ThreadSnapshot {
+    thread: ThreadDTO;
+    messages: MessageDTO[];
+    /** Nested runs on this thread (§2.7) — name, depth and final state, so a
+     *  reconnecting client rebuilds its subagent panel without depending on
+     *  events that only replay while a run is unfinished. */
+    runs: RunRecord[];
+    /** Cursor for starting live replay without duplicating snapshot state. */
+    lastEventSeq: number;
+    /** Only the unfinished run's events, used to restore transient activity. */
+    activeEvents: AgentEvent[];
+}
+/** Everything streamText accepts except the platform-owned keys (§3.1).
+ *  `onChunk` / `onFinish` ARE allowed — the platform chains them (§4). */
+export type StreamTextAgentSpec = {
+    /** Unique handle key — the queue dispatch key (§5). */
+    name: string;
+    /** Registry key for this agent's model — resolved via
+     *  `AgentCore.resolveModel` (instance + contextWindow). */
+    model?: string;
+    /** Opt-in subagent delegation (§2.7). */
+    subagents?: boolean | SubagentsConfig;
+    /** Default per-run token budget (input + output). Per-run
+     *  `input.tokenBudget` wins; `undefined` = unbounded apart from `maxSteps`. */
+    tokenBudget?: number;
+    /** Additional provider-specific options, passed through to the provider
+     *  from the AI SDK. Per-provider namespace; the execute input wins. */
+    providerOptions?: ProviderOptions;
+} & Omit<Parameters<typeof import('ai').streamText>[0], 'model' | 'messages' | 'prompt' | 'system' | 'abortSignal' | 'maxSteps' | 'onStepFinish' | 'onError'> & {
+    /** `system` is allowed here (static persona); per-run system is not. */
+    system?: string;
+    tools?: ToolSet;
+    onChunk?: (para: any) => void | Promise<void>;
+    onFinish?: (finishParams: any) => void | Promise<void>;
+};
+export type GenerateTextAgentSpec = {
+    /** Unique handle key — the queue dispatch key (§5). */
+    name: string;
+    model?: string;
+    subagents?: boolean | SubagentsConfig;
+    tokenBudget?: number;
+    providerOptions?: ProviderOptions;
+} & Omit<Parameters<typeof import('ai').generateText>[0], 'model' | 'messages' | 'prompt' | 'abortSignal' | 'onFinish' | 'onStepFinish'> & {
+    tools?: ToolSet;
+    onFinish?: (finishParams: any) => void | Promise<void>;
+};
+/** An executor bound to a generation flavor and to the user's generation
+ *  arguments (§3). Returned by the `create*Agent` factories. */
+export interface AgentHandle {
+    readonly name: string;
+    readonly kind: AgentKind;
+    /** Worker-side only (§5.6). Throws on failure — see executeWithPolicy.
+     *  Returns 'lock-conflict' when another worker owns the thread's run lock
+     *  (nothing was executed) and 'stale' when a newer run has replaced this
+     *  one (§2.1, §2.8). */
+    execute(input: ExecuteInput): Promise<ExecuteOutcome>;
+    /** execute + §2.8 failure policy: redrive < maxAttempts, else finalize FAILED */
+    executeWithPolicy(input: ExecuteInput, policy?: {
+        maxAttempts?: number;
+    }): Promise<void>;
+    /** Persist user message → state RUNNING → enqueue a job dispatched back to
+     *  THIS handle (the job carries `agent: this.name` and `tokenBudget`). */
+    run(input: RunInput): Promise<RunResult>;
+    /** Platform stop (§2.1) — works regardless of which agent's run is active. */
+    stop(threadId: string, state?: AgentRunState): Promise<StopResult>;
+}
+export interface AgentCore {
+    /** Resolve a registry key to the stable identity and provider instance used
+     *  by execution, compaction, usage attribution, and persisted run metadata. */
+    resolveModel(modelName: string): ResolvedModel;
+    /** Most recent first — thread pickers / sidebars. Takes the run state
+     *  (§2.10) so a tenant-scoped Storage can filter; a read has no dispatch
+     *  ticket to carry it on. */
+    listThreads(state?: AgentRunState): Promise<ThreadDTO[]>;
+    /** One call for UIs / history routes: thread + messages + recent events. */
+    getThreadSnapshot(threadId: string, state?: AgentRunState): Promise<ThreadSnapshot | null>;
+    /** Tokens spent so far and the §2.6 context load. Null when the thread is
+     *  gone. Kept out of the snapshot so hydration stays one cheap read. */
+    getThreadUsage(threadId: string, state?: AgentRunState): Promise<ThreadUsage | null>;
+    /** Delete a thread and everything that follows it — messages, events,
+     *  usage rows, subagent runs, and the thread's hot kv keys (§3.2).
+     *  Refused while a run is active; stop() first. */
+    deleteThread(threadId: string, state?: AgentRunState): Promise<DeleteThreadResult>;
+    hitl: {
+        respond(input: RespondInput): Promise<RespondResult>;
+        reclaimIfOrphaned(threadId: string, state?: AgentRunState): Promise<boolean>;
+    };
+    events: {
+        since(threadId: string, sinceSeq: number, state?: AgentRunState): Promise<AgentEvent[]>;
+        subscribe(threadId: string, handler: (event: AgentEvent) => void): Promise<() => void>;
+        /** Replay then live, as one sequence, with the cursor discipline already
+         *  applied (§2.2): subscribe before replaying, never emit at or below the
+         *  cursor, forward a seq-0 notice without moving it.
+         *
+         *  Framework-neutral — an async iterable is something Express, Nest, Hono,
+         *  Next or a plain worker can each consume in their own way. Pass a signal,
+         *  or the subscription outlives the client. */
+        follow(threadId: string, options?: FollowOptions & {
+            state?: AgentRunState;
+        }): AsyncGenerator<AgentEvent>;
+        /** `follow`, encoded as Server-Sent Events. Returns the stream and the
+         *  headers rather than a Response, because half the ecosystem has none. */
+        sse(threadId: string, options?: SseOptions & {
+            state?: AgentRunState;
+        }): SseStream;
+    };
+    /** Agent factories — see §4. Each call registers a handle under `spec.name`. */
+    createStreamTextAgent(spec: StreamTextAgentSpec): AgentHandle;
+    createGenerateTextAgent(spec: GenerateTextAgentSpec): AgentHandle;
+    /** Worker-side resolution of a registered handle from the queue job. */
+    getAgent(name: string): AgentHandle | null;
+    /** Operational reads (§2.9). The platform records what runs did; building a
+     *  view over it is the caller's business. Everything here comes from the
+     *  platform's OWN store — it never reads the caller's database. */
+    admin: {
+        overview(range?: {
+            since?: Date;
+        }): Promise<AdminOverview>;
+        listRuns(filter?: RunFilter): Promise<RunRecord[]>;
+        stats(range?: {
+            since?: Date;
+            until?: Date;
+        }): Promise<RunStats>;
+        getRun(runId: string): Promise<RunDetail | null>;
+        listRunsByThread(threadId: string): Promise<RunRecord[]>;
+        listSteps(runId: string): Promise<StepRecord[]>;
+        /** Threads with their runs rolled up — the top level of an operational
+         *  view, since a thread is what a person recognises (§2.9). */
+        listThreads(filter?: {
+            state?: ExecutionState[];
+            since?: Date;
+            limit?: number;
+        }): Promise<ThreadSummary[]>;
+        getThread(threadId: string): Promise<ThreadDetail | null>;
+    };
+    /** The queue dispatch side of the platform (§2.8): resolves the handle,
+     *  applies the failure policy, and is idempotent under at-least-once
+     *  delivery (the per-thread run lock, §3.4). The HTTP layer only verifies
+     *  signatures, parses JSON, and calls this. */
+    worker: {
+        handleJob(job: RunJob): Promise<{
+            accepted: boolean;
+            reason?: string;
+        }>;
+    };
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/ports/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/ports/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAClC,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,cAAc,EACd,UAAU,EACV,eAAe,EACf,aAAa,EACb,MAAM,EACN,SAAS,EACT,eAAe,EACf,SAAS,EACT,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9E,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACnF,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,aAAa,EACd,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,aAAa,EACb,SAAS,EACT,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGtE,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAE3G;;;;;qDAKqD;AACrD,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,EAAE,EAAE,EAAE,CAAC;IACP;2EACuE;IACvE,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/C,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB;;8DAE0D;IAC1D,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,EAAE,EAAE,EAAE,CAAC;IACP;oEACgE;IAChE,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/C,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,QAAQ;IACvB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf;;;mCAG+B;IAC/B,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB;;+EAE2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;gEAC4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;kCAE8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;6CAEyC;IACzC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB;gFAC4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;sDAEkD;IAClD,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,MAAM,EAAE,WAAW,CAAC;IACpB,gEAAgE;IAChE,OAAO,EAAE,YAAY,CAAC;IACtB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB;;6DAEyD;IACzD,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;0EAC0E;AAC1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb;+DAC2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,SAAS,CAAC,EAAE,OAAO,GAAG,eAAe,CAAC;IACtC;mFAC+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;2EACuE;IACvE,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,EAClD,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,aAAa,GACxD,UAAU,GAAG,cAAc,GAAG,SAAS,CAAC,GAAG;IAC/C,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,GAAG,eAAe,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,EACpD,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,aAAa,GAAG,UAAU,GAAG,cAAc,CAAC,GAAG;IACnF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD,CAAC;AAEF;gEACgE;AAChE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;;4BAGwB;IACxB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEtD,iFAAiF;IACjF,iBAAiB,CACf,KAAK,EAAE,YAAY,EACnB,MAAM,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAChC,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;8EAC0E;IAC1E,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAEzC,8EAA8E;IAC9E,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,SAAS;IACxB;mFAC+E;IAC/E,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC;IAE/C;;iCAE6B;IAC7B,WAAW,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAEzD,4EAA4E;IAC5E,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAE3F;4EACwE;IACxE,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAErF;;uDAEmD;IACnD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEnF,IAAI,EAAE;QACJ,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QACrD,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC9E,CAAC;IAEF,MAAM,EAAE;QACN,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QACxF,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;QACvF;;;;;;uDAM+C;QAC/C,MAAM,CACJ,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,aAAa,GAAG;YAAE,KAAK,CAAC,EAAE,aAAa,CAAA;SAAE,GAClD,cAAc,CAAC,UAAU,CAAC,CAAC;QAC9B;mFAC2E;QAC3E,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG;YAAE,KAAK,CAAC,EAAE,aAAa,CAAA;SAAE,GAAG,SAAS,CAAC;KACpF,CAAC;IAEF,gFAAgF;IAChF,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,WAAW,CAAC;IAC9D,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,GAAG,WAAW,CAAC;IAElE,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC;IAE3C;;uEAEmE;IACnE,KAAK,EAAE;QACL,QAAQ,CAAC,KAAK,CAAC,EAAE;YAAE,KAAK,CAAC,EAAE,IAAI,CAAA;SAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;QACnD,KAAK,CAAC,KAAK,CAAC,EAAE;YAAE,KAAK,CAAC,EAAE,IAAI,CAAC;YAAC,KAAK,CAAC,EAAE,IAAI,CAAA;SAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QACjE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;QACjD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;QACzD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QAChD;uEAC+D;QAC/D,WAAW,CAAC,MAAM,CAAC,EAAE;YACnB,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;YACzB,KAAK,CAAC,EAAE,IAAI,CAAC;YACb,KAAK,CAAC,EAAE,MAAM,CAAC;SAChB,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;QAC7B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;KAC3D,CAAC;IAEF;;;mDAG+C;IAC/C,MAAM,EAAE;QACN,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;YAAE,QAAQ,EAAE,OAAO,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACzE,CAAC;CACH"}

package/dist/ports/runtime.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime.js.map

package/dist/ports/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/ports/runtime.ts"],"names":[],"mappings":""}

package/dist/ports/storage.d.ts

@@ -0,0 +1,72 @@
+import type { StorageContext } from '../core/state.js';
+import type { AgentEvent, ExecutionState, MessageDTO, NewMessage, NewUsage, UsageTotals, ThreadDTO } from '../core/types.js';
+/** Persistence port for a caller's OWN data (§3.2): threads, messages, events,
+ *  usage. DTOs cross the boundary; ORM/entity types never leak into core.
+ *  Implement it once for MongoDB, MySQL, DynamoDB — or use the shipped
+ *  PrismaStorage reference adapter.
+ *
+ *  Operational history — run records, timings, step markers — is NOT here.
+ *  agentic-kit owns and stores that itself (§2.9); callers only read it back
+ *  through `runtime.admin`.
+ *
+ *  Every method receives the run's StorageContext as its last argument, so an
+ *  implementation can scope a query to a tenant, stamp a row with who caused
+ *  it, or route to a different database entirely (§2.10). */
+export interface Storage {
+    threads: {
+        get(threadId: string, ctx: StorageContext): Promise<ThreadDTO | null>;
+        create(init: {
+            model?: string;
+        } | undefined, ctx: StorageContext): Promise<ThreadDTO>;
+        /** Most recent first — thread pickers / sidebars. */
+        list(ctx: StorageContext): Promise<ThreadDTO[]>;
+        setState(threadId: string, state: ExecutionState, ctx: StorageContext): Promise<void>;
+        /** Delete the thread AND everything that follows it: messages, events,
+         *  usage rows, and subagent runs. Throws if the thread does not exist.
+         *  The reference Prisma schema cascades via `onDelete: Cascade`. */
+        delete(threadId: string, ctx: StorageContext): Promise<void>;
+        /** Compare-and-set: returns true iff THIS caller performed the transition.
+         *  Backs HITL reclamation + double-dispatch protection (§2.5, §2.8).
+         *  Must be atomic — a single conditional UPDATE or equivalent. */
+        claimState(threadId: string, from: ExecutionState, to: ExecutionState, ctx: StorageContext): Promise<boolean>;
+    };
+    messages: {
+        append(threadId: string, message: NewMessage, ctx: StorageContext): Promise<MessageDTO>;
+        /** Oldest first. The scope decides WHOSE turns come back (§2.7):
+         *  - `{ agentId: null }` — the main agent's stream. Compaction (§2.6) and
+         *    the edit lookup (§5.1) must use this; unscoped, a subagent's turns
+         *    leak into the parent's prompt and context isolation is gone.
+         *  - `{ agentId: 'sub_1' }` — that nested run's own stream.
+         *  - omitted — every row on the thread, for UI hydration (§2.2). */
+        list(threadId: string, opts: {
+            agentId?: string | null;
+        } | undefined, ctx: StorageContext): Promise<MessageDTO[]>;
+        /** Delete `messageId` and every message after it, in the same order
+         *  `list` returns (§5.1 edit + resend). Returns how many rows went; 0 when
+         *  the id is not in this thread.
+         *
+         *  Dropping a suffix only leaves the history well-formed if it starts at a
+         *  user turn — cutting from a tool result would strip it off the assistant
+         *  tool-call that produced it, and a dangling call is a conversation no
+         *  provider accepts. `run()` enforces that; adapters just delete. */
+        deleteFrom(threadId: string, messageId: string, ctx: StorageContext): Promise<number>;
+    };
+    events: {
+        append(threadId: string, event: AgentEvent, ctx: StorageContext): Promise<void>;
+        /** All events after the cursor, ascending by seq — SSE replay (§2.2) */
+        listSince(threadId: string, sinceSeq: number, ctx: StorageContext): Promise<AgentEvent[]>;
+        /** Most recent event of a type — the HITL pending check (§2.5) */
+        latest(threadId: string, type: string, ctx: StorageContext): Promise<AgentEvent | null>;
+        /** Every event of a type, ascending by seq. The open-approval set (§2.7)
+         *  is derived from these; scanning `listSince` instead would drag every
+         *  CHUNK on the thread through memory. */
+        listByType(threadId: string, type: string, ctx: StorageContext): Promise<AgentEvent[]>;
+    };
+    usage: {
+        record(threadId: string, usage: NewUsage, ctx: StorageContext): Promise<void>;
+        /** Every recorded segment for the thread, summed (§4). A thread with no
+         *  usage rows yet returns zeroes, never null. */
+        total(threadId: string, ctx: StorageContext): Promise<UsageTotals>;
+    };
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/ports/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/ports/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,UAAU,EACV,UAAU,EACV,QAAQ,EACR,WAAW,EACX,SAAS,EACV,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;6DAW6D;AAC7D,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE;QACP,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;QACtE,MAAM,CAAC,IAAI,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,SAAS,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QACtF,qDAAqD;QACrD,IAAI,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;QAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACtF;;4EAEoE;QACpE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7D;;0EAEkE;QAClE,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,cAAc,EAClB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,OAAO,CAAC,CAAC;KACrB,CAAC;IACF,QAAQ,EAAE;QACR,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QACxF;;;;;4EAKoE;QACpE,IAAI,CACF,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;YAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,GAAG,SAAS,EAC7C,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QACzB;;;;;;;6EAOqE;QACrE,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;KACvF,CAAC;IACF,MAAM,EAAE;QACN,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAChF,wEAAwE;QACxE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QAC1F,kEAAkE;QAClE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;QACxF;;kDAE0C;QAC1C,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;KACxF,CAAC;IACF,KAAK,EAAE;QACL,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC9E;yDACiD;QACjD,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;KACpE,CAAC;CACH"}

package/dist/ports/storage.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storage.js.map

package/dist/ports/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/ports/storage.ts"],"names":[],"mappings":""}

package/dist/runtime.d.ts

@@ -0,0 +1,5 @@
+import type { AgentCore, RuntimeOptions } from './ports/runtime.js';
+/** Bind the ports to the core behaviors (§3.3). This is the package's public
+ *  entry point — the only place where anything is wired together. */
+export declare function setupAgentCore(opts: RuntimeOptions): Promise<AgentCore>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EAMT,cAAc,EAGf,MAAM,oBAAoB,CAAC;AAY5B;qEACqE;AACrE,wBAAsB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CA6M7E"}

package/dist/runtime.js

@@ -0,0 +1,177 @@
+import { resolveConfig } from './core/types.js';
+import { contextUsage } from './core/context.js';
+import { createGenerateTextAgent, createStreamTextAgent } from './core/agent.js';
+import * as adminReads from './core/admin.js';
+import { bindStorage } from './core/state.js';
+import { followEvents, toSseStream } from './core/follow.js';
+import { openDefaultAdminStore } from './admin/default.js';
+import { reclaimIfOrphaned } from './core/reclaim.js';
+import { respond } from './core/hitl.js';
+import { deleteThread } from './core/deleteThread.js';
+/** Bind the ports to the core behaviors (§3.3). This is the package's public
+ *  entry point — the only place where anything is wired together. */
+export async function setupAgentCore(opts) {
+    // Operational history is the platform's own (§2.9). Nothing configured means
+    // SQLite on disk: history that survives a restart should be the default, not
+    // something you have to remember to switch on.
+    //
+    // Opened here, eagerly, which is why this function is async: a store that
+    // cannot be opened is a startup error you see immediately, rather than a
+    // surprise on the first run — and losing run history silently looks exactly
+    // like having no traffic.
+    const admin = opts.admin ?? (await openDefaultAdminStore());
+    const shared = {
+        admin,
+        bus: opts.bus,
+        queue: opts.queue,
+        kv: opts.kv,
+        resolveModel: (modelName) => opts.resolveModel(modelName),
+        config: resolveConfig(opts.config),
+    };
+    /** Ports for ONE run: the caller's storage with that run's state bound, so
+     *  every query, insert and update their implementation makes can see it
+     *  (§2.10). Called per entry point rather than once, because state belongs
+     *  to a run and a runtime outlives many. */
+    const scope = (state = {}, runId) => ({
+        ...shared,
+        storage: bindStorage(opts.storage, { state, runId }),
+    });
+    // For reads that are not on behalf of any particular run.
+    const deps = scope();
+    // Handle registry — keyed by spec.name, resolved by the queue dispatch.
+    const registry = new Map();
+    // The first registered stream-text handle is the default for jobs that
+    // omit `agent` (§5).
+    let defaultAgent = null;
+    const register = (name, kind, spec) => {
+        const handle = kind === 'stream-text'
+            ? createStreamTextAgent(scope, spec)
+            : createGenerateTextAgent(scope, spec);
+        registry.set(name, handle);
+        return handle;
+    };
+    const core = {
+        resolveModel: (modelName) => deps.resolveModel(modelName),
+        // Reads take the run state too (§2.10). A run carries it on its ticket,
+        // but a read has no ticket to carry — so a tenant-scoped Storage would see
+        // an empty context here and either return nothing or, worse, everything.
+        listThreads: (state) => scope(state).storage.threads.list(),
+        deleteThread: (threadId, state) => deleteThread(scope(state), threadId),
+        getThreadSnapshot: async (threadId, state) => {
+            const deps = scope(state);
+            const thread = await deps.storage.threads.get(threadId);
+            if (!thread)
+                return null;
+            const messages = await deps.storage.messages.list(threadId, undefined);
+            const runs = await deps.admin.runs.listByThread(threadId);
+            const events = await deps.storage.events.listSince(threadId, -1);
+            const lastEventSeq = events.at(-1)?.seq ?? -1;
+            let activeEvents = [];
+            if (thread.state === 'RUNNING' || thread.state === 'WAITING_FOR_INPUT') {
+                let boundary = -1;
+                for (let index = events.length - 1; index >= 0; index -= 1) {
+                    const event = events[index];
+                    if (event.type === 'STATE_CHANGE' &&
+                        event.payload?.state === 'RUNNING') {
+                        boundary = index;
+                        break;
+                    }
+                }
+                const active = events.slice(Math.max(0, boundary));
+                // Everything up to the last committed step is ALREADY in `messages`
+                // (§2.2). Replaying those chunks too would render each finished step's
+                // text twice — once from the durable message, once from the stream
+                // that produced it. Only the in-flight step's chunks are missing from
+                // durable history, so only those are transient.
+                //
+                // Chunks alone: a park (INPUT_REQUIRED) is published DURING the step,
+                // before its messages commit, so slicing the whole window by this
+                // boundary would drop the very approval a reconnecting client needs.
+                const lastCommitted = active.reduce((seq, e) => (e.type === 'STEP_COMMITTED' ? e.seq : seq), -1);
+                const isStream = (type) => type === 'CHUNK' || type === 'SUBAGENT_CHUNK';
+                activeEvents = active.filter((e) => !(isStream(e.type) && e.seq !== 0 && e.seq <= lastCommitted));
+            }
+            return { thread, messages, runs, lastEventSeq, activeEvents };
+        },
+        admin: {
+            overview: (range) => adminReads.overview(deps, range),
+            listRuns: (filter) => adminReads.listRuns(deps, filter),
+            stats: (range) => adminReads.runStats(deps, range),
+            getRun: (runId) => adminReads.getRun(deps, runId),
+            listRunsByThread: (threadId) => deps.admin.runs.listByThread(threadId),
+            listSteps: (runId) => adminReads.listSteps(deps, runId),
+            listThreads: (filter) => adminReads.listThreads(deps, filter),
+            getThread: (threadId) => adminReads.getThread(deps, threadId),
+        },
+        getThreadUsage: async (threadId, state) => {
+            const deps = scope(state);
+            const thread = await deps.storage.threads.get(threadId);
+            if (!thread)
+                return null;
+            const [tokens, context] = await Promise.all([
+                deps.storage.usage.total(threadId),
+                contextUsage(deps, threadId, thread.model),
+            ]);
+            return { tokens, context, model: thread.model };
+        },
+        hitl: {
+            respond: (input) => {
+                // Scoped like the run it resumes: answering an approval reads and
+                // writes the caller's rows (§2.10).
+                const scoped = scope(input.state);
+                // Heal an orphaned wait first — if reclamation claims the thread, the
+                // response is rejected as late (§2.5)
+                return (async () => {
+                    await reclaimIfOrphaned(scoped, input.threadId);
+                    return respond(scoped, input);
+                })();
+            },
+            reclaimIfOrphaned: (threadId, state) => reclaimIfOrphaned(scope(state), threadId),
+        },
+        events: {
+            since: (threadId, sinceSeq, state) => scope(state).storage.events.listSince(threadId, sinceSeq),
+            subscribe: async (threadId, handler) => deps.bus.subscribe(threadId, handler),
+            // The replay-then-tail dance lives here rather than in every route
+            // handler: subscribe first, never emit at or below the cursor, and let a
+            // seq-0 notice through without moving it (§2.2).
+            follow: (threadId, options = {}) => followEvents(scope(options.state), threadId, options),
+            sse: (threadId, options = {}) => toSseStream(followEvents(scope(options.state), threadId, options), options),
+        },
+        createStreamTextAgent: (spec) => {
+            const handle = register(spec.name, 'stream-text', spec);
+            if (defaultAgent === null)
+                defaultAgent = spec.name;
+            return handle;
+        },
+        createGenerateTextAgent: (spec) => register(spec.name, 'generate-text', spec),
+        getAgent: (name) => registry.get(name) ?? null,
+        worker: {
+            handleJob: async (job) => {
+                // Missing `agent` → the default handle (first registered stream-text)
+                const agent = (job.agent ? registry.get(job.agent) : null) ??
+                    (defaultAgent ? registry.get(defaultAgent) : null);
+                if (!agent)
+                    return { accepted: false, reason: 'unknown-agent' };
+                // executeWithPolicy: run lock (idempotent under at-least-once
+                // delivery, §3.4) + §2.8 failure policy — redrive < maxAttempts,
+                // else finalize FAILED; a user stop is never retried.
+                await agent.executeWithPolicy({
+                    threadId: job.threadId,
+                    // The dispatch's identity (§2.1) — without it the worker cannot tell
+                    // it has been replaced by a newer run, and a blocked job is dropped.
+                    runId: job.runId,
+                    // Carries the queue wait through to the run record (§2.9).
+                    enqueuedAt: job.enqueuedAt,
+                    // Rehydrated from the ticket: this worker never saw the caller (§2.10).
+                    state: job.state,
+                    model: job.model,
+                    tokenBudget: job.tokenBudget,
+                    providerOptions: job.providerOptions,
+                });
+                return { accepted: true };
+            },
+        },
+    };
+    return core;
+}
+//# sourceMappingURL=runtime.js.map