@copilotkit/channels-core 0.4.1-canary.1785375021 → 0.4.1-canary.narrowinstall1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/channels-core",
-  "version": "0.4.1-canary.1785375021",
+  "version": "0.4.1-canary.narrowinstall1",
   "description": "Platform-agnostic JSX channel engine for CopilotKit (createChannel, Thread, PlatformAdapter, ActionStore).",
   "license": "MIT",
   "repository": {
@@ -51,9 +51,9 @@
     "@ag-ui/client": "0.0.57",
     "@ag-ui/core": "0.0.57",
     "zod-to-json-schema": "^3.24.1",
-    "@copilotkit/channels-ui": "~0.4.1-canary.1785375021",
-    "@copilotkit/core": "^1.64.2-canary.1785375021",
-    "@copilotkit/shared": "^1.64.2-canary.1785375021"
+    "@copilotkit/channels-ui": "~0.4.1-canary.narrowinstall1",
+    "@copilotkit/core": "^1.64.2-canary.narrowinstall1",
+    "@copilotkit/shared": "^1.64.2-canary.narrowinstall1"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",

package/dist/canonical-run-loop.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=canonical-run-loop.test.d.ts.map

package/dist/canonical-run-loop.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonical-run-loop.test.d.ts","sourceRoot":"","sources":["../src/canonical-run-loop.test.ts"],"names":[],"mappings":""}

package/dist/canonical-run-loop.test.js

@@ -1,393 +0,0 @@
-import { EventType } from "@ag-ui/client";
-import { expect, test } from "vitest";
-import { z } from "zod";
-import { runAgentLoop } from "./run-loop.js";
-import { FakeAgent } from "./testing/fake-agent.js";
-const canonicalRun = {
-    threadId: "canonical-thread",
-    runId: "canonical-run",
-};
-function lifecycleBatch(runId, middle) {
-    return [
-        {
-            type: EventType.RUN_STARTED,
-            threadId: "inner-thread",
-            runId,
-        },
-        ...middle,
-        {
-            type: EventType.RUN_FINISHED,
-            threadId: "inner-thread",
-            runId,
-        },
-    ];
-}
-function textEvent(messageId, text) {
-    return {
-        type: EventType.TEXT_MESSAGE_CONTENT,
-        messageId,
-        delta: text,
-    };
-}
-async function emitBatch(subscriber, agent, runId, middle) {
-    const input = {
-        threadId: agent.threadId,
-        runId,
-        messages: agent.messages,
-        state: agent.state,
-        tools: [],
-        context: [],
-        forwardedProps: {},
-    };
-    const params = {
-        messages: agent.messages,
-        state: agent.state,
-        agent,
-        input,
-    };
-    for (const event of lifecycleBatch(runId, middle)) {
-        await subscriber.onEvent?.({ ...params, event });
-        switch (event.type) {
-            case EventType.RUN_STARTED:
-                await subscriber.onRunStartedEvent?.({ ...params, event });
-                break;
-            case EventType.RUN_FINISHED:
-                await subscriber.onRunFinishedEvent?.({
-                    ...params,
-                    event,
-                    outcome: "success",
-                });
-                break;
-            case EventType.RUN_ERROR:
-                await subscriber.onRunErrorEvent?.({ ...params, event });
-                break;
-            case EventType.TEXT_MESSAGE_CONTENT:
-                await subscriber.onTextMessageContentEvent?.({
-                    ...params,
-                    event,
-                    textMessageBuffer: event.delta,
-                });
-                break;
-            case EventType.TOOL_CALL_END:
-                await subscriber.onToolCallEndEvent?.({
-                    ...params,
-                    event,
-                    toolCallName: "echo",
-                    toolCallArgs: { value: "ok" },
-                });
-                break;
-        }
-    }
-}
-function setupRenderer(options = {}) {
-    const renderedEvents = [];
-    const renderedFinishMetadata = [];
-    const toolCalls = [];
-    const subscriber = {
-        onRunStartedEvent: ({ event }) => {
-            renderedEvents.push(event);
-        },
-        onRunFinishedEvent: ({ event }) => {
-            renderedEvents.push(event);
-            renderedFinishMetadata.push(event.metadata);
-            if (options.failOnFinish) {
-                throw new Error("renderer finalization failed");
-            }
-        },
-        onRunErrorEvent: ({ event }) => {
-            renderedEvents.push(event);
-        },
-        onTextMessageContentEvent: ({ event }) => {
-            renderedEvents.push(event);
-            if (options.failOnContent) {
-                throw new Error("renderer failed");
-            }
-        },
-        onToolCallEndEvent: ({ event, toolCallName, toolCallArgs }) => {
-            toolCalls.push({
-                toolCallId: event.toolCallId,
-                toolCallName,
-                toolCallArgs,
-            });
-        },
-    };
-    return {
-        renderer: {
-            subscriber,
-            markInterrupted: async () => { },
-            getCapturedToolCalls: () => toolCalls,
-            getPendingInterrupt: () => undefined,
-            clearPendingInterrupt: () => { },
-        },
-        renderedEvents,
-        renderedFinishMetadata,
-    };
-}
-test("managed runAgentLoop emits one canonical lifecycle and shares stamped events with ingestion and rendering", async () => {
-    let agent;
-    agent = new FakeAgent([
-        (subscriber) => emitBatch(subscriber, agent, "inner-run-1", [
-            textEvent("message-1", "first"),
-            {
-                type: EventType.TOOL_CALL_END,
-                toolCallId: "tool-call-1",
-            },
-        ]),
-        (subscriber) => emitBatch(subscriber, agent, "inner-run-2", [
-            textEvent("message-2", "second"),
-        ]),
-    ]);
-    const { renderer, renderedEvents } = setupRenderer();
-    const ingestedEvents = [];
-    const echo = {
-        name: "echo",
-        description: "Return the value.",
-        parameters: z.object({ value: z.string() }),
-        handler: ({ value }) => value,
-    };
-    const result = await runAgentLoop({
-        agent,
-        renderer,
-        tools: new Map([["echo", echo]]),
-        toolDescriptors: [],
-        context: [],
-        makeToolCtx: () => {
-            throw new Error("tool context is not used by this test");
-        },
-        subscriber: {
-            onEvent: ({ event }) => {
-                ingestedEvents.push(event);
-            },
-        },
-        canonicalRun,
-    });
-    const lifecycleTypes = ingestedEvents
-        .filter(({ type }) => type === EventType.RUN_STARTED ||
-        type === EventType.RUN_FINISHED ||
-        type === EventType.RUN_ERROR)
-        .map(({ type }) => type);
-    const ingestedContent = ingestedEvents.filter(({ type }) => type === EventType.TEXT_MESSAGE_CONTENT);
-    const renderedContent = renderedEvents.filter(({ type }) => type === EventType.TEXT_MESSAGE_CONTENT);
-    expect(result).toEqual({ iterations: 2, interrupted: false });
-    expect(lifecycleTypes).toEqual([
-        EventType.RUN_STARTED,
-        EventType.RUN_FINISHED,
-    ]);
-    expect(renderedEvents
-        .filter(({ type }) => type === EventType.RUN_STARTED ||
-        type === EventType.RUN_FINISHED ||
-        type === EventType.RUN_ERROR)
-        .map(({ type }) => type)).toEqual([EventType.RUN_STARTED, EventType.RUN_FINISHED]);
-    expect(ingestedContent).toHaveLength(2);
-    expect(renderedContent).toHaveLength(2);
-    expect(renderedContent[0]).toBe(ingestedContent[0]);
-    expect(renderedContent[1]).toBe(ingestedContent[1]);
-    expect(ingestedEvents).toEqual(expect.arrayContaining([
-        expect.objectContaining(canonicalRun),
-        expect.objectContaining({
-            ...canonicalRun,
-            type: EventType.TEXT_MESSAGE_CONTENT,
-            messageId: "message-1",
-        }),
-        expect.objectContaining({
-            ...canonicalRun,
-            type: EventType.TEXT_MESSAGE_CONTENT,
-            messageId: "message-2",
-        }),
-    ]));
-});
-test("managed renderer failure is deferred until canonical RUN_FINISHED reaches ingestion", async () => {
-    let agent;
-    agent = new FakeAgent([
-        (subscriber) => emitBatch(subscriber, agent, "inner-run", [
-            textEvent("message-1", "hello"),
-        ]),
-    ]);
-    const { renderer } = setupRenderer({ failOnContent: true });
-    const ingestedByTypedCallback = [];
-    const ingestedLifecycle = [];
-    const result = await runAgentLoop({
-        agent,
-        renderer,
-        tools: new Map(),
-        toolDescriptors: [],
-        context: [],
-        makeToolCtx: () => {
-            throw new Error("no tool calls are expected");
-        },
-        subscriber: {
-            onEvent: ({ event }) => {
-                if (event.type === EventType.RUN_STARTED ||
-                    event.type === EventType.RUN_FINISHED ||
-                    event.type === EventType.RUN_ERROR) {
-                    ingestedLifecycle.push(event);
-                }
-            },
-            onTextMessageContentEvent: ({ event }) => {
-                ingestedByTypedCallback.push(event);
-            },
-        },
-        canonicalRun,
-    });
-    expect(result).toMatchObject({
-        iterations: 1,
-        interrupted: false,
-        deliveryError: { message: "renderer failed" },
-    });
-    expect(ingestedByTypedCallback).toEqual([
-        expect.objectContaining({
-            ...canonicalRun,
-            type: EventType.TEXT_MESSAGE_CONTENT,
-            messageId: "message-1",
-        }),
-    ]);
-    expect(ingestedLifecycle.map(({ type }) => type)).toEqual([
-        EventType.RUN_STARTED,
-        EventType.RUN_FINISHED,
-    ]);
-});
-test("managed renderer failure freezes later rendering while canonical ingestion finishes", async () => {
-    let agent;
-    agent = new FakeAgent([
-        (subscriber) => emitBatch(subscriber, agent, "inner-run", [
-            textEvent("message-1", "first"),
-            textEvent("message-2", "second"),
-        ]),
-    ]);
-    const { renderer, renderedEvents } = setupRenderer({
-        failOnContent: true,
-    });
-    const ingestedEvents = [];
-    const result = await runAgentLoop({
-        agent,
-        renderer,
-        tools: new Map(),
-        toolDescriptors: [],
-        context: [],
-        makeToolCtx: () => {
-            throw new Error("no tool calls are expected");
-        },
-        subscriber: {
-            onEvent: ({ event }) => {
-                ingestedEvents.push(event);
-            },
-        },
-        canonicalRun,
-    });
-    expect(result).toMatchObject({
-        deliveryError: { message: "renderer failed" },
-    });
-    expect(renderedEvents.map(({ type, ...event }) => ({
-        type,
-        messageId: "messageId" in event ? event.messageId : undefined,
-    }))).toEqual([
-        { type: EventType.RUN_STARTED, messageId: undefined },
-        { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "message-1" },
-    ]);
-    expect(ingestedEvents
-        .filter(({ type }) => type === EventType.TEXT_MESSAGE_CONTENT ||
-        type === EventType.RUN_FINISHED)
-        .map(({ type, ...event }) => ({
-        type,
-        messageId: "messageId" in event ? event.messageId : undefined,
-    }))).toEqual([
-        { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "message-1" },
-        { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "message-2" },
-        { type: EventType.RUN_FINISHED, messageId: undefined },
-    ]);
-});
-test("inner RUN_ERROR becomes one canonical outer RUN_ERROR", async () => {
-    let agent;
-    agent = new FakeAgent([
-        (subscriber) => emitBatch(subscriber, agent, "inner-run", [
-            {
-                type: EventType.RUN_ERROR,
-                message: "inner agent failed",
-                code: "INNER_FAILED",
-            },
-        ]),
-    ]);
-    const { renderer, renderedEvents } = setupRenderer();
-    const ingestedEvents = [];
-    await expect(runAgentLoop({
-        agent,
-        renderer,
-        tools: new Map(),
-        toolDescriptors: [],
-        context: [],
-        makeToolCtx: () => {
-            throw new Error("no tool calls are expected");
-        },
-        subscriber: {
-            onEvent: ({ event }) => {
-                ingestedEvents.push(event);
-            },
-        },
-        canonicalRun,
-    })).rejects.toMatchObject({
-        message: "inner agent failed",
-        code: "INNER_FAILED",
-    });
-    const expectedLifecycle = [
-        expect.objectContaining({
-            ...canonicalRun,
-            type: EventType.RUN_STARTED,
-        }),
-        expect.objectContaining({
-            ...canonicalRun,
-            type: EventType.RUN_ERROR,
-            message: "inner agent failed",
-            code: "INNER_FAILED",
-        }),
-    ];
-    expect(ingestedEvents.filter(({ type }) => type === EventType.RUN_STARTED ||
-        type === EventType.RUN_FINISHED ||
-        type === EventType.RUN_ERROR)).toEqual(expectedLifecycle);
-    expect(renderedEvents.filter(({ type }) => type === EventType.RUN_STARTED ||
-        type === EventType.RUN_FINISHED ||
-        type === EventType.RUN_ERROR)).toEqual(expectedLifecycle);
-});
-test("managed renderer finalization sees runner metadata without replacing canonical RUN_FINISHED", async () => {
-    let agent;
-    agent = new FakeAgent([
-        (subscriber) => emitBatch(subscriber, agent, "inner-run", []),
-    ]);
-    const { renderer, renderedFinishMetadata } = setupRenderer({
-        failOnFinish: true,
-    });
-    const ingestedEvents = [];
-    const runnerMetadata = {
-        cpki_event_id: "runner-event-finished",
-        cpki_event_seq: 1,
-    };
-    const result = await runAgentLoop({
-        agent,
-        renderer,
-        tools: new Map(),
-        toolDescriptors: [],
-        context: [],
-        makeToolCtx: () => {
-            throw new Error("no tool calls are expected");
-        },
-        subscriber: {
-            onEvent: ({ event }) => {
-                if (event.type === EventType.RUN_FINISHED) {
-                    event.metadata = runnerMetadata;
-                }
-                ingestedEvents.push(event);
-            },
-        },
-        canonicalRun,
-    });
-    expect(result).toMatchObject({
-        iterations: 1,
-        interrupted: false,
-        deliveryError: { message: "renderer finalization failed" },
-    });
-    expect(ingestedEvents
-        .filter(({ type }) => type === EventType.RUN_STARTED ||
-        type === EventType.RUN_FINISHED ||
-        type === EventType.RUN_ERROR)
-        .map(({ type }) => type)).toEqual([EventType.RUN_STARTED, EventType.RUN_FINISHED]);
-    expect(renderedFinishMetadata).toEqual([runnerMetadata]);
-});

package/dist/managed-v1-await-choice-guard.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=managed-v1-await-choice-guard.test.d.ts.map

package/dist/managed-v1-await-choice-guard.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"managed-v1-await-choice-guard.test.d.ts","sourceRoot":"","sources":["../src/managed-v1-await-choice-guard.test.ts"],"names":[],"mappings":""}

package/dist/managed-v1-await-choice-guard.test.js

@@ -1,52 +0,0 @@
-import { expect, test } from "vitest";
-import { Section } from "@copilotkit/channels-ui";
-import { createChannel } from "./create-channel.js";
-import { FakeAdapter } from "./testing/fake-adapter.js";
-class NonBlockingManagedAdapter extends FakeAdapter {
-    __intelligenceChannel = true;
-    constructor() {
-        super({ platform: "intelligence" });
-        this.capabilities.supportsBlockingChoice = false;
-    }
-}
-async function setupNonBlockingManagedThread() {
-    const adapter = new NonBlockingManagedAdapter();
-    const channel = createChannel({ adapters: [adapter] });
-    let thread;
-    channel.onThreadStarted(({ thread: activeThread }) => {
-        thread = activeThread;
-    });
-    await channel.ɵruntime.start();
-    await adapter.emitThreadStarted();
-    if (!thread) {
-        throw new Error("Managed thread was not created");
-    }
-    return {
-        adapter,
-        thread,
-        teardown: () => channel.ɵruntime.stop(),
-    };
-}
-test("managed awaitChoice fails fast before registering or posting a picker", async () => {
-    const { adapter, thread, teardown } = await setupNonBlockingManagedThread();
-    try {
-        const outcome = await Promise.race([
-            thread.awaitChoice(Section({ children: "Choose" })).then(() => ({ status: "resolved" }), (error) => ({ status: "rejected", error })),
-            new Promise((resolve) => {
-                setTimeout(() => resolve({ status: "pending" }), 0);
-            }),
-        ]);
-        expect(outcome).toMatchObject({
-            status: "rejected",
-            error: {
-                name: "ChannelAwaitChoiceNotSupportedError",
-                code: "channel_await_choice_not_supported",
-                message: expect.stringContaining("Thread.resume()"),
-            },
-        });
-        expect(adapter.posted).toHaveLength(0);
-    }
-    finally {
-        await teardown();
-    }
-});

package/dist/source-platform.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=source-platform.test.d.ts.map

package/dist/source-platform.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source-platform.test.d.ts","sourceRoot":"","sources":["../src/source-platform.test.ts"],"names":[],"mappings":""}

package/dist/source-platform.test.js

@@ -1,149 +0,0 @@
-import { z } from "zod";
-import { expect, test, vi } from "vitest";
-import { createChannel } from "./create-channel.js";
-import { MemoryStore } from "./state/memory-store.js";
-import { FakeAdapter } from "./testing/fake-adapter.js";
-import { FakeAgent } from "./testing/fake-agent.js";
-test("an ingress source platform reaches the text thread and its tool context", async () => {
-    const observed = {};
-    const adapter = new FakeAdapter({ platform: "intelligence" });
-    const agent = new FakeAgent([
-        (subscriber) => {
-            subscriber.onToolCallEndEvent?.({
-                event: { toolCallId: "tool-call-1" },
-                toolCallName: "capture_platform",
-                toolCallArgs: {},
-            });
-            subscriber.onRunFinishedEvent?.({ event: {} });
-        },
-        (subscriber) => {
-            subscriber.onRunFinishedEvent?.({ event: {} });
-        },
-    ]);
-    const channel = createChannel({
-        adapters: [adapter],
-        agent: () => agent,
-        tools: [
-            {
-                name: "capture_platform",
-                description: "Capture the handler platform",
-                parameters: z.object({}),
-                handler: (_args, ctx) => {
-                    observed.toolPlatform = ctx.platform;
-                    observed.toolThreadPlatform = ctx.thread.platform;
-                    return "captured";
-                },
-            },
-        ],
-    });
-    channel.onMessage(async ({ message, thread }) => {
-        observed.messagePlatform = message.platform;
-        observed.threadPlatform = thread.platform;
-        await thread.runAgent();
-    });
-    await channel.ɵruntime.start();
-    await adapter.getSink().onTurn({
-        conversationKey: "conversation-1",
-        replyTarget: {},
-        userText: "hello",
-        platform: "slack",
-    });
-    expect(observed).toEqual({
-        messagePlatform: "slack",
-        threadPlatform: "slack",
-        toolPlatform: "slack",
-        toolThreadPlatform: "slack",
-    });
-});
-test("an ingress source platform scopes identity resolution and event dedupe", async () => {
-    const state = new MemoryStore();
-    const dedupeSeen = vi.spyOn(state.dedup, "seen").mockResolvedValue(false);
-    const identity = vi.fn(() => "person-1");
-    const adapter = new FakeAdapter({ platform: "intelligence" });
-    const channel = createChannel({
-        adapters: [adapter],
-        store: {
-            adapter: state,
-            identity,
-            transcripts: {},
-        },
-    });
-    let userKey;
-    channel.onMessage(({ message }) => {
-        userKey = message.userKey;
-    });
-    await channel.ɵruntime.start();
-    await adapter.getSink().onTurn({
-        conversationKey: "conversation-1",
-        replyTarget: {},
-        userText: "hello",
-        platform: "teams",
-        eventId: "event-1",
-        user: { id: "user-1" },
-    });
-    expect(dedupeSeen).toHaveBeenCalledWith("evt:teams:event-1", 300_000);
-    expect(identity).toHaveBeenCalledWith(expect.objectContaining({
-        adapter: "teams",
-        message: expect.objectContaining({ platform: "teams" }),
-    }));
-    expect(userKey).toBe("person-1");
-});
-test("non-text ingress keeps source platform in handler contexts and dedupe keys", async () => {
-    const state = new MemoryStore();
-    const dedupeSeen = vi.spyOn(state.dedup, "seen").mockResolvedValue(false);
-    const adapter = new FakeAdapter({ platform: "intelligence" });
-    const observed = {};
-    const channel = createChannel({
-        adapters: [adapter],
-        store: { adapter: state },
-    });
-    channel.onCommand("triage", ({ platform, thread }) => {
-        observed.commandPlatform = platform;
-        observed.commandThreadPlatform = thread.platform;
-    });
-    channel.onInteraction("approve", ({ message, platform, thread }) => {
-        observed.interactionMessagePlatform = message.platform;
-        observed.interactionPlatform = platform;
-        observed.interactionThreadPlatform = thread.platform;
-    });
-    channel.onReaction(({ thread }) => {
-        observed.reactionThreadPlatform = thread.platform;
-    });
-    await channel.ɵruntime.start();
-    const sink = adapter.getSink();
-    await sink.onCommand({
-        command: "triage",
-        conversationKey: "command-conversation",
-        eventId: "command-event",
-        platform: "teams",
-        replyTarget: {},
-        text: "",
-    });
-    const interaction = {
-        id: "approve",
-        conversationKey: "interaction-conversation",
-        eventId: "interaction-event",
-        platform: "slack",
-        replyTarget: {},
-    };
-    await sink.onInteraction(interaction);
-    await sink.onReaction({
-        added: true,
-        conversationKey: "reaction-conversation",
-        messageId: "message-1",
-        platform: "teams",
-        raw: {},
-        rawEmoji: "👍",
-        replyTarget: {},
-    });
-    expect(observed).toEqual({
-        commandPlatform: "teams",
-        commandThreadPlatform: "teams",
-        interactionMessagePlatform: "slack",
-        interactionPlatform: "slack",
-        interactionThreadPlatform: "slack",
-        reactionThreadPlatform: "teams",
-    });
-    expect(dedupeSeen).toHaveBeenCalledWith("evt:teams:command-event", 300_000);
-    expect(dedupeSeen).toHaveBeenCalledWith("evt:slack:interaction-event", 300_000);
-});

package/dist/thread-promise-contract.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=thread-promise-contract.test.d.ts.map

package/dist/thread-promise-contract.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"thread-promise-contract.test.d.ts","sourceRoot":"","sources":["../src/thread-promise-contract.test.ts"],"names":[],"mappings":""}

package/dist/thread-promise-contract.test.js

@@ -1,37 +0,0 @@
-import { expect, test } from "vitest";
-import { ActionRegistry } from "./action-registry.js";
-import { InMemoryActionStore } from "./action-store.js";
-import { MemoryStore } from "./state/memory-store.js";
-import { FakeAdapter } from "./testing/fake-adapter.js";
-import { Thread } from "./thread.js";
-function setupThreadWithSyncDeleteFailure(failure) {
-    const adapter = new FakeAdapter();
-    adapter.delete = () => {
-        throw failure;
-    };
-    const deps = {
-        adapter,
-        replyTarget: {},
-        conversationKey: "thread-promise-contract",
-        registry: new ActionRegistry({ store: new InMemoryActionStore() }),
-        agentFactory: (threadId) => {
-            throw new Error(`agentFactory not needed in this test: ${threadId}`);
-        },
-        tools: new Map(),
-        toolDescriptors: [],
-        context: [],
-        registerWaiter: () => undefined,
-        interruptHandlers: new Map(),
-        state: new MemoryStore(),
-    };
-    return new Thread(deps);
-}
-test("a synchronous non-managed adapter failure returns a rejected Promise", async () => {
-    const failure = new Error("adapter delete failed synchronously");
-    const thread = setupThreadWithSyncDeleteFailure(failure);
-    let deletion;
-    expect(() => {
-        deletion = thread.delete({ id: "message-1" });
-    }).not.toThrow();
-    await expect(deletion).rejects.toBe(failure);
-});