@capekai/core 1.0.0

package/src/retry/stream-chat.ts

@@ -0,0 +1,312 @@
+/**
+ * C6 retry stream loop. `streamChatWithRetry` keeps its exact pre-C6 event
+ * shape, wire errors, message finalization, interrupt registration, and
+ * running-state updates; every policy decision (classification, backoff,
+ * circuit state, and the tool-activity side-effect barrier) resolves through
+ * `getRetryPolicy()`, so composed agent scopes run on their own agent-scoped
+ * policy while unscoped consumers keep the process-default behavior.
+ *
+ * Its core edges are named and AST-gated by the `retry-domain-no-core` rule:
+ * the session interrupt manager for backoff cancellation and the turn stream
+ * it wraps. Both stay in core until their owning phases (C6/C7).
+ */
+
+import type { ChatOptions } from '../core/agent';
+import type { UsageEventData } from '../core/step-handlers';
+import type {
+  AssistantMessage, AuthErrorMessage, ChatRetryMessage, ContextOverflowErrorMessage, ErrorMessage, InvalidRequestErrorMessage, MessageEvent, RateLimitErrorMessage, ServerErrorMessage, TimeoutErrorMessage, ToolPart } from '@capekai/types';
+import {
+  ApiErrorType,
+  ERROR_CHAT_FAILED,
+  ERROR_RATE_LIMIT,
+  ERROR_SERVER_ERROR,
+  ERROR_TIMEOUT,
+  type ClassifiedError,
+} from '../utils/errors';
+import { emitSessionUpdated } from '../runtime/host-dependencies';
+import {
+  getPartsByMessage,
+  getSession,
+  syncMessageFts,
+  transitionToolToInterrupted,
+  updateMessage,
+  updateSession,
+} from '../storage/runtime';
+import { rejectPendingAsksBySession } from '../permission/ask-user-api';
+import { interruptManager } from '../core/interrupt';
+import {
+  getRetryPolicy,
+  RetryDelayAbortedError,
+  type StreamRetryPolicy,
+} from './policy';
+
+export type StreamChatEvent =
+  | MessageEvent
+  | { type: 'usage'; usage: UsageEventData; model: string; variant: string | null }
+  | { type: 'needs_compaction'; sessionId: string }
+  | ChatRetryMessage
+  | RateLimitErrorMessage
+  | ServerErrorMessage
+  | TimeoutErrorMessage
+  | AuthErrorMessage
+  | ContextOverflowErrorMessage
+  | InvalidRequestErrorMessage
+  | ErrorMessage;
+
+export type StreamChatFn = (options: ChatOptions) => AsyncGenerator<StreamChatEvent>;
+
+async function finalizeFailedAttempt(
+  message: AssistantMessage | null,
+  classifiedError: { message: string },
+  retryFailed: boolean,
+): Promise<MessageEvent[]> {
+  if (!message) return [];
+
+  const events: MessageEvent[] = [];
+  const parts = await getPartsByMessage(message.id);
+  for (const part of parts) {
+    if (part.type !== 'tool') continue;
+    const toolPart = part as ToolPart;
+    if (toolPart.state.status !== 'pending' && toolPart.state.status !== 'running') continue;
+    const interruptedPart = await transitionToolToInterrupted(toolPart.id, 'error');
+    if (interruptedPart) {
+      events.push({ type: 'part.updated', sessionId: message.sessionId, part: interruptedPart });
+    }
+  }
+
+  const errorMessage: AssistantMessage = {
+    ...message,
+    status: 'error',
+    error: classifiedError.message,
+    completedAt: Date.now(),
+    ...(retryFailed ? { mode: 'retry_failed' as const } : {}),
+  };
+  updateMessage(message.id, errorMessage, { syncFts: false });
+  syncMessageFts(message.id);
+  events.push({ type: 'message.updated', message: errorMessage });
+  return events;
+}
+
+function createFinalErrorEvent(classifiedError: ClassifiedError): StreamChatEvent {
+  if (classifiedError.type === ApiErrorType.RateLimit) {
+    return {
+      type: 'error.rate_limit',
+      code: ERROR_RATE_LIMIT,
+      message: classifiedError.message,
+      retryAfterMs: classifiedError.retryAfterMs ?? 5_000,
+    };
+  }
+  if (classifiedError.type === ApiErrorType.ServerError || classifiedError.type === ApiErrorType.Network) {
+    return {
+      type: 'error.server',
+      code: ERROR_SERVER_ERROR,
+      message: classifiedError.message,
+      retryAfterMs: classifiedError.retryAfterMs,
+    };
+  }
+  if (classifiedError.type === ApiErrorType.ContextOverflow) {
+    return {
+      type: 'error.context_overflow',
+      code: 'context_overflow',
+      message: classifiedError.message,
+    };
+  }
+  if (classifiedError.type === ApiErrorType.Timeout) {
+    return {
+      type: 'error.timeout',
+      code: ERROR_TIMEOUT,
+      message: classifiedError.message,
+      retryAfterMs: classifiedError.retryAfterMs,
+    };
+  }
+  return {
+    type: 'error',
+    code: ERROR_CHAT_FAILED,
+    message: classifiedError.message,
+  };
+}
+
+export async function* streamChatWithRetry(
+  options: ChatOptions,
+  streamChatFn?: StreamChatFn,
+  policyOptions: StreamRetryPolicy = {},
+): AsyncGenerator<StreamChatEvent> {
+  const policy = getRetryPolicy();
+  const maxRetries = policyOptions.maxRetries ?? policy.defaults.maxRetries;
+  const baseDelayMs = policyOptions.baseDelayMs ?? policy.defaults.baseDelayMs;
+  const maxDelayMs = policyOptions.maxDelayMs ?? policy.defaults.maxDelayMs;
+  const jitterRatio = policyOptions.jitterRatio ?? policy.defaults.jitterRatio;
+  const circuitKey = policy.circuitKey(options.providerId, options.modelId);
+  const session = await getSession(options.sessionId);
+  const abortController = interruptManager.registerSession(options.sessionId, session?.parentId ?? undefined);
+  const isMainSession = session && !session.parentId;
+
+  if (isMainSession) {
+    const updatedSession = await updateSession(options.sessionId, { runningAt: new Date().toISOString() });
+    if (updatedSession) {
+      emitSessionUpdated(updatedSession);
+    }
+  }
+
+  try {
+    const circuitRemainingMs = policy.openCircuitRemainingMs(circuitKey);
+    if (circuitRemainingMs > 0) {
+      const message = 'Provider is temporarily unavailable after repeated failures.';
+      yield {
+        type: 'chat.retry',
+        sessionId: options.sessionId,
+        status: 'exhausted',
+        retryNumber: 0,
+        maxRetries,
+        errorType: 'server_error',
+        message,
+      };
+      yield {
+        type: 'error.server',
+        code: ERROR_SERVER_ERROR,
+        message,
+        retryAfterMs: circuitRemainingMs,
+      };
+      return;
+    }
+
+    let retries = 0;
+    while (retries <= maxRetries) {
+      let lastAssistantMessage: AssistantMessage | null = null;
+      let attemptHadToolActivity = false;
+
+      try {
+        const stream = streamChatFn ?? (await import('../core/agent')).streamChat;
+        for await (const event of stream({ ...options, retryAbortController: abortController })) {
+          if (event.type === 'message.created' || event.type === 'message.updated') {
+            if (event.message.role === 'assistant') {
+              lastAssistantMessage = event.message as AssistantMessage;
+            }
+          } else if (
+            (event.type === 'part.created' || event.type === 'part.updated')
+            && event.part.type === 'tool'
+          ) {
+            attemptHadToolActivity = true;
+          }
+          yield event;
+        }
+        policy.resetCircuit(circuitKey);
+        return;
+      } catch (err) {
+        const classifiedError = policy.classify(err);
+        const retryNumber = retries + 1;
+        const policyCanRetry = policy.canRetry({
+          retryNumber,
+          maxRetries,
+          classified: classifiedError,
+          attemptHadToolActivity,
+          aborted: abortController.signal.aborted,
+        });
+        // C6 step 6: mandatory side-effect barrier enforced by the runtime
+        // loop from non-overridable runtime evidence. A custom policy can
+        // only advise; it can never authorize a replay after tool activity
+        // or after the run was aborted.
+        const canRetry = policyCanRetry
+          && !attemptHadToolActivity
+          && !abortController.signal.aborted;
+        const circuitOpened = classifiedError.retryable
+          && !canRetry
+          && !abortController.signal.aborted
+          ? policy.recordCircuitFailure(circuitKey)
+          : false;
+
+        console.error('[streamChatWithRetry] AI SDK error', {
+          sessionId: options.sessionId,
+          model: options.modelId,
+          provider: options.providerId,
+          attempt: retries + 1,
+          maxRetries,
+          errorType: classifiedError.type,
+          errorMessage: classifiedError.message,
+          retryable: classifiedError.retryable,
+          attemptHadToolActivity,
+          circuitOpened,
+          rawError: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : err,
+        });
+
+        for (const event of await finalizeFailedAttempt(lastAssistantMessage, classifiedError, canRetry)) {
+          yield event;
+        }
+
+        if (!canRetry) {
+          if (classifiedError.retryable) {
+            const message = policy.exhaustedMessage({ attemptHadToolActivity, circuitOpened })
+              ?? classifiedError.message;
+            yield {
+              type: 'chat.retry',
+              sessionId: options.sessionId,
+              status: abortController.signal.aborted ? 'cancelled' : 'exhausted',
+              retryNumber: retries,
+              maxRetries,
+              errorType: policy.retryErrorType(classifiedError),
+              message,
+            };
+          }
+          if (!abortController.signal.aborted) {
+            yield createFinalErrorEvent(classifiedError);
+          }
+          return;
+        }
+
+        retries = retryNumber;
+        const delayMs = policy.calculateDelay(
+          retryNumber,
+          classifiedError,
+          baseDelayMs,
+          maxDelayMs,
+          jitterRatio,
+        );
+        const retryAt = Date.now() + delayMs;
+        const retryMessage: ChatRetryMessage = {
+          type: 'chat.retry',
+          sessionId: options.sessionId,
+          status: 'scheduled',
+          retryNumber,
+          maxRetries,
+          errorType: policy.retryErrorType(classifiedError),
+          message: classifiedError.message,
+          delayMs,
+          retryAt,
+        };
+        yield retryMessage;
+        console.log(`[streamChatWithRetry] Retrying ${options.sessionId} (${retryNumber}/${maxRetries}) in ${delayMs}ms`);
+
+        try {
+          await policy.waitForRetry(delayMs, abortController.signal);
+        } catch (delayError) {
+          if (!(delayError instanceof RetryDelayAbortedError)) {
+            throw delayError;
+          }
+          yield {
+            ...retryMessage,
+            status: 'cancelled',
+            delayMs: undefined,
+            retryAt: undefined,
+          };
+          return;
+        }
+
+        yield {
+          ...retryMessage,
+          status: 'started',
+          delayMs: undefined,
+          retryAt: undefined,
+        };
+      }
+    }
+  } finally {
+    interruptManager.unregisterSession(options.sessionId);
+    await rejectPendingAsksBySession(options.sessionId);
+    if (isMainSession) {
+      const updatedSession = await updateSession(options.sessionId, { runningAt: null });
+      if (updatedSession) {
+        emitSessionUpdated(updatedSession);
+      }
+    }
+  }
+}

package/src/runtime/agent-runtime.ts

@@ -0,0 +1,83 @@
+import type { CapekPlugin, AgentScopeHandle, RunScopeHandle } from '../kernel/types';
+
+export interface AgentRunContext {
+  runId: string;
+  signal: AbortSignal;
+  scope: RunScopeHandle;
+}
+
+export interface AgentDriver<Input, Result> {
+  run(context: AgentRunContext, input: Input): Promise<Result>;
+}
+
+export interface AgentRuntimeRunOptions {
+  signal?: AbortSignal;
+  cancellationReason?: string;
+}
+
+export interface AgentRuntime<Input, Result> {
+  run(runId: string, input: Input, options?: AgentRuntimeRunOptions): Promise<Result>;
+}
+
+export interface AgentRuntimeOptions<Input, Result> {
+  agentScope: AgentScopeHandle;
+  driver: AgentDriver<Input, Result>;
+  runPlugins?: (input: Input) => readonly CapekPlugin<unknown>[];
+}
+
+export function createAgentRuntime<Input, Result>(
+  options: AgentRuntimeOptions<Input, Result>,
+): AgentRuntime<Input, Result> {
+  return {
+    async run(runId, input, runOptions = {}) {
+      const runScope = await options.agentScope.createRunScope(
+        runId,
+        options.runPlugins?.(input) ?? [],
+      );
+      const controller = new AbortController();
+      const cancel = (): void => {
+        if (!controller.signal.aborted) {
+          controller.abort(runOptions.signal?.reason ?? new Error(runOptions.cancellationReason ?? 'Agent run cancelled'));
+        }
+        runScope.cancel(runOptions.cancellationReason ?? 'caller signal');
+      };
+      runOptions.signal?.addEventListener('abort', cancel, { once: true });
+
+      try {
+        if (runOptions.signal?.aborted) {
+          cancel();
+          throw controller.signal.reason;
+        }
+        await runScope.start();
+        const execution = options.driver.run({ runId, signal: controller.signal, scope: runScope }, input);
+        const barrier = runScope.registerCleanupBarrier(execution.then(() => {}, () => {}));
+        try {
+          const result = await execution;
+          await runScope.markTerminal('completed');
+          return result;
+        } finally {
+          barrier.dispose();
+        }
+      } catch (error: unknown) {
+        if (runScope.runStatus === 'created' || runScope.runStatus === 'running') {
+          if (controller.signal.aborted || runOptions.signal?.aborted) {
+            await runScope.cancel(runOptions.cancellationReason ?? 'caller signal').completion;
+          } else {
+            await runScope.markTerminal('failed');
+          }
+        }
+        throw error;
+      } finally {
+        if (!controller.signal.aborted) {
+          controller.abort(new Error('Agent run settled'));
+        }
+        runOptions.signal?.removeEventListener('abort', cancel);
+        if (runScope.runStatus === 'created' || runScope.runStatus === 'running') {
+          await runScope.cancel('runtime cleanup').completion;
+        } else {
+          await runScope.dispose();
+        }
+      }
+    },
+  };
+}

package/src/runtime/default-agent-driver.ts

@@ -0,0 +1,23 @@
+import type { AgentDriver, AgentRunContext } from './agent-runtime';
+
+export interface DriverAdvance<Result> {
+  result: Result;
+  continuation: 'complete' | 'continue';
+}
+
+export interface DefaultDriverInput<Result> {
+  advance(context: AgentRunContext): Promise<DriverAdvance<Result>>;
+  maxContinuations?: number;
+}
+
+export class DefaultAgentDriver implements AgentDriver<DefaultDriverInput<unknown>, unknown> {
+  async run(context: AgentRunContext, input: DefaultDriverInput<unknown>): Promise<unknown> {
+    const maxContinuations = input.maxContinuations ?? 1_000;
+    for (let continuation = 0; continuation <= maxContinuations; continuation += 1) {
+      if (context.signal.aborted) throw context.signal.reason;
+      const turn = await input.advance(context);
+      if (turn.continuation === 'complete') return turn.result;
+    }
+    throw new Error(`Agent driver exceeded ${maxContinuations} continuations`);
+  }
+}

package/src/runtime/domain-tool-source.ts

@@ -0,0 +1,156 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Ask, ToolDisplayConfig } from '@capekai/tool';
+import type { AnyVisualization } from '@capekai/types';
+
+/**
+ * Internal contributed-domain-tool payload context (C5).
+ *
+ * The turn-execution core must not import optional domains. A domain plugin
+ * attaches its executable payload to its kernel tool contribution under
+ * `DOMAIN_TOOL_PAYLOAD_FIELD`; `enterAgentScope` collects every visible
+ * payload into a scoped map keyed by tool name. Remaining C5 domains reuse
+ * this seam instead of adding domain-specific ALS layers.
+ *
+ * Three states the core distinguishes:
+ * - getContributedDomainToolPayloads() === null: no composed agent scope is
+ *   entered; a registered legacy fallback may apply.
+ * - an empty map: a composed scope is entered but carries no domain
+ *   payloads; legacy fallbacks must never apply.
+ * - a map with entries: the composed scope's own domain payloads.
+ */
+
+export const DOMAIN_TOOL_PAYLOAD_FIELD = 'capekDomainToolPayload';
+
+export interface DomainToolExecuteContext {
+  readonly workspaceId: string;
+  readonly sessionId: string;
+  /** Required: risk-bearing execution must always be able to ask for
+   * permission. Callers supply a real ask function even for risk 'none'. */
+  readonly ask: (ask: Ask) => Promise<unknown>;
+  readonly agentId?: string | null;
+  /** Domain-specific fields travel through this index signature. */
+  readonly [field: string]: unknown;
+}
+
+export interface DomainToolPayload {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Readonly<Record<string, unknown>>;
+  /** Client display hints declared by the domain (collapsed-row summary
+   * template). Travels through tool catalogs to clients; not consumed by
+   * the runtime. Mirrors ToolDefinition.display. */
+  readonly display?: ToolDisplayConfig;
+  /** Optional result visualization: called with the tool input and the
+   * domain's execute result after success. The builders merge the returned
+   * visualization into the tool output as `_visualization` (stripped again
+   * before LLM consumption). */
+  readonly visualize?: (
+    input: Record<string, unknown>,
+    result: Record<string, unknown>,
+  ) => AnyVisualization | undefined;
+  /** The domain's availability predicate (workspace settings gate). The
+   * owning domain uses the same predicate for its context contribution. */
+  readonly isEnabled?: (workspaceId: string, sessionId?: string) => boolean | Promise<boolean>;
+  /** Optional per-build definition resolver for tools whose description or
+   * schema depends on per-session data (the task tool's resolved subagent
+   * list, the workflow tool's allowed leaf agents). Returns null when the
+   * tool must be omitted for this session. `allowedSubagentIds` carries a
+   * build-time-captured target list when the domain needs it. */
+  readonly resolveDefinition?: (
+    sessionId: string,
+    options?: Record<string, unknown>,
+  ) => Promise<{
+    description: string;
+    inputSchema: Readonly<Record<string, unknown>>;
+    allowedSubagentIds?: string[];
+  } | null>;
+  execute(
+    input: Record<string, unknown>,
+    context: DomainToolExecuteContext,
+  ): Promise<Record<string, unknown>>;
+}
+
+export function isDomainToolPayload(value: unknown): value is DomainToolPayload {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as Record<string, unknown>;
+  return typeof candidate.name === 'string'
+    && typeof candidate.description === 'string'
+    && typeof candidate.inputSchema === 'object' && candidate.inputSchema !== null
+    && typeof candidate.execute === 'function';
+}
+
+/** Merges a payload's `visualize` result into the execute output as
+ * `_visualization`, mirroring the external-tool builder's merge. Only a
+ * successful object-shaped output can carry a visualization. */
+export function mergeDomainToolVisualization(
+  payload: DomainToolPayload,
+  input: Record<string, unknown>,
+  result: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!payload.visualize) return result;
+  if (typeof result.error === 'string' && result.error.length > 0) return result;
+  const visualization = payload.visualize(input, result);
+  if (!visualization) return result;
+  return { ...result, _visualization: visualization };
+}
+
+const scopedPayloads = new AsyncLocalStorage<ReadonlyMap<string, DomainToolPayload>>();
+
+export function withContributedDomainToolPayloads<T>(
+  payloads: ReadonlyMap<string, DomainToolPayload>,
+  callback: () => T,
+): T {
+  return scopedPayloads.run(payloads, callback);
+}
+
+/** null means no composed agent scope is entered; an empty map is a real
+ * composed scope with zero domain payloads and disables fallbacks. */
+export function getContributedDomainToolPayloads(): ReadonlyMap<string, DomainToolPayload> | null {
+  return scopedPayloads.getStore() ?? null;
+}
+
+const fallbacks = new Map<string, DomainToolPayload>();
+
+export function registerDomainToolFallback(name: string, payload: DomainToolPayload): void {
+  fallbacks.set(name, payload);
+}
+
+export function getDomainToolFallback(name: string): DomainToolPayload | null {
+  return fallbacks.get(name) ?? null;
+}
+
+/** Registered domain-tool fallback definitions for tool catalogs: name,
+ * description, schema, and display hints. Introspects the fallback registry
+ * the server installs at bootstrap. */
+export function listDomainToolFallbackDefinitions(): Array<{
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  display?: ToolDisplayConfig;
+}> {
+  return [...fallbacks.values()].map((payload) => ({
+    name: payload.name,
+    description: payload.description,
+    inputSchema: payload.inputSchema as Record<string, unknown>,
+    ...(payload.display ? { display: payload.display } : {}),
+  }));
+}
+
+function isTestExecution(): boolean {
+  return process.env.NODE_ENV === 'test'
+    || (globalThis as { Bun?: { env?: Record<string, string> } }).Bun?.env?.NODE_ENV === 'test';
+}
+
+/** Test-only destructive reset. Fails closed outside test execution: a
+ * production process must never be able to wipe the unscoped fallback
+ * registry. The production installation path (configureRuntimeHost plus the
+ * six install*ToolFallback calls) is the idempotent way to restore the
+ * complete inventory. */
+export function resetDomainToolFallbacksForTests(): void {
+  if (!isTestExecution()) {
+    throw new Error(
+      'Domain tool fallback reset is only available during test execution',
+    );
+  }
+  fallbacks.clear();
+}

package/src/runtime/events.ts

@@ -0,0 +1,61 @@
+import type { Ask } from '@capekai/tool'
+import type { AskAuthority, AssistantMessage, Message, MessageWithParts, Part, QueuedMessage, Session } from '@capekai/types';
+import type { UsageEventData } from '../core/step-handlers';
+
+export type RuntimeEvent =
+  | { kind: 'message'; action: 'created' | 'updated'; message: Message }
+  | { kind: 'part'; action: 'created' | 'updated'; sessionId: string; part: Part }
+  | { kind: 'part'; action: 'append'; sessionId: string; partId: string; field: 'text' | 'reasoning'; delta: string }
+  | { kind: 'session'; action: 'created' | 'updated' | 'renamed'; session: Session }
+  | { kind: 'session'; action: 'state'; sessionId: string; messages: MessageWithParts[] }
+  | { kind: 'usage'; sessionId: string; usage: UsageEventData; model: string; variant?: string }
+  | {
+    kind: 'retry';
+    sessionId: string;
+    status: 'scheduled' | 'started' | 'exhausted' | 'cancelled';
+    attempt: number;
+    maxAttempts: number;
+    errorType: 'rate_limit' | 'server_error' | 'timeout' | 'network';
+    message: string;
+    delayMs?: number;
+    retryAt?: number;
+  }
+  | { kind: 'failure'; category: 'generic'; code: string; message: string; sessionId?: string }
+  | { kind: 'failure'; category: 'rate_limit'; code: 'rate_limit'; message: string; sessionId?: string; retryAfterMs: number }
+  | { kind: 'failure'; category: 'server'; code: 'server_error'; message: string; sessionId?: string; retryAfterMs?: number }
+  | { kind: 'failure'; category: 'timeout'; code: 'timeout'; message: string; sessionId?: string; retryAfterMs?: number }
+  | { kind: 'queue'; action: 'added'; sessionId: string; message: QueuedMessage }
+  | { kind: 'queue'; action: 'sending'; sessionId: string; queueId: string }
+  | {
+    kind: 'ask';
+    action: 'requested';
+    sessionId: string;
+    toolCallId: string;
+    toolName: string;
+    ask: Ask;
+    requestId?: string;
+    authority?: AskAuthority;
+  }
+  | { kind: 'ask'; action: 'timed_out'; sessionId: string; toolCallId: string; requestId?: string }
+  | { kind: 'terminal'; message: AssistantMessage; sessionId: string };
+
+export type RuntimeAudience<Origin = unknown> =
+  | { scope: 'global' }
+  | { scope: 'session'; sessionId: string }
+  | { scope: 'origin'; origin: Origin }
+  | { scope: 'controller'; sessionId: string }
+  | { scope: 'ask_targets'; sessionId: string; authority: AskAuthority }
+  | { scope: 'host' };
+
+export interface RuntimeDelivery<Origin = unknown> {
+  audience: RuntimeAudience<Origin>;
+  event: RuntimeEvent;
+}
+
+export type RuntimeEventSink = (event: RuntimeEvent) => void;
+
+export interface RuntimeEventContext<Origin = unknown> {
+  emit(delivery: RuntimeDelivery<Origin>): void;
+  observe?(delivery: RuntimeDelivery<Origin>): void;
+  attachOriginToSession(origin: Origin, sessionId: string): void;
+}