@intx/hub-sessions 0.1.2 → 0.2.2

package/dist/available-skills-stanza.js

@@ -0,0 +1,32 @@
+/**
+ * Render the `<available_skills>` stanza appended to the agent's
+ * system prompt. Returns the empty string when `entries` is empty —
+ * an empty `<available_skills></available_skills>` wrapper would be
+ * misleading noise for agents with no skills attached.
+ *
+ * Values are XML-escaped at the boundary. The skill kind handler
+ * already rejects descriptions containing literal `<` or `>` so the
+ * `&` escape is the practical case in production; the others are
+ * defensive.
+ */
+export function buildAvailableSkillsStanza(entries) {
+    if (entries.length === 0) {
+        return "";
+    }
+    const lines = ["<available_skills>"];
+    for (const entry of entries) {
+        lines.push("  <skill>");
+        lines.push(`    <name>${escapeXml(entry.qualifiedName)}</name>`);
+        lines.push(`    <description>${escapeXml(entry.description)}</description>`);
+        lines.push(`    <path>${escapeXml(entry.workspacePath)}</path>`);
+        lines.push("  </skill>");
+    }
+    lines.push("</available_skills>");
+    return lines.join("\n");
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}

package/dist/credential-push.d.ts

@@ -0,0 +1,32 @@
+import type { DB } from "@intx/db";
+import type { SidecarRouter } from "./ws/sidecar-handler.js";
+/**
+ * Re-resolve a single running instance's inference sources from the catalog
+ * (the agent's model requirements plus the invoker preferences persisted on
+ * the instance) and push the ordered list to its sidecar. The head of the
+ * catalog-priority-ordered list is the active default; the tail is the
+ * failover chain.
+ *
+ * No-op when the instance resolves to no launchable source — the resolver's
+ * own logger is the signal for why.
+ */
+export declare function pushInstanceSourceUpdate(db: DB["db"], sidecarRouter: Pick<SidecarRouter, "sendSourcesUpdate">, instance: {
+    address: string;
+    agentId: string;
+    tenantId: string;
+    modelPreferences: unknown;
+}): Promise<void>;
+/**
+ * After a credential secret is rotated, re-resolve every running instance in
+ * the tenant against the catalog and push the updates. A rotated secret flows
+ * through because resolution dereferences the provider's credential reference
+ * to the current secret.
+ */
+export declare function pushSourceUpdates(db: DB["db"], sidecarRouter: SidecarRouter, tenantId: string): Promise<void>;
+/**
+ * After a catalog edit in a tenant, re-resolve and push to every running
+ * instance in that tenant AND its descendants. Descendants inherit the
+ * edited tenant's catalog, so a change there (a disabled provider, a new
+ * offering, a price update) alters their resolved sources too.
+ */
+export declare function pushSourceUpdatesSubtree(db: DB["db"], sidecarRouter: SidecarRouter, tenantId: string): Promise<void>;

package/dist/credential-push.js

@@ -0,0 +1,85 @@
+// Shared logic for re-resolving a running instance's inference sources from
+// the catalog and pushing the update to its sidecar.
+//
+// Used after a credential secret rotation (a model provider's credential
+// changes the resolved source's apiKey) and on sidecar reconnect.
+import { eq, and, inArray } from "drizzle-orm";
+import { getLogger } from "@intx/log";
+import { agentInstance } from "@intx/db/schema";
+import { resolveInstanceModelSources, getDescendantTenants } from "@intx/db";
+const log = getLogger(["hub", "credentials"]);
+/**
+ * Re-resolve a single running instance's inference sources from the catalog
+ * (the agent's model requirements plus the invoker preferences persisted on
+ * the instance) and push the ordered list to its sidecar. The head of the
+ * catalog-priority-ordered list is the active default; the tail is the
+ * failover chain.
+ *
+ * No-op when the instance resolves to no launchable source — the resolver's
+ * own logger is the signal for why.
+ */
+export async function pushInstanceSourceUpdate(db, sidecarRouter, instance) {
+    const resolution = await resolveInstanceModelSources(db, instance.tenantId, instance);
+    if (!resolution.ok)
+        return;
+    const [head] = resolution.sources;
+    if (head === undefined)
+        return;
+    await sidecarRouter.sendSourcesUpdate(instance.address, resolution.sources, head.id);
+}
+/**
+ * Re-resolve every running instance in the given tenants against the catalog
+ * and push the updates to sidecars. Each instance re-resolves from its own
+ * tenant's context (its ancestor chain), so the rotated/edited upstream entry
+ * flows through. Errors are logged per-instance but do not propagate.
+ */
+async function pushSourceUpdatesToTenants(db, sidecarRouter, tenantIds) {
+    if (tenantIds.length === 0)
+        return;
+    // Callers fire this without awaiting, so it must never reject: a failure to
+    // enumerate or push is logged and dropped, not propagated as an unhandled
+    // rejection. The push is best effort — the next mutation or a sidecar
+    // reconnect re-resolves sources.
+    try {
+        const instances = await db.query.agentInstance.findMany({
+            where: and(inArray(agentInstance.tenantId, tenantIds), eq(agentInstance.status, "running")),
+        });
+        if (instances.length === 0)
+            return;
+        const results = await Promise.allSettled(instances.map((instance) => pushInstanceSourceUpdate(db, sidecarRouter, instance)));
+        for (const result of results) {
+            if (result.status === "rejected") {
+                log.warn `Failed to push source update: ${String(result.reason)}`;
+            }
+        }
+    }
+    catch (err) {
+        log.warn `Failed to push source updates: ${String(err)}`;
+    }
+}
+/**
+ * After a credential secret is rotated, re-resolve every running instance in
+ * the tenant against the catalog and push the updates. A rotated secret flows
+ * through because resolution dereferences the provider's credential reference
+ * to the current secret.
+ */
+export async function pushSourceUpdates(db, sidecarRouter, tenantId) {
+    await pushSourceUpdatesToTenants(db, sidecarRouter, [tenantId]);
+}
+/**
+ * After a catalog edit in a tenant, re-resolve and push to every running
+ * instance in that tenant AND its descendants. Descendants inherit the
+ * edited tenant's catalog, so a change there (a disabled provider, a new
+ * offering, a price update) alters their resolved sources too.
+ */
+export async function pushSourceUpdatesSubtree(db, sidecarRouter, tenantId) {
+    let tenants;
+    try {
+        tenants = await getDescendantTenants(db, tenantId);
+    }
+    catch (err) {
+        log.warn `Failed to enumerate descendants for source push: ${String(err)}`;
+        return;
+    }
+    await pushSourceUpdatesToTenants(db, sidecarRouter, tenants);
+}

package/dist/event-collector-registry.d.ts

@@ -0,0 +1,20 @@
+import type { DB } from "@intx/db";
+import type { InferenceEvent } from "@intx/types/runtime";
+import type { SessionStatus } from "@intx/types";
+import { type TurnFinalized } from "./event-collector.js";
+export type EventCollectorRegistry = {
+    create(agentAddress: string, tenantId: string, sessionId: string, instanceId: string): void;
+    dispatch(agentAddress: string, event: InferenceEvent): void;
+    abandon(agentAddress: string): void;
+    has(agentAddress: string): boolean;
+    getStatus(agentAddress: string): SessionStatus | undefined;
+    getAccumulatedText(agentAddress: string): string | undefined;
+    getCurrentTurnId(agentAddress: string): string | null | undefined;
+    getLastTurnId(agentAddress: string): string | null | undefined;
+};
+export type EventCollectorRegistryConfig = {
+    db: DB["db"];
+    onTurnFinalized?: (agentAddress: string, turn: TurnFinalized) => void;
+};
+export declare function deriveStatus(event: InferenceEvent): SessionStatus | null;
+export declare function createEventCollectorRegistry(config: EventCollectorRegistryConfig): EventCollectorRegistry;

package/dist/event-collector-registry.js

@@ -0,0 +1,115 @@
+// Registry of active event collectors, keyed by agent address.
+//
+// The hub creates a collector when an instance starts and removes it when the
+// instance ends or the sidecar disconnects. The hub session orchestrator's
+// `agent.event` listener looks up the collector by agent address and
+// dispatches the event.
+import { getLogger } from "@intx/log";
+import { createEventCollector, } from "./event-collector.js";
+const log = getLogger(["hub", "event-collector-registry"]);
+export function deriveStatus(event) {
+    switch (event.type) {
+        case "inference.start":
+            return { status: "busy" };
+        case "connector.reply":
+            return { status: "idle" };
+        case "reactor.gate.blocked":
+            if (event.data.reason === "approval")
+                return { status: "waiting_approval" };
+            return null;
+        case "reactor.gate.cleared":
+            return { status: "busy" };
+        case "reactor.done":
+            return { status: "idle" };
+        case "reactor.error":
+            if (event.data.fatal)
+                return { status: "idle" };
+            return null;
+        default:
+            return null;
+    }
+}
+export function createEventCollectorRegistry(config) {
+    const { db, onTurnFinalized } = config;
+    const collectors = new Map();
+    const statuses = new Map();
+    function create(agentAddress, tenantId, sessionId, instanceId) {
+        if (collectors.has(agentAddress)) {
+            log.warn `Collector already exists for ${agentAddress}, replacing`;
+            abandon(agentAddress);
+        }
+        const collector = createEventCollector({
+            db,
+            sessionId,
+            instanceId,
+            tenantId,
+            ...(onTurnFinalized
+                ? {
+                    onTurnFinalized: (turn) => onTurnFinalized(agentAddress, turn),
+                }
+                : {}),
+        });
+        collectors.set(agentAddress, collector);
+        statuses.set(agentAddress, { status: "idle" });
+    }
+    function removeCollector(agentAddress) {
+        collectors.delete(agentAddress);
+        statuses.delete(agentAddress);
+    }
+    function dispatch(agentAddress, event) {
+        const collector = collectors.get(agentAddress);
+        if (collector === undefined) {
+            return;
+        }
+        const derived = deriveStatus(event);
+        if (derived !== null) {
+            statuses.set(agentAddress, derived);
+        }
+        const isTerminal = event.type === "reactor.done" ||
+            (event.type === "reactor.error" && event.data.fatal);
+        collector
+            .onEvent(event)
+            .catch((err) => {
+            log.warn `Failed to persist event ${event.type} seq=${String(event.seq)} for ${agentAddress}: ${err instanceof Error ? err.message : String(err)}`;
+        })
+            .finally(() => {
+            if (isTerminal) {
+                removeCollector(agentAddress);
+            }
+        });
+    }
+    function abandon(agentAddress) {
+        const collector = collectors.get(agentAddress);
+        if (collector === undefined)
+            return;
+        collector.abandon().catch((err) => {
+            log.warn `Failed to abandon collector for ${agentAddress}: ${err instanceof Error ? err.message : String(err)}`;
+        });
+        removeCollector(agentAddress);
+    }
+    function has(agentAddress) {
+        return collectors.has(agentAddress);
+    }
+    function getStatus(agentAddress) {
+        return statuses.get(agentAddress);
+    }
+    function getAccumulatedText(agentAddress) {
+        return collectors.get(agentAddress)?.getAccumulatedText();
+    }
+    function getCurrentTurnId(agentAddress) {
+        return collectors.get(agentAddress)?.getCurrentTurnId();
+    }
+    function getLastTurnId(agentAddress) {
+        return collectors.get(agentAddress)?.getLastTurnId();
+    }
+    return {
+        create,
+        dispatch,
+        abandon,
+        has,
+        getStatus,
+        getAccumulatedText,
+        getCurrentTurnId,
+        getLastTurnId,
+    };
+}

package/dist/event-collector.d.ts

@@ -0,0 +1,39 @@
+import type { InferenceEvent } from "@intx/types/runtime";
+import { type DB } from "@intx/db";
+export type TurnToolCall = {
+    name: string;
+    arguments: Record<string, unknown>;
+    result: string;
+    isError: boolean;
+};
+export type TurnFinalized = {
+    turnId: string;
+    status: "completed" | "failed";
+    text: string;
+    hadReply: boolean;
+    hadError: boolean;
+    errors: {
+        category: string;
+        message: string;
+    }[];
+    toolCalls: TurnToolCall[];
+    toolErrors: {
+        name: string;
+        content: string;
+    }[];
+};
+export type EventCollector = {
+    onEvent(event: InferenceEvent): Promise<void>;
+    abandon(): Promise<void>;
+    getAccumulatedText(): string;
+    getCurrentTurnId(): string | null;
+    getLastTurnId(): string | null;
+};
+export type EventCollectorConfig = {
+    db: DB["db"];
+    sessionId: string;
+    instanceId: string;
+    tenantId: string;
+    onTurnFinalized?: (turn: TurnFinalized) => void;
+};
+export declare function createEventCollector(config: EventCollectorConfig): EventCollector;

package/dist/event-collector.js

@@ -0,0 +1,357 @@
+// Persists assistant inference turns from the InferenceEvent stream.
+//
+// One collector per active session. Events are written eagerly to the DB
+// so data survives crashes. The collector does not block the websocket
+// message loop — callers should fire-and-forget and log errors.
+import { eq } from "drizzle-orm";
+import { inferenceTurn, turnPart } from "@intx/db/schema";
+import { getLogger } from "@intx/log";
+import { parseTurnPartType } from "@intx/db";
+import { generateId } from "@intx/hub-common";
+const log = getLogger(["hub", "event-collector"]);
+export function createEventCollector(config) {
+    const { db, sessionId, instanceId, tenantId, onTurnFinalized } = config;
+    // Current inference turn being accumulated. A new turn is created on each
+    // inference.start. Finalized on connector.reply, reactor.done,
+    // reactor.error (fatal), or abandon. Null when no turn is active.
+    let currentTurnId = null;
+    // Most recent turn ID, set in beginTurn. Unlike currentTurnId this is NOT
+    // cleared on finalization — the SSE replay endpoint needs the turn ID
+    // after the turn commits but before the collector is removed.
+    let lastTurnId = null;
+    let ordinal = 0;
+    // Prevents double-finalization when reactor.done and abandon() race.
+    let finalized = false;
+    // Set when inference.error fires so connector.reply knows to persist its
+    // content (on normal turns, inference.done already persisted the text).
+    let pendingError = false;
+    // Accumulated visible text content for the current turn. Only text blocks
+    // from inference.done (not thinking/reasoning) are included. Reset on each
+    // new turn.
+    let accumulatedText = "";
+    // In-progress text from inference.text.delta events during the current
+    // inference step. Reset on inference.done (when accumulatedText takes over).
+    let streamingText = "";
+    // Set when inference.error fires. Unlike pendingError (which resets on
+    // connector.reply), this persists until finalization so the callback can
+    // report whether an inference error occurred during the turn.
+    let turnHadError = false;
+    // Structured error details accumulated during the turn for inclusion in
+    // TurnFinalized. Reset on each new turn.
+    let accumulatedErrors = [];
+    // Maps tool call IDs to tool names for correlating tool results with their
+    // originating calls. Populated from inference.done tool_call blocks.
+    const callNames = new Map();
+    const callArgs = new Map();
+    // Tool calls accumulated for TurnFinalized.
+    let accumulatedToolCalls = [];
+    // Tool results that reported isError, accumulated for TurnFinalized.
+    let accumulatedToolErrors = [];
+    async function onEvent(event) {
+        switch (event.type) {
+            case "inference.start":
+                await beginTurn(event.data.model);
+                await insertPart("step-start", null, { model: event.data.model });
+                break;
+            case "inference.text.delta":
+                streamingText += event.data.token;
+                break;
+            case "inference.done":
+                await handleInferenceDone(event.data.turn.content);
+                streamingText = "";
+                break;
+            case "tool.done": {
+                const callId = event.data.result.callId;
+                const isError = event.data.result.isError ?? false;
+                await insertPart("tool", null, {
+                    kind: "result",
+                    callId,
+                    content: event.data.result.content,
+                    isError,
+                });
+                const name = callNames.get(callId) ?? callId;
+                const raw = event.data.result.content;
+                const content = typeof raw === "string" ? raw : JSON.stringify(raw);
+                accumulatedToolCalls.push({
+                    name,
+                    arguments: callArgs.get(callId) ?? {},
+                    result: content,
+                    isError,
+                });
+                if (isError) {
+                    accumulatedToolErrors.push({ name, content });
+                }
+                break;
+            }
+            case "inference.error":
+                pendingError = true;
+                turnHadError = true;
+                await insertPart("error", event.data.error.message, {
+                    category: event.data.error.category,
+                    ...(event.data.error.statusCode !== undefined
+                        ? { statusCode: event.data.error.statusCode }
+                        : {}),
+                });
+                accumulatedErrors.push({
+                    category: event.data.error.category,
+                    message: event.data.error.message,
+                });
+                break;
+            case "connector.reply":
+                if (finalized)
+                    break;
+                // Only persist reply content when it originated from an error path.
+                // On normal turns inference.done already persisted the text parts.
+                if (pendingError) {
+                    accumulatedText += event.data.content;
+                    await insertPart("text", event.data.content, null);
+                    pendingError = false;
+                }
+                await finalizeTurn(turnHadError ? "failed" : "completed", true, true);
+                break;
+            case "reactor.done":
+                await finalizeTurn("completed", true, false);
+                break;
+            case "reactor.error":
+                if (event.data.fatal && !finalized) {
+                    // The reactor failed before any inference started (e.g., context
+                    // store load failure), but the user needs to see why their agent
+                    // failed, and without a turn there is no container for the error.
+                    if (currentTurnId === null) {
+                        await beginTurn("unknown");
+                    }
+                    turnHadError = true;
+                    // Push after beginTurn so the error survives the array reset.
+                    accumulatedErrors.push({
+                        category: "reactor_error",
+                        message: event.data.error,
+                    });
+                    await insertPart("error", event.data.error, {
+                        category: "reactor_error",
+                    });
+                    await finalizeTurn("failed", true, false);
+                }
+                else if (!event.data.fatal && !finalized) {
+                    if (currentTurnId === null) {
+                        await beginTurn("unknown");
+                    }
+                    turnHadError = true;
+                    accumulatedErrors.push({
+                        category: "reactor_error",
+                        message: event.data.error,
+                    });
+                    await insertPart("error", event.data.error, {
+                        category: "reactor_error",
+                    });
+                }
+                break;
+            default:
+                // reactor.start, streaming deltas, usage, and other events are
+                // not persisted.
+                break;
+        }
+    }
+    async function beginTurn(model) {
+        // A previous turn is still open — this is normal in multi-step tool-use
+        // loops where inference.start fires again after tools return.
+        if (currentTurnId !== null && !finalized) {
+            await finalizeTurn("completed", true, false);
+        }
+        currentTurnId = generateId("inferenceTurn");
+        lastTurnId = currentTurnId;
+        ordinal = 0;
+        finalized = false;
+        pendingError = false;
+        accumulatedText = "";
+        streamingText = "";
+        turnHadError = false;
+        accumulatedErrors = [];
+        callNames.clear();
+        callArgs.clear();
+        accumulatedToolCalls = [];
+        accumulatedToolErrors = [];
+        await db.insert(inferenceTurn).values({
+            id: currentTurnId,
+            sessionId,
+            instanceId,
+            tenantId,
+            model,
+            status: "running",
+            startedAt: new Date(),
+        });
+    }
+    async function handleInferenceDone(content) {
+        for (const block of content) {
+            switch (block.type) {
+                case "text":
+                    accumulatedText += block.text;
+                    await insertPart("text", block.text, null);
+                    break;
+                case "thinking":
+                    await insertPart("reasoning", block.thinking, null);
+                    break;
+                case "redacted_thinking":
+                    // The opaque `data` blob is meaningless to humans and
+                    // must be preserved verbatim for echo-back on follow-up
+                    // turns; persisting it as a reasoning row would invite
+                    // truncation or display. Skip and let the adapter layer
+                    // own the round-trip.
+                    break;
+                case "refusal":
+                    // Refusal blocks carry human-readable text the model
+                    // emitted when it declined a structured-output request.
+                    // A dedicated `refusal` part kind keeps the signal
+                    // distinct from ordinary `text` (the model produced
+                    // schema-conformant content) and from `error` (the HTTP
+                    // call failed or the protocol mismatched). Session
+                    // readers can branch on the part type to render policy
+                    // declines differently from regular assistant output.
+                    await insertPart("refusal", block.reason, null);
+                    break;
+                case "tool_call":
+                    callNames.set(block.id, block.name);
+                    callArgs.set(block.id, block.arguments);
+                    await insertPart("tool", null, {
+                        kind: "call",
+                        callId: block.id,
+                        name: block.name,
+                        arguments: block.arguments,
+                    });
+                    break;
+                case "tool_result":
+                    // Tool results in the content block are echoes of earlier
+                    // tool.done events. Skip to avoid duplication.
+                    break;
+                case "citation":
+                    // Citations annotate model output by reference (URI or
+                    // document index). Persistence semantics — whether the
+                    // cited source warrants an audit row of its own — are not
+                    // yet settled; skip until they are.
+                    break;
+                case "code_execution_request":
+                case "code_execution_result":
+                    // Server-side code execution requests and results.
+                    // Persistence semantics — whether the code and its output
+                    // warrant audit rows of their own, and how to relate the
+                    // pair through the requestId back-pointer — are not yet
+                    // settled; skip until they are.
+                    break;
+                case "image":
+                case "audio":
+                case "video":
+                case "document": {
+                    // All media block variants persist into the generic "file"
+                    // part bucket. The block's own `type` distinguishes the
+                    // semantic role; `mimeType` distinguishes the encoding; the
+                    // MediaSource discriminant distinguishes inline vs reference.
+                    const source = block.source;
+                    if (source.kind === "base64") {
+                        await insertPart("file", null, {
+                            kind: "base64",
+                            mimeType: source.mimeType,
+                            dataLength: source.data.length,
+                        });
+                    }
+                    else if (source.kind === "file-reference") {
+                        await insertPart("file", null, {
+                            kind: "file-reference",
+                            mimeType: source.mimeType,
+                            reference: source.reference,
+                        });
+                    }
+                    else if (source.kind === "url") {
+                        // The `url` MediaSource variant carries a self-contained
+                        // dereferenceable HTTP(S) URL (Gemini accepts these in
+                        // `fileData/fileUri`; other adapters route similarly).
+                        // The session record keeps the URL on a distinct `url`
+                        // field rather than reusing the `reference` slot that
+                        // `file-reference` uses: a session reader that filters
+                        // or joins on `metadata->>'reference'` should see
+                        // provider-opaque file ids only, with public URLs
+                        // surfaced under their own field. The discriminant
+                        // `kind` is the structural source of truth, and the
+                        // field-per-variant shape keeps naive substring queries
+                        // honest.
+                        await insertPart("file", null, {
+                            kind: "url",
+                            mimeType: source.mimeType,
+                            url: source.url,
+                        });
+                    }
+                    else {
+                        source;
+                        throw new Error(`unreachable: unknown MediaSource kind`);
+                    }
+                    break;
+                }
+            }
+        }
+        // Mark the end of this inference step.
+        await insertPart("step-finish", null, null);
+    }
+    async function finalizeTurn(status, notify, hadReply) {
+        if (currentTurnId === null || finalized)
+            return;
+        finalized = true;
+        const turnId = currentTurnId;
+        await db
+            .update(inferenceTurn)
+            .set({ status, endedAt: new Date() })
+            .where(eq(inferenceTurn.id, turnId));
+        if (notify && onTurnFinalized) {
+            onTurnFinalized({
+                turnId,
+                status,
+                text: accumulatedText,
+                hadReply,
+                hadError: turnHadError,
+                errors: [...accumulatedErrors],
+                toolCalls: [...accumulatedToolCalls],
+                toolErrors: [...accumulatedToolErrors],
+            });
+        }
+        currentTurnId = null;
+    }
+    async function abandon() {
+        if (currentTurnId === null || finalized)
+            return;
+        log.warn `Abandoning running turn ${currentTurnId} for session ${sessionId}`;
+        await finalizeTurn("failed", false, false);
+    }
+    async function insertPart(partType, content, metadata) {
+        if (currentTurnId === null) {
+            log.warn `Dropping ${partType} part: no active turn for session ${sessionId}`;
+            return;
+        }
+        const values = {
+            id: generateId("turnPart"),
+            turnId: currentTurnId,
+            sessionId,
+            type: parseTurnPartType(partType),
+            ordinal: ordinal++,
+        };
+        if (content !== null) {
+            values.content = content;
+        }
+        if (metadata !== null) {
+            values.metadata = metadata;
+        }
+        await db.insert(turnPart).values(values);
+    }
+    function getAccumulatedText() {
+        return accumulatedText + streamingText;
+    }
+    function getCurrentTurnId() {
+        return currentTurnId;
+    }
+    function getLastTurnId() {
+        return lastTurnId;
+    }
+    return {
+        onEvent,
+        abandon,
+        getAccumulatedText,
+        getCurrentTurnId,
+        getLastTurnId,
+    };
+}