@turingfocus/chat-testing 0.1.0

package/dist/memory-gateway-clock.js

@@ -0,0 +1,52 @@
+/** Deterministic clock used to drive Memory Gateway deadlines without timers. */
+export class MemoryGatewayClock {
+    #deadlineWaiters = new Set();
+    #time;
+    constructor(now) {
+        this.#time = now;
+    }
+    now() {
+        return this.#time;
+    }
+    signal(deadlineAt) {
+        if (this.#time >= deadlineAt) {
+            return { cancel: () => undefined, promise: Promise.resolve() };
+        }
+        let active = true;
+        let resolvePromise;
+        const promise = new Promise((resolve) => {
+            resolvePromise = resolve;
+        });
+        const waiter = {
+            deadlineAt,
+            resolve: () => {
+                if (!active)
+                    return;
+                active = false;
+                this.#deadlineWaiters.delete(waiter);
+                resolvePromise();
+            },
+        };
+        this.#deadlineWaiters.add(waiter);
+        return {
+            cancel: () => {
+                if (!active)
+                    return;
+                active = false;
+                this.#deadlineWaiters.delete(waiter);
+            },
+            promise,
+        };
+    }
+    advanceTo(timestamp) {
+        if (!Number.isSafeInteger(timestamp) || timestamp < this.#time) {
+            throw new TypeError("Memory Gateway time must advance to a safe integer");
+        }
+        this.#time = timestamp;
+        for (const waiter of [...this.#deadlineWaiters]) {
+            if (waiter.deadlineAt <= timestamp)
+                waiter.resolve();
+        }
+    }
+}
+//# sourceMappingURL=memory-gateway-clock.js.map

package/dist/memory-gateway-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-gateway-clock.js","sourceRoot":"","sources":["../src/memory-gateway-clock.ts"],"names":[],"mappings":"AAUA,iFAAiF;AACjF,MAAM,OAAO,kBAAkB;IACpB,gBAAgB,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtD,KAAK,CAAS;IAEd,YAAY,GAAW;QACrB,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;IACnB,CAAC;IAED,GAAG;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,UAAkB;QACvB,IAAI,IAAI,CAAC,KAAK,IAAI,UAAU,EAAE,CAAC;YAC7B,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;QACjE,CAAC;QAED,IAAI,MAAM,GAAG,IAAI,CAAC;QAClB,IAAI,cAAwC,CAAC;QAC7C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAC5C,cAAc,GAAG,OAAO,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,MAAM,MAAM,GAAmB;YAC7B,UAAU;YACV,OAAO,EAAE,GAAG,EAAE;gBACZ,IAAI,CAAC,MAAM;oBAAE,OAAO;gBACpB,MAAM,GAAG,KAAK,CAAC;gBACf,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACrC,cAAe,EAAE,CAAC;YACpB,CAAC;SACF,CAAC;QACF,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClC,OAAO;YACL,MAAM,EAAE,GAAG,EAAE;gBACX,IAAI,CAAC,MAAM;oBAAE,OAAO;gBACpB,MAAM,GAAG,KAAK,CAAC;gBACf,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACvC,CAAC;YACD,OAAO;SACR,CAAC;IACJ,CAAC;IAED,SAAS,CAAC,SAAiB;QACzB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/D,MAAM,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAC;QAC5E,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,KAAK,MAAM,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAChD,IAAI,MAAM,CAAC,UAAU,IAAI,SAAS;gBAAE,MAAM,CAAC,OAAO,EAAE,CAAC;QACvD,CAAC;IACH,CAAC;CACF"}

package/dist/memory-gateway-holds.d.ts

@@ -0,0 +1,26 @@
+export type MemoryGatewayOperation = "answerInteraction" | "interrupt" | "listConversations" | "loadConversation" | "sendText" | "subscribe";
+export type MemoryGatewayHoldPoint = MemoryGatewayOperation | "gateway.dispose" | "subscription.dispose";
+export interface MemoryGatewayHold {
+    readonly completed: Promise<void>;
+    readonly resourceDisposeCount: number;
+    readonly started: Promise<void>;
+    release(): void;
+}
+export interface HeldTransportCompletion {
+    readonly subscription?: FakeTransportSubscription | undefined;
+}
+export declare class FakeTransportSubscription {
+    #private;
+    constructor(onDispose: () => void);
+    dispose(): void;
+}
+export declare class PendingHold implements MemoryGatewayHold {
+    #private;
+    constructor(point: MemoryGatewayHoldPoint);
+    get completed(): Promise<void>;
+    get resourceDisposeCount(): number;
+    get started(): Promise<void>;
+    start(): Promise<HeldTransportCompletion>;
+    release(): void;
+}
+//# sourceMappingURL=memory-gateway-holds.d.ts.map

package/dist/memory-gateway-holds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-gateway-holds.d.ts","sourceRoot":"","sources":["../src/memory-gateway-holds.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,WAAW,GACX,mBAAmB,GACnB,kBAAkB,GAClB,UAAU,GACV,WAAW,CAAC;AAEhB,MAAM,MAAM,sBAAsB,GAChC,sBAAsB,GAAG,iBAAiB,GAAG,sBAAsB,CAAC;AAEtE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;CAC/D;AAED,qBAAa,yBAAyB;;gBAIxB,SAAS,EAAE,MAAM,IAAI;IAIjC,OAAO,IAAI,IAAI;CAKhB;AAED,qBAAa,WAAY,YAAW,iBAAiB;;gBAWvC,KAAK,EAAE,sBAAsB;IAqBzC,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAE7B;IAED,IAAI,oBAAoB,IAAI,MAAM,CAEjC;IAED,IAAI,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAED,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC;IASzC,OAAO,IAAI,IAAI;CAKhB"}

package/dist/memory-gateway-holds.js

@@ -0,0 +1,67 @@
+export class FakeTransportSubscription {
+    #onDispose;
+    #disposed = false;
+    constructor(onDispose) {
+        this.#onDispose = onDispose;
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#onDispose();
+    }
+}
+export class PendingHold {
+    #completedPromise;
+    #publicCompletedPromise;
+    #resolveCompleted;
+    #resolveStarted;
+    #startedPromise;
+    #released = false;
+    #resourceDisposeCount = 0;
+    #started = false;
+    #transportSubscription;
+    constructor(point) {
+        let resolveCompleted;
+        this.#completedPromise = new Promise((resolve) => {
+            resolveCompleted = resolve;
+        });
+        this.#publicCompletedPromise = this.#completedPromise.then(() => undefined);
+        this.#resolveCompleted = resolveCompleted;
+        let resolveStarted;
+        this.#startedPromise = new Promise((resolve) => {
+            resolveStarted = resolve;
+        });
+        this.#resolveStarted = resolveStarted;
+        this.#transportSubscription =
+            point === "subscribe"
+                ? new FakeTransportSubscription(() => {
+                    this.#resourceDisposeCount += 1;
+                })
+                : undefined;
+    }
+    get completed() {
+        return this.#publicCompletedPromise;
+    }
+    get resourceDisposeCount() {
+        return this.#resourceDisposeCount;
+    }
+    get started() {
+        return this.#startedPromise;
+    }
+    start() {
+        if (this.#started) {
+            throw new Error("A Memory Gateway hold can only start once");
+        }
+        this.#started = true;
+        this.#resolveStarted();
+        return this.#completedPromise;
+    }
+    release() {
+        if (this.#released)
+            return;
+        this.#released = true;
+        this.#resolveCompleted({ subscription: this.#transportSubscription });
+    }
+}
+//# sourceMappingURL=memory-gateway-holds.js.map

package/dist/memory-gateway-holds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-gateway-holds.js","sourceRoot":"","sources":["../src/memory-gateway-holds.ts"],"names":[],"mappings":"AAsBA,MAAM,OAAO,yBAAyB;IAC3B,UAAU,CAAa;IAChC,SAAS,GAAG,KAAK,CAAC;IAElB,YAAY,SAAqB;QAC/B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;CACF;AAED,MAAM,OAAO,WAAW;IACb,iBAAiB,CAAmC;IACpD,uBAAuB,CAAgB;IACvC,iBAAiB,CAAgD;IACjE,eAAe,CAAa;IAC5B,eAAe,CAAgB;IACxC,SAAS,GAAG,KAAK,CAAC;IAClB,qBAAqB,GAAG,CAAC,CAAC;IAC1B,QAAQ,GAAG,KAAK,CAAC;IACR,sBAAsB,CAAwC;IAEvE,YAAY,KAA6B;QACvC,IAAI,gBACyD,CAAC;QAC9D,IAAI,CAAC,iBAAiB,GAAG,IAAI,OAAO,CAA0B,CAAC,OAAO,EAAE,EAAE;YACxE,gBAAgB,GAAG,OAAO,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC5E,IAAI,CAAC,iBAAiB,GAAG,gBAAiB,CAAC;QAC3C,IAAI,cAAwC,CAAC;QAC7C,IAAI,CAAC,eAAe,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACnD,cAAc,GAAG,OAAO,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,cAAe,CAAC;QACvC,IAAI,CAAC,sBAAsB;YACzB,KAAK,KAAK,WAAW;gBACnB,CAAC,CAAC,IAAI,yBAAyB,CAAC,GAAG,EAAE;oBACjC,IAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC;gBAClC,CAAC,CAAC;gBACJ,CAAC,CAAC,SAAS,CAAC;IAClB,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACtC,CAAC;IAED,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,KAAK;QACH,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACxE,CAAC;CACF"}

package/dist/memory-gateway.d.ts

@@ -0,0 +1,55 @@
+import { type ChatError, type AnswerInteractionInput, type AnswerInteractionSuccess, type ChatGateway, type ChatSnapshot, type ChatUpdate, type ConversationPage, type GatewayResult, type InterruptRunInput, type InterruptRunSuccess, type ListConversationsInput, type LoadConversationInput, type SendTextInput, type SendTextSuccess, type SubscribeConversationInput } from "@turingfocus/chat-protocol";
+import { type ChatContractFixtures } from "./fixtures.js";
+import { type MemoryGatewayHold, type MemoryGatewayHoldPoint, type MemoryGatewayOperation } from "./memory-gateway-holds.js";
+export type { MemoryGatewayHold, MemoryGatewayHoldPoint, MemoryGatewayOperation, } from "./memory-gateway-holds.js";
+export type MemoryGatewayCall = {
+    readonly operation: "answerInteraction";
+    readonly input: AnswerInteractionInput;
+} | {
+    readonly operation: "interrupt";
+    readonly input: InterruptRunInput;
+} | {
+    readonly operation: "listConversations";
+    readonly input: ListConversationsInput;
+} | {
+    readonly operation: "loadConversation";
+    readonly input: LoadConversationInput;
+} | {
+    readonly operation: "sendText";
+    readonly input: SendTextInput;
+} | {
+    readonly operation: "subscribe";
+    readonly input: SubscribeConversationInput;
+};
+export interface MemoryChatGatewayOptions {
+    readonly connected?: boolean | undefined;
+    readonly fixtures?: ChatContractFixtures | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export interface MemoryGatewayController {
+    readonly calls: readonly MemoryGatewayCall[];
+    readonly connected: boolean;
+    readonly disposed: boolean;
+    disconnect(error?: ChatError): number;
+    emitError(error: ChatError): number;
+    emitUpdate(update: ChatUpdate): number;
+    emitUpdateToAll(update: ChatUpdate): number;
+    failNext(operation: MemoryGatewayOperation, error: ChatError): void;
+    holdNext(point: MemoryGatewayHoldPoint): MemoryGatewayHold;
+    now(): number;
+    advanceTimeTo(timestamp: number): void;
+    reconnect(): void;
+    setConversationPage(page: ConversationPage): void;
+    setAnswerInteractionResult(result: GatewayResult<AnswerInteractionSuccess>): void;
+    setInterruptResult(result: GatewayResult<InterruptRunSuccess>): void;
+    setSendTextResult(result: GatewayResult<SendTextSuccess>): void;
+    setSnapshot(snapshot: ChatSnapshot): void;
+}
+export interface MemoryGatewayHarness {
+    readonly controller: MemoryGatewayController;
+    readonly fixtures: ChatContractFixtures;
+    readonly gateway: ChatGateway;
+}
+/** Creates one isolated, scriptable, network-free ChatGateway test harness. */
+export declare const createMemoryChatGateway: (options?: MemoryChatGatewayOptions) => MemoryGatewayHarness;
+//# sourceMappingURL=memory-gateway.d.ts.map

package/dist/memory-gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-gateway.d.ts","sourceRoot":"","sources":["../src/memory-gateway.ts"],"names":[],"mappings":"AAAA,OAAO,EAiBL,KAAK,SAAS,EACd,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,gBAAgB,EAGrB,KAAK,aAAa,EAElB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAChC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,2BAA2B,CAAC;AAGnC,YAAY,EACV,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,iBAAiB,GACzB;IACE,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;CACxC,GACD;IAAE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GACtE;IACE,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;CACxC,GACD;IACE,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;CACvC,GACD;IAAE,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GACjE;IACE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;CAC5C,CAAC;AAEN,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACrD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IACtC,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;IACpC,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC;IACvC,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,sBAAsB,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACpE,QAAQ,CAAC,KAAK,EAAE,sBAAsB,GAAG,iBAAiB,CAAC;IAC3D,GAAG,IAAI,MAAM,CAAC;IACd,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,SAAS,IAAI,IAAI,CAAC;IAClB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAClD,0BAA0B,CACxB,MAAM,EAAE,aAAa,CAAC,wBAAwB,CAAC,GAC9C,IAAI,CAAC;IACR,kBAAkB,CAAC,MAAM,EAAE,aAAa,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC;IACrE,iBAAiB,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;IAChE,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;CAC/B;AA2gBD,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,GAClC,UAAS,wBAA6B,KACrC,oBAoCF,CAAC"}

package/dist/memory-gateway.js

@@ -0,0 +1,461 @@
+import { answerInteractionInputSchema, answerInteractionResultSchema, chatErrorSchema, chatSnapshotSchema, chatUpdateSchema, conversationPageSchema, createGatewayDeadlineExceededError, interruptRunInputSchema, interruptRunResultSchema, isGatewayDeadlineExceeded, isGatewayOperationSupported, listConversationsInputSchema, loadConversationInputSchema, sendTextInputSchema, sendTextResultSchema, subscribeConversationInputSchema, } from "@turingfocus/chat-protocol";
+import { createChatContractFixtures, } from "./fixtures.js";
+import { FakeTransportSubscription, PendingHold, } from "./memory-gateway-holds.js";
+import { MemoryGatewayClock } from "./memory-gateway-clock.js";
+const unsupported = (message) => ({
+    ok: false,
+    error: chatErrorSchema.parse({
+        code: "unsupported",
+        message,
+        retryable: false,
+    }),
+});
+const notFound = (conversationId) => ({
+    ok: false,
+    error: chatErrorSchema.parse({
+        code: "not-found",
+        message: "Conversation was not found",
+        retryable: false,
+        conversationId,
+    }),
+});
+const disposedError = () => ({
+    ok: false,
+    error: chatErrorSchema.parse({
+        code: "conflict",
+        message: "Gateway has been disposed",
+        retryable: false,
+    }),
+});
+const staleInterrupt = (conversationId, requestedRunId) => ({
+    ok: false,
+    error: chatErrorSchema.parse({
+        code: "conflict",
+        message: "The requested run is no longer active",
+        retryable: false,
+        conversationId,
+        details: { requestedRunId },
+    }),
+});
+const updateConversationId = (update) => {
+    switch (update.kind) {
+        case "snapshot.replace":
+            return update.snapshot.conversation.id;
+        case "conversation.upsert":
+            return update.conversation.id;
+        case "error.reported":
+            return update.conversationId;
+        default:
+            return update.conversationId;
+    }
+};
+class MemoryChatGateway {
+    #calls = [];
+    #clock;
+    #failures = new Map();
+    #holds = new Map();
+    #observers = new Set();
+    #connected;
+    #answerInteractionResult;
+    #conversationPage;
+    #disposed = false;
+    #disposePromise;
+    #interruptResult;
+    #sendTextResult;
+    #snapshot;
+    constructor(options, fixtures) {
+        this.#connected = options.connected ?? true;
+        this.#clock = new MemoryGatewayClock(options.now?.() ?? Date.now());
+        this.#conversationPage = conversationPageSchema.parse({
+            conversations: [fixtures.conversation],
+        });
+        this.#snapshot = fixtures.initialSnapshot;
+        this.#answerInteractionResult = answerInteractionResultSchema.parse({
+            ok: true,
+            value: fixtures.answerInteractionSuccess,
+        });
+        this.#sendTextResult = sendTextResultSchema.parse({
+            ok: true,
+            value: fixtures.sendTextSuccess,
+        });
+        this.#interruptResult = interruptRunResultSchema.parse({
+            ok: true,
+            value: fixtures.interruptSuccess,
+        });
+    }
+    get calls() {
+        return Object.freeze([...this.#calls]);
+    }
+    get connected() {
+        return this.#connected;
+    }
+    get disposed() {
+        return this.#disposed;
+    }
+    #record(call) {
+        this.#calls.push(Object.freeze(call));
+    }
+    #takeHold(point) {
+        return this.#holds.get(point)?.shift();
+    }
+    async #waitForOperation(operation, input) {
+        const hold = this.#takeHold(operation);
+        if (hold === undefined)
+            return undefined;
+        const transportCompletion = hold.start();
+        const deadline = this.#clock.signal(input.deadlineAt);
+        const outcome = await Promise.race([
+            transportCompletion.then(() => "transport"),
+            deadline.promise.then(() => "deadline"),
+        ]);
+        if (outcome === "transport") {
+            deadline.cancel();
+            const completion = await transportCompletion;
+            if (this.#disposed) {
+                completion.subscription?.dispose();
+                return { failure: disposedError() };
+            }
+            return { transportSubscription: completion.subscription };
+        }
+        if (operation === "subscribe") {
+            void transportCompletion.then((completion) => {
+                completion.subscription?.dispose();
+            });
+        }
+        return {
+            failure: {
+                ok: false,
+                error: createGatewayDeadlineExceededError("conversationId" in input && typeof input.conversationId === "string"
+                    ? input.conversationId
+                    : undefined),
+            },
+        };
+    }
+    async #waitForCleanup(point, options) {
+        const hold = this.#takeHold(point);
+        if (hold === undefined)
+            return;
+        const transportCompletion = hold.start();
+        const deadline = this.#clock.signal(options.deadlineAt);
+        const outcome = await Promise.race([
+            transportCompletion.then(() => "transport"),
+            deadline.promise.then(() => "deadline"),
+        ]);
+        if (outcome === "transport")
+            deadline.cancel();
+    }
+    #guard(operation, input) {
+        if (isGatewayDeadlineExceeded(input, this.#clock.now())) {
+            return {
+                ok: false,
+                error: createGatewayDeadlineExceededError("conversationId" in input && typeof input.conversationId === "string"
+                    ? input.conversationId
+                    : undefined),
+            };
+        }
+        if (this.#disposed)
+            return disposedError();
+        const failures = this.#failures.get(operation);
+        const failure = failures?.shift();
+        if (failure !== undefined)
+            return { ok: false, error: failure };
+        if (!this.#connected) {
+            return {
+                ok: false,
+                error: chatErrorSchema.parse({
+                    code: "network",
+                    message: "Memory Gateway is disconnected",
+                    retryable: true,
+                    ...("conversationId" in input &&
+                        typeof input.conversationId === "string"
+                        ? { conversationId: input.conversationId }
+                        : {}),
+                }),
+            };
+        }
+        return undefined;
+    }
+    async listConversations(input) {
+        const parsedInput = listConversationsInputSchema.parse(input);
+        this.#record({ operation: "listConversations", input: parsedInput });
+        const guarded = this.#guard("listConversations", parsedInput);
+        if (guarded !== undefined)
+            return guarded;
+        const held = await this.#waitForOperation("listConversations", parsedInput);
+        if (held?.failure !== undefined)
+            return held.failure;
+        if (!isGatewayOperationSupported(this.#snapshot.capabilities, "listConversations")) {
+            return unsupported("Conversation listing is unavailable");
+        }
+        return { ok: true, value: this.#conversationPage };
+    }
+    async answerInteraction(input) {
+        const parsed = answerInteractionInputSchema.safeParse(input);
+        if (!parsed.success) {
+            return {
+                ok: false,
+                error: chatErrorSchema.parse({
+                    code: "validation",
+                    message: "Interaction answer input is invalid",
+                    retryable: false,
+                    ...(typeof input.conversationId === "string"
+                        ? { conversationId: input.conversationId }
+                        : {}),
+                }),
+            };
+        }
+        const parsedInput = parsed.data;
+        this.#record({ operation: "answerInteraction", input: parsedInput });
+        const guarded = this.#guard("answerInteraction", parsedInput);
+        if (guarded !== undefined)
+            return guarded;
+        const held = await this.#waitForOperation("answerInteraction", parsedInput);
+        if (held?.failure !== undefined)
+            return held.failure;
+        if (parsedInput.conversationId !== this.#snapshot.conversation.id) {
+            return notFound(parsedInput.conversationId);
+        }
+        if (!isGatewayOperationSupported(this.#snapshot.capabilities, "answerInteraction")) {
+            return unsupported("Interaction answers are unavailable");
+        }
+        if (this.#snapshot.pendingInteraction?.requestId !==
+            parsedInput.answer.requestId ||
+            this.#snapshot.pendingInteraction.revision !== parsedInput.answer.revision) {
+            return {
+                ok: false,
+                error: chatErrorSchema.parse({
+                    code: "conflict",
+                    message: "The interaction request is no longer pending",
+                    retryable: false,
+                    conversationId: parsedInput.conversationId,
+                }),
+            };
+        }
+        return this.#answerInteractionResult;
+    }
+    async loadConversation(input) {
+        const parsedInput = loadConversationInputSchema.parse(input);
+        this.#record({ operation: "loadConversation", input: parsedInput });
+        const guarded = this.#guard("loadConversation", parsedInput);
+        if (guarded !== undefined)
+            return guarded;
+        const held = await this.#waitForOperation("loadConversation", parsedInput);
+        if (held?.failure !== undefined)
+            return held.failure;
+        if (parsedInput.conversationId !== this.#snapshot.conversation.id) {
+            return notFound(parsedInput.conversationId);
+        }
+        if (parsedInput.previousCursor !== undefined &&
+            !isGatewayOperationSupported(this.#snapshot.capabilities, "loadHistory")) {
+            return unsupported("History loading is unavailable");
+        }
+        return { ok: true, value: this.#snapshot };
+    }
+    async subscribe(input, observer) {
+        const parsedInput = subscribeConversationInputSchema.parse(input);
+        this.#record({ operation: "subscribe", input: parsedInput });
+        const guarded = this.#guard("subscribe", parsedInput);
+        if (guarded !== undefined)
+            return guarded;
+        const held = await this.#waitForOperation("subscribe", parsedInput);
+        if (held?.failure !== undefined)
+            return held.failure;
+        if (parsedInput.conversationId !== this.#snapshot.conversation.id) {
+            held?.transportSubscription?.dispose();
+            return notFound(parsedInput.conversationId);
+        }
+        if (!isGatewayOperationSupported(this.#snapshot.capabilities, "subscribe")) {
+            held?.transportSubscription?.dispose();
+            return unsupported("Live updates are unavailable");
+        }
+        const registration = {
+            active: true,
+            conversationId: parsedInput.conversationId,
+            observer,
+            ...(held?.transportSubscription === undefined
+                ? {}
+                : { transportSubscription: held.transportSubscription }),
+        };
+        this.#observers.add(registration);
+        return {
+            ok: true,
+            value: Object.freeze({
+                dispose: async (options) => {
+                    registration.active = false;
+                    this.#observers.delete(registration);
+                    registration.transportSubscription?.dispose();
+                    await this.#waitForCleanup("subscription.dispose", options);
+                },
+            }),
+        };
+    }
+    async sendText(input) {
+        const parsedInput = sendTextInputSchema.parse(input);
+        this.#record({ operation: "sendText", input: parsedInput });
+        const guarded = this.#guard("sendText", parsedInput);
+        if (guarded !== undefined)
+            return guarded;
+        const held = await this.#waitForOperation("sendText", parsedInput);
+        if (held?.failure !== undefined)
+            return held.failure;
+        if (parsedInput.conversationId !== this.#snapshot.conversation.id) {
+            return notFound(parsedInput.conversationId);
+        }
+        if (!isGatewayOperationSupported(this.#snapshot.capabilities, "sendText")) {
+            return unsupported("Text sending is unavailable");
+        }
+        return this.#sendTextResult;
+    }
+    async interrupt(input) {
+        const parsedInput = interruptRunInputSchema.parse(input);
+        this.#record({ operation: "interrupt", input: parsedInput });
+        const guarded = this.#guard("interrupt", parsedInput);
+        if (guarded !== undefined)
+            return guarded;
+        const held = await this.#waitForOperation("interrupt", parsedInput);
+        if (held?.failure !== undefined)
+            return held.failure;
+        if (parsedInput.conversationId !== this.#snapshot.conversation.id) {
+            return notFound(parsedInput.conversationId);
+        }
+        if (parsedInput.runId !== undefined &&
+            parsedInput.runId !== this.#snapshot.run?.id) {
+            return staleInterrupt(parsedInput.conversationId, parsedInput.runId);
+        }
+        if (!isGatewayOperationSupported(this.#snapshot.capabilities, "interrupt", this.#snapshot.run)) {
+            return unsupported("Run interruption is unavailable");
+        }
+        return this.#interruptResult;
+    }
+    dispose(options) {
+        if (this.#disposed)
+            return this.#disposePromise;
+        this.#disposed = true;
+        for (const registration of this.#observers) {
+            registration.active = false;
+            registration.transportSubscription?.dispose();
+        }
+        this.#observers.clear();
+        this.#disposePromise = this.#waitForCleanup("gateway.dispose", options);
+        return this.#disposePromise;
+    }
+    emitUpdate(update) {
+        return this.#deliverUpdate(update, true);
+    }
+    emitUpdateToAll(update) {
+        return this.#deliverUpdate(update, false);
+    }
+    #deliverUpdate(update, filterConversation) {
+        if (this.#disposed || !this.#connected)
+            return 0;
+        const parsed = chatUpdateSchema.parse(update);
+        const conversationId = updateConversationId(parsed);
+        let delivered = 0;
+        for (const registration of this.#observers) {
+            if (registration.active &&
+                (!filterConversation ||
+                    conversationId === undefined ||
+                    conversationId === registration.conversationId)) {
+                registration.observer.next(parsed);
+                delivered += 1;
+            }
+        }
+        return delivered;
+    }
+    emitError(error) {
+        if (this.#disposed)
+            return 0;
+        const parsed = chatErrorSchema.parse(error);
+        let delivered = 0;
+        for (const registration of this.#observers) {
+            if (registration.active &&
+                (parsed.conversationId === undefined ||
+                    parsed.conversationId === registration.conversationId)) {
+                registration.observer.error?.(parsed);
+                delivered += 1;
+            }
+        }
+        return delivered;
+    }
+    disconnect(error) {
+        if (this.#disposed || !this.#connected)
+            return 0;
+        this.#connected = false;
+        return this.emitError(error);
+    }
+    reconnect() {
+        if (this.#disposed) {
+            throw new Error("Cannot reconnect a disposed Memory Gateway");
+        }
+        this.#connected = true;
+    }
+    failNext(operation, error) {
+        const failures = this.#failures.get(operation) ?? [];
+        failures.push(chatErrorSchema.parse(error));
+        this.#failures.set(operation, failures);
+    }
+    holdNext(point) {
+        const hold = new PendingHold(point);
+        const holds = this.#holds.get(point) ?? [];
+        holds.push(hold);
+        this.#holds.set(point, holds);
+        return hold;
+    }
+    now() {
+        return this.#clock.now();
+    }
+    advanceTimeTo(timestamp) {
+        this.#clock.advanceTo(timestamp);
+    }
+    setConversationPage(page) {
+        this.#conversationPage = conversationPageSchema.parse(page);
+    }
+    setAnswerInteractionResult(result) {
+        this.#answerInteractionResult = answerInteractionResultSchema.parse(result);
+    }
+    setInterruptResult(result) {
+        this.#interruptResult = interruptRunResultSchema.parse(result);
+    }
+    setSendTextResult(result) {
+        this.#sendTextResult = sendTextResultSchema.parse(result);
+    }
+    setSnapshot(snapshot) {
+        this.#snapshot = chatSnapshotSchema.parse(snapshot);
+    }
+}
+/** Creates one isolated, scriptable, network-free ChatGateway test harness. */
+export const createMemoryChatGateway = (options = {}) => {
+    const fixtures = options.fixtures ?? createChatContractFixtures();
+    const implementation = new MemoryChatGateway(options, fixtures);
+    const controller = {
+        get calls() {
+            return implementation.calls;
+        },
+        get connected() {
+            return implementation.connected;
+        },
+        get disposed() {
+            return implementation.disposed;
+        },
+        disconnect: (error = fixtures.disconnectError) => implementation.disconnect(error),
+        emitError: (error) => implementation.emitError(error),
+        emitUpdate: (update) => implementation.emitUpdate(update),
+        emitUpdateToAll: (update) => implementation.emitUpdateToAll(update),
+        failNext: (operation, error) => implementation.failNext(operation, error),
+        holdNext: (point) => implementation.holdNext(point),
+        now: () => implementation.now(),
+        advanceTimeTo: (timestamp) => implementation.advanceTimeTo(timestamp),
+        reconnect: () => implementation.reconnect(),
+        setConversationPage: (page) => implementation.setConversationPage(page),
+        setAnswerInteractionResult: (result) => implementation.setAnswerInteractionResult(result),
+        setInterruptResult: (result) => implementation.setInterruptResult(result),
+        setSendTextResult: (result) => implementation.setSendTextResult(result),
+        setSnapshot: (snapshot) => implementation.setSnapshot(snapshot),
+    };
+    return Object.freeze({
+        controller: Object.freeze(controller),
+        fixtures,
+        gateway: implementation,
+    });
+};
+//# sourceMappingURL=memory-gateway.js.map