@copilotkit/channels-core 0.5.0 → 0.5.1-canary.1785633429

package/dist/transcripts.js

@@ -1,5 +1,5 @@
 import { parseDuration } from "./state/duration.js";
-const keyFor = (userKey) => `transcript:user:${userKey}`;
+const keyFor = (userId) => `transcript:user:${userId}`;
 export class Transcripts {
     state;
     cfg;
@@ -12,39 +12,39 @@ export class Transcripts {
     }
     /**
      * Append a message to the user's transcript.
-     * No-ops silently when no `userKey` is resolved (from `opts.userKey` or `msg.userKey`).
+     * No-ops silently when no canonical application user ID is supplied.
      */
     async append(thread, msg, opts) {
-        const userKey = opts?.userKey ?? msg.userKey;
-        if (!userKey)
+        const userId = opts.userId;
+        if (!userId)
             return; // identity unresolved → no-op
         const entry = {
             role: msg.role ?? "user",
             text: msg.text,
             platform: thread.platform,
             threadId: thread.conversationKey,
-            userKey,
+            userId,
             ts: Date.now(),
         };
-        await this.state.list.append(keyFor(userKey), entry, {
+        await this.state.list.append(keyFor(userId), entry, {
             maxLen: this.cfg.maxPerUser,
             ttlMs: this.retentionMs,
         });
         if (this.retentionMs !== undefined) {
             const cutoff = Date.now() - this.retentionMs;
-            const all = await this.state.list.range(keyFor(userKey));
+            const all = await this.state.list.range(keyFor(userId));
             const expired = all.filter((e) => e.ts < cutoff).length;
             if (expired > 0) {
                 const survivors = all.length - expired;
                 if (survivors <= 0)
-                    await this.state.list.delete(keyFor(userKey));
+                    await this.state.list.delete(keyFor(userId));
                 else
-                    await this.state.list.trim(keyFor(userKey), survivors);
+                    await this.state.list.trim(keyFor(userId), survivors);
             }
         }
     }
     async list(q) {
-        let items = await this.state.list.range(keyFor(q.userKey));
+        let items = await this.state.list.range(keyFor(q.userId));
         if (this.retentionMs !== undefined) {
             const cutoff = Date.now() - this.retentionMs;
             items = items.filter((e) => e.ts >= cutoff);
@@ -60,8 +60,8 @@ export class Transcripts {
         return items; // oldest-first
     }
     async delete(q) {
-        const n = (await this.state.list.range(keyFor(q.userKey))).length;
-        await this.state.list.delete(keyFor(q.userKey));
+        const n = (await this.state.list.range(keyFor(q.userId))).length;
+        await this.state.list.delete(keyFor(q.userId));
         return { deleted: n };
     }
 }

package/dist/transcripts.test.js

@@ -8,45 +8,44 @@ const thread = {
 describe("Transcripts", () => {
     it("appends and lists oldest-first, filters compose", async () => {
         const t = new Transcripts(new MemoryStore(), { maxPerUser: 100 });
-        await t.append(thread, { role: "user", text: "hi" }, { userKey: "u@x.com" });
-        await t.append(thread, { role: "assistant", text: "hello" }, { userKey: "u@x.com" });
-        const all = await t.list({ userKey: "u@x.com" });
+        await t.append(thread, { role: "user", text: "hi" }, { userId: "u@x.com" });
+        await t.append(thread, { role: "assistant", text: "hello" }, { userId: "u@x.com" });
+        const all = await t.list({ userId: "u@x.com" });
         expect(all.map((e) => e.role)).toEqual(["user", "assistant"]);
-        expect(await t.list({ userKey: "u@x.com", roles: ["user"] })).toHaveLength(1);
+        expect(await t.list({ userId: "u@x.com", roles: ["user"] })).toHaveLength(1);
     });
     it("delete wipes and reports count", async () => {
         const t = new Transcripts(new MemoryStore());
-        await t.append(thread, { role: "user", text: "x" }, { userKey: "k" });
-        expect(await t.delete({ userKey: "k" })).toEqual({ deleted: 1 });
-        expect(await t.list({ userKey: "k" })).toEqual([]);
+        await t.append(thread, { role: "user", text: "x" }, { userId: "k" });
+        expect(await t.delete({ userId: "k" })).toEqual({ deleted: 1 });
+        expect(await t.list({ userId: "k" })).toEqual([]);
     });
     it("TTL expiry: entries not visible after retention window", async () => {
         const t = new Transcripts(new MemoryStore(), { retention: "30ms" });
-        await t.append(thread, { role: "user", text: "hi" }, { userKey: "u" });
+        await t.append(thread, { role: "user", text: "hi" }, { userId: "u" });
         await new Promise((r) => setTimeout(r, 60));
-        expect(await t.list({ userKey: "u" })).toEqual([]);
+        expect(await t.list({ userId: "u" })).toEqual([]);
     });
     it("maxPerUser: only newest N entries are kept", async () => {
         const t = new Transcripts(new MemoryStore(), { maxPerUser: 2 });
-        await t.append(thread, { role: "user", text: "1" }, { userKey: "u" });
-        await t.append(thread, { role: "user", text: "2" }, { userKey: "u" });
-        await t.append(thread, { role: "user", text: "3" }, { userKey: "u" });
-        const entries = await t.list({ userKey: "u" });
+        await t.append(thread, { role: "user", text: "1" }, { userId: "u" });
+        await t.append(thread, { role: "user", text: "2" }, { userId: "u" });
+        await t.append(thread, { role: "user", text: "3" }, { userId: "u" });
+        const entries = await t.list({ userId: "u" });
         expect(entries).toHaveLength(2);
         expect(entries.map((e) => e.text)).toEqual(["2", "3"]);
     });
-    it("no userKey resolved: no-op, list returns empty for any key", async () => {
+    it("no userId resolved: no-op, list returns empty for any key", async () => {
         const t = new Transcripts(new MemoryStore());
-        // neither opts.userKey nor msg.userKey is set
-        await t.append(thread, { role: "user", text: "ghost" });
-        expect(await t.list({ userKey: "anyone" })).toEqual([]);
+        await t.append(thread, { role: "user", text: "ghost" }, { userId: null });
+        expect(await t.list({ userId: "anyone" })).toEqual([]);
     });
     it("list with limit: returns only the last N entries", async () => {
         const t = new Transcripts(new MemoryStore());
-        await t.append(thread, { role: "user", text: "a" }, { userKey: "u" });
-        await t.append(thread, { role: "user", text: "b" }, { userKey: "u" });
-        await t.append(thread, { role: "user", text: "c" }, { userKey: "u" });
-        const last = await t.list({ userKey: "u", limit: 1 });
+        await t.append(thread, { role: "user", text: "a" }, { userId: "u" });
+        await t.append(thread, { role: "user", text: "b" }, { userId: "u" });
+        await t.append(thread, { role: "user", text: "c" }, { userId: "u" });
+        const last = await t.list({ userId: "u", limit: 1 });
         expect(last).toHaveLength(1);
         expect(last[0].text).toBe("c");
     });
@@ -60,9 +59,9 @@ describe("Transcripts retention", () => {
         const t = new Transcripts(store, { retention: "1h" });
         vi.useFakeTimers();
         try {
-            await t.append(thread, { role: "user", text: "old" }, { userKey: "u" });
+            await t.append(thread, { role: "user", text: "old" }, { userId: "u" });
             vi.advanceTimersByTime(2 * 60 * 60 * 1000); // advance 2h
-            expect(await t.list({ userKey: "u" })).toEqual([]);
+            expect(await t.list({ userId: "u" })).toEqual([]);
         }
         finally {
             vi.useRealTimers();
@@ -78,11 +77,11 @@ describe("Transcripts retention", () => {
         const t = new Transcripts(store, { retention: "1h" });
         vi.useFakeTimers();
         try {
-            await t.append(thread, { role: "user", text: "A" }, { userKey: "u" });
+            await t.append(thread, { role: "user", text: "A" }, { userId: "u" });
             vi.advanceTimersByTime(50 * 60 * 1000); // +50m: A still within window, key TTL refreshed to +110m
-            await t.append(thread, { role: "user", text: "B" }, { userKey: "u" });
+            await t.append(thread, { role: "user", text: "B" }, { userId: "u" });
             vi.advanceTimersByTime(50 * 60 * 1000); // +100m: key still live (expires +110m), but A is now 100m old
-            await t.append(thread, { role: "user", text: "C" }, { userKey: "u" });
+            await t.append(thread, { role: "user", text: "C" }, { userId: "u" });
             const raw = await store.list.range("transcript:user:u");
             expect(raw.map((e) => e.text)).toEqual(["B", "C"]); // A pruned by age, not whole-key expiry
         }
@@ -95,10 +94,10 @@ describe("Transcripts retention", () => {
         const t = new Transcripts(store, { retention: "1h" });
         vi.useFakeTimers();
         try {
-            await t.append(thread, { role: "user", text: "A" }, { userKey: "u" });
+            await t.append(thread, { role: "user", text: "A" }, { userId: "u" });
             vi.advanceTimersByTime(30 * 60 * 1000); // advance 30m — A still within 1h
-            await t.append(thread, { role: "user", text: "B" }, { userKey: "u" });
-            const entries = await t.list({ userKey: "u" });
+            await t.append(thread, { role: "user", text: "B" }, { userId: "u" });
+            const entries = await t.list({ userId: "u" });
             expect(entries).toHaveLength(2);
         }
         finally {

package/dist/welcome.test.d.ts

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

package/dist/welcome.test.d.ts.map

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

package/dist/welcome.test.js

@@ -0,0 +1,53 @@
+import { expect, test, vi } from "vitest";
+import { createChannel } from "./create-channel.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+test("routes a welcome lifecycle event without synthesizing a message turn", async () => {
+    const adapter = new FakeAdapter();
+    const onWelcome = vi.fn();
+    const onMessage = vi.fn();
+    const channel = createChannel({
+        identifyUser: () => ({ id: "app-user-1", name: "Ada App" }),
+        adapters: [adapter],
+    });
+    channel.onWelcome(onWelcome);
+    channel.onMessage(onMessage);
+    await channel.ɵruntime.start();
+    await adapter.emitWelcome({
+        conversationKey: "teams:tenant:conversation",
+        replyTarget: { conversationId: "conversation" },
+        platform: "teams",
+        actor: { id: "provider-user-1", kind: "human", name: "Ada Provider" },
+    });
+    expect(onWelcome).toHaveBeenCalledOnce();
+    expect(onWelcome).toHaveBeenCalledWith(expect.objectContaining({
+        user: { id: "app-user-1", name: "Ada App" },
+        actor: {
+            id: "provider-user-1",
+            kind: "human",
+            name: "Ada Provider",
+        },
+        platform: "teams",
+    }));
+    expect(onMessage).not.toHaveBeenCalled();
+});
+test("exposes submitted input values separately from the action envelope", async () => {
+    const adapter = new FakeAdapter();
+    const handler = vi.fn();
+    const channel = createChannel({
+        identifyUser: "platform",
+        adapters: [adapter],
+    });
+    channel.onInteraction("approve", handler);
+    await channel.ɵruntime.start();
+    adapter.emitInteraction({
+        id: "approve",
+        value: { decision: "yes" },
+        values: { reason: "ready", priority: "high" },
+        platform: "teams",
+    });
+    await vi.waitFor(() => expect(handler).toHaveBeenCalledOnce());
+    expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+        action: { id: "approve", value: { decision: "yes" } },
+        values: { reason: "ready", priority: "high" },
+    }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/channels-core",
-  "version": "0.5.0",
+  "version": "0.5.1-canary.1785633429",
   "description": "Platform-agnostic JSX channel engine for CopilotKit (createChannel, Thread, PlatformAdapter, ActionStore).",
   "license": "MIT",
   "repository": {
@@ -50,10 +50,10 @@
   "dependencies": {
     "@ag-ui/client": "0.0.57",
     "@ag-ui/core": "0.0.57",
-    "zod-to-json-schema": "^3.24.1",
-    "@copilotkit/core": "^1.64.1",
-    "@copilotkit/shared": "^1.64.1",
-    "@copilotkit/channels-ui": "~0.5.0"
+    "@copilotkit/channels-ui": "0.5.1-canary.1785633429",
+    "@copilotkit/core": "1.64.3-canary.1785633429",
+    "@copilotkit/shared": "1.64.3-canary.1785633429",
+    "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",