@copilotkit/channels 0.1.0

package/dist/state/kv-action-store.js

@@ -0,0 +1,9 @@
+const key = (id) => `action:${id}`;
+/** Back the legacy ActionStore shape with state.kv. Durable iff `state` is durable. */
+export function kvActionStore(state, opts) {
+    return {
+        put: (id, snap, ttlMs) => state.kv.set(key(id), snap, ttlMs ?? opts?.defaultTtlMs),
+        get: (id) => state.kv.get(key(id)),
+        delete: (id) => state.kv.delete(key(id)),
+    };
+}

package/dist/state/kv-action-store.test.d.ts

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

package/dist/state/kv-action-store.test.d.ts.map

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

package/dist/state/kv-action-store.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { MemoryStore } from "./memory-store.js";
+import { kvActionStore } from "./kv-action-store.js";
+describe("kvActionStore", () => {
+    it("put/get/delete a snapshot via state.kv", async () => {
+        const state = new MemoryStore();
+        const store = kvActionStore(state);
+        const snap = {
+            component: "Card",
+            props: { x: 1 },
+            path: [0, "onClick"],
+            conversationKey: "c",
+        };
+        await store.put("ck:abc", snap);
+        expect(await store.get("ck:abc")).toEqual(snap);
+        // It is actually stored under the action: namespace in kv.
+        expect(await state.kv.get("action:ck:abc")).toEqual(snap);
+        await store.delete("ck:abc");
+        expect(await store.get("ck:abc")).toBeUndefined();
+    });
+});

package/dist/state/memory-store.d.ts

@@ -0,0 +1,41 @@
+import type { StateStore } from "./state-store.js";
+export declare class MemoryStore implements StateStore {
+    private kvMap;
+    private lists;
+    private locks;
+    private queues;
+    kv: {
+        get: <T>(key: string) => Promise<T | undefined>;
+        set: <T>(key: string, value: T, ttlMs?: number) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+    };
+    list: {
+        append: <T>(key: string, value: T, opts?: {
+            maxLen?: number;
+            ttlMs?: number;
+        }) => Promise<number>;
+        range: <T>(key: string, start?: number, stop?: number) => Promise<T[]>;
+        trim: (key: string, maxLen: number) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+    };
+    lock: {
+        acquire: (key: string, opts?: {
+            ttlMs?: number;
+        }) => Promise<{
+            token: string;
+        } | null>;
+        release: (key: string, token: string) => Promise<void>;
+    };
+    dedup: {
+        seen: (key: string, ttlMs: number) => Promise<boolean>;
+    };
+    queue: {
+        enqueue: <T>(key: string, value: T, opts?: {
+            maxSize?: number;
+            onFull?: "drop-oldest" | "drop-newest";
+        }) => Promise<number>;
+        dequeue: <T>(key: string) => Promise<T | undefined>;
+        depth: (key: string) => Promise<number>;
+    };
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/state/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../src/state/memory-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAQnD,qBAAa,WAAY,YAAW,UAAU;IAC5C,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,KAAK,CAA0C;IACvD,OAAO,CAAC,KAAK,CAA4D;IACzE,OAAO,CAAC,MAAM,CAAgC;IAE9C,EAAE;cACY,CAAC,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;cAQvC,CAAC,OAAO,MAAM,SAAS,CAAC,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;sBAMhD,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;MAG1C;IAEF,IAAI;iBACa,CAAC,OACT,MAAM,SACJ,CAAC,SACD;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,KACzC,OAAO,CAAC,MAAM,CAAC;gBAYJ,CAAC,OAAO,MAAM,yBAAoB,MAAM,KAAG,OAAO,CAAC,CAAC,EAAE,CAAC;oBASnD,MAAM,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;sBAMpC,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;MAG1C;IAEF,IAAI;uBAEK,MAAM,SACJ;YAAE,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,KACxB,OAAO,CAAC;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;uBAWf,MAAM,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;MAI1D;IAEF,KAAK;oBACe,MAAM,SAAS,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;MAO1D;IAEF,KAAK;kBACa,CAAC,OACV,MAAM,SACJ,CAAC,SACD;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,aAAa,GAAG,aAAa,CAAA;SAAE,KAClE,OAAO,CAAC,MAAM,CAAC;kBAaF,CAAC,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;qBAIpC,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC;MAE3C;CACH"}

package/dist/state/memory-store.js

@@ -0,0 +1,110 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_LOCK_TTL_MS = 30_000;
+const live = (e) => !!e && (e.expiresAt === undefined || Date.now() <= e.expiresAt);
+export class MemoryStore {
+    kvMap = new Map();
+    lists = new Map();
+    locks = new Map();
+    queues = new Map();
+    kv = {
+        get: async (key) => {
+            const e = this.kvMap.get(key);
+            if (!live(e)) {
+                this.kvMap.delete(key);
+                return undefined;
+            }
+            return e.value;
+        },
+        set: async (key, value, ttlMs) => {
+            this.kvMap.set(key, {
+                value,
+                expiresAt: ttlMs ? Date.now() + ttlMs : undefined,
+            });
+        },
+        delete: async (key) => {
+            this.kvMap.delete(key);
+        },
+    };
+    list = {
+        append: async (key, value, opts) => {
+            const e = this.lists.get(key);
+            const arr = live(e) ? e.value : [];
+            arr.push(value);
+            if (opts?.maxLen && arr.length > opts.maxLen)
+                arr.splice(0, arr.length - opts.maxLen);
+            this.lists.set(key, {
+                value: arr,
+                expiresAt: opts?.ttlMs ? Date.now() + opts.ttlMs : e?.expiresAt,
+            });
+            return arr.length;
+        },
+        range: async (key, start = 0, stop) => {
+            const e = this.lists.get(key);
+            if (!live(e)) {
+                this.lists.delete(key);
+                return [];
+            }
+            const arr = e.value;
+            return arr.slice(start, stop === undefined ? undefined : stop + 1);
+        },
+        trim: async (key, maxLen) => {
+            const e = this.lists.get(key);
+            if (!live(e))
+                return;
+            const arr = e.value;
+            if (arr.length > maxLen)
+                arr.splice(0, arr.length - maxLen);
+        },
+        delete: async (key) => {
+            this.lists.delete(key);
+        },
+    };
+    lock = {
+        acquire: async (key, opts) => {
+            const cur = this.locks.get(key);
+            if (cur && (cur.expiresAt === undefined || Date.now() <= cur.expiresAt))
+                return null;
+            const token = randomUUID();
+            this.locks.set(key, {
+                token,
+                expiresAt: Date.now() + (opts?.ttlMs ?? DEFAULT_LOCK_TTL_MS),
+            });
+            return { token };
+        },
+        release: async (key, token) => {
+            const cur = this.locks.get(key);
+            if (cur?.token === token)
+                this.locks.delete(key);
+        },
+    };
+    dedup = {
+        seen: async (key, ttlMs) => {
+            const k = `dedup:${key}`;
+            const e = this.kvMap.get(k);
+            if (live(e))
+                return true;
+            this.kvMap.set(k, { value: 1, expiresAt: Date.now() + ttlMs });
+            return false;
+        },
+    };
+    queue = {
+        enqueue: async (key, value, opts) => {
+            const arr = this.queues.get(key) ?? [];
+            if (opts?.maxSize && arr.length >= opts.maxSize) {
+                if ((opts.onFull ?? "drop-oldest") === "drop-newest") {
+                    this.queues.set(key, arr);
+                    return arr.length;
+                }
+                arr.shift();
+            }
+            arr.push(value);
+            this.queues.set(key, arr);
+            return arr.length;
+        },
+        dequeue: async (key) => {
+            const arr = this.queues.get(key);
+            return arr && arr.length ? arr.shift() : undefined;
+        },
+        depth: async (key) => this.queues.get(key)?.length ?? 0,
+    };
+}

package/dist/state/memory-store.test.d.ts

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

package/dist/state/memory-store.test.d.ts.map

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

package/dist/state/memory-store.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi } from "vitest";
+import { runStateStoreConformance } from "../testing/state-store-conformance.js";
+import { MemoryStore } from "./memory-store.js";
+runStateStoreConformance("MemoryStore", () => new MemoryStore());
+describe("MemoryStore lock default TTL", () => {
+    it("auto-expires a no-ttl lock after the 30s default (not immortal)", async () => {
+        vi.useFakeTimers();
+        try {
+            const s = new MemoryStore();
+            const a = await s.lock.acquire("k"); // no ttlMs
+            expect(a).not.toBeNull();
+            vi.advanceTimersByTime(29_000);
+            expect(await s.lock.acquire("k")).toBeNull(); // still held before 30s
+            vi.advanceTimersByTime(2_000); // now past 30s
+            const b = await s.lock.acquire("k");
+            expect(b).not.toBeNull(); // expired -> re-acquirable
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/dist/state/state-conversation-store.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationStore } from "../platform-adapter.js";
+import type { StateStore } from "./state-store.js";
+/**
+ * A {@link ConversationStore} backed by `StateStore.kv`.
+ *
+ * Persists the `conversationKey → threadId` mapping under the key
+ * `conv:<conversationKey>`, so the same stable agent thread is reused across
+ * process restarts and multiple instances sharing the same store backend.
+ * Agent instances are still created per-process via `makeAgent`.
+ */
+export declare function createStateBackedConversationStore(state: StateStore, opts?: {
+    idTtlMs?: number;
+}): ConversationStore;
+//# sourceMappingURL=state-conversation-store.d.ts.map

package/dist/state/state-conversation-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-conversation-store.d.ts","sourceRoot":"","sources":["../../src/state/state-conversation-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,UAAU,EACjB,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1B,iBAAiB,CAgBnB"}

package/dist/state/state-conversation-store.js

@@ -0,0 +1,22 @@
+import { randomUUID } from "node:crypto";
+/**
+ * A {@link ConversationStore} backed by `StateStore.kv`.
+ *
+ * Persists the `conversationKey → threadId` mapping under the key
+ * `conv:<conversationKey>`, so the same stable agent thread is reused across
+ * process restarts and multiple instances sharing the same store backend.
+ * Agent instances are still created per-process via `makeAgent`.
+ */
+export function createStateBackedConversationStore(state, opts) {
+    return {
+        async getOrCreate(conversationKey, _replyTarget, makeAgent) {
+            const k = `conv:${conversationKey}`;
+            let threadId = await state.kv.get(k);
+            if (!threadId) {
+                threadId = randomUUID();
+                await state.kv.set(k, threadId, opts?.idTtlMs);
+            }
+            return { agent: makeAgent(threadId) };
+        },
+    };
+}

package/dist/state/state-conversation-store.test.d.ts

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

package/dist/state/state-conversation-store.test.d.ts.map

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

package/dist/state/state-conversation-store.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { MemoryStore } from "./memory-store.js";
+import { createStateBackedConversationStore } from "./state-conversation-store.js";
+describe("createStateBackedConversationStore", () => {
+    it("two stores sharing one MemoryStore yield the same persisted threadId", async () => {
+        const mem = new MemoryStore();
+        // Minimal stub — makeAgent only needs to accept a threadId; the test captures it.
+        const capturedIds = [];
+        const makeAgent = (threadId) => {
+            capturedIds.push(threadId);
+            // Return a minimal object that satisfies AbstractAgent structurally.
+            return {};
+        };
+        const store1 = createStateBackedConversationStore(mem);
+        const store2 = createStateBackedConversationStore(mem);
+        const target = {};
+        const session1 = await store1.getOrCreate("c1", target, makeAgent);
+        const session2 = await store2.getOrCreate("c1", target, makeAgent);
+        // Both calls should have reached makeAgent with the SAME threadId.
+        expect(capturedIds).toHaveLength(2);
+        expect(capturedIds[0]).toBe(capturedIds[1]);
+        // The threadId must be a valid UUID (minted on first call).
+        expect(capturedIds[0]).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+        // Both sessions carry the agent returned by makeAgent.
+        expect(session1.agent).toBeDefined();
+        expect(session2.agent).toBeDefined();
+    });
+    it("different conversationKeys get distinct threadIds", async () => {
+        const mem = new MemoryStore();
+        const store = createStateBackedConversationStore(mem);
+        const target = {};
+        const ids = [];
+        const makeAgent = (threadId) => {
+            ids.push(threadId);
+            return {};
+        };
+        await store.getOrCreate("c1", target, makeAgent);
+        await store.getOrCreate("c2", target, makeAgent);
+        expect(ids).toHaveLength(2);
+        expect(ids[0]).not.toBe(ids[1]);
+    });
+    it("respects idTtlMs — expired mapping mints a new threadId", async () => {
+        const mem = new MemoryStore();
+        const store = createStateBackedConversationStore(mem, { idTtlMs: 30 });
+        const target = {};
+        const ids = [];
+        const makeAgent = (threadId) => {
+            ids.push(threadId);
+            return {};
+        };
+        await store.getOrCreate("c1", target, makeAgent);
+        // Wait for the TTL to expire.
+        await new Promise((r) => setTimeout(r, 60));
+        await store.getOrCreate("c1", target, makeAgent);
+        expect(ids).toHaveLength(2);
+        expect(ids[0]).not.toBe(ids[1]);
+    });
+});

package/dist/state/state-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Pluggable persistence interface for the bot runtime.
+ *
+ * **JSON-serialization contract**: all values round-trip through
+ * `JSON.stringify` / `JSON.parse` on remote backends (Redis, Postgres), so `T`
+ * must be JSON-serializable. Non-JSON values (Date, Map, class instances) will
+ * not survive on those backends. MemoryStore preserves them by reference — a
+ * backend divergence to be aware of when writing tests that run against both.
+ */
+export interface StateStore {
+    kv: {
+        get<T>(key: string): Promise<T | undefined>;
+        set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+        delete(key: string): Promise<void>;
+    };
+    list: {
+        /**
+         * Append to a capped list; returns new length.
+         * When `ttlMs` is given, (re)sets the whole list's expiry; otherwise the
+         * existing expiry is preserved.
+         */
+        append<T>(key: string, value: T, opts?: {
+            maxLen?: number;
+            ttlMs?: number;
+        }): Promise<number>;
+        /**
+         * Oldest-first range; defaults to the whole list.
+         * Indices are non-negative only; negative indices are not supported
+         * (behavior is backend-specific).
+         */
+        range<T>(key: string, start?: number, stop?: number): Promise<T[]>;
+        trim(key: string, maxLen: number): Promise<void>;
+        delete(key: string): Promise<void>;
+    };
+    lock: {
+        /**
+         * Returns a release token, or null if already held.
+         * When `ttlMs` is omitted, the lock auto-expires after a default window
+         * (30_000 ms) so a crashed holder can't deadlock the key. All backends
+         * apply the same default.
+         */
+        acquire(key: string, opts?: {
+            ttlMs?: number;
+        }): Promise<{
+            token: string;
+        } | null>;
+        /** No-op if the token no longer owns the lock. */
+        release(key: string, token: string): Promise<void>;
+    };
+    dedup: {
+        /** Atomically record `key`; returns true if it was ALREADY seen within ttl. */
+        seen(key: string, ttlMs: number): Promise<boolean>;
+    };
+    queue: {
+        enqueue<T>(key: string, value: T, opts?: {
+            maxSize?: number;
+            onFull?: "drop-oldest" | "drop-newest";
+        }): Promise<number>;
+        dequeue<T>(key: string): Promise<T | undefined>;
+        depth(key: string): Promise<number>;
+    };
+}
+//# sourceMappingURL=state-store.d.ts.map

package/dist/state/state-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-store.d.ts","sourceRoot":"","sources":["../../src/state/state-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE;QACF,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACpC,CAAC;IACF,IAAI,EAAE;QACJ;;;;WAIG;QACH,MAAM,CAAC,CAAC,EACN,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,CAAC,EACR,IAAI,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,GACzC,OAAO,CAAC,MAAM,CAAC,CAAC;QACnB;;;;WAIG;QACH,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;QACnE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACjD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACpC,CAAC;IACF,IAAI,EAAE;QACJ;;;;;WAKG;QACH,OAAO,CACL,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,GACxB,OAAO,CAAC;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC,CAAC;QACrC,kDAAkD;QAClD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACpD,CAAC;IACF,KAAK,EAAE;QACL,+EAA+E;QAC/E,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KACpD,CAAC;IACF,KAAK,EAAE;QACL,OAAO,CAAC,CAAC,EACP,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,CAAC,EACR,IAAI,CAAC,EAAE;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,aAAa,GAAG,aAAa,CAAA;SAAE,GAClE,OAAO,CAAC,MAAM,CAAC,CAAC;QACnB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;QAChD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;KACrC,CAAC;CACH"}

package/dist/state/state-store.js

@@ -0,0 +1 @@
+export {};

package/dist/telemetry/bot-telemetry.d.ts

@@ -0,0 +1,31 @@
+import type { LambdaSendOptions } from "@copilotkit/shared";
+import type { StateStore } from "../state/state-store.js";
+export declare const BOT_TELEMETRY_EVENTS: readonly ["oss.bot.configured", "oss.bot.started", "oss.bot.start_failed", "oss.bot.agent_run", "oss.bot.agent_run_failed"];
+export type BotTelemetryEvent = (typeof BOT_TELEMETRY_EVENTS)[number];
+export declare function isTestEnv(): boolean;
+export declare function resolveEnvironment(): string;
+export interface BotTelemetryOptions {
+    backend: StateStore;
+    packageName: string;
+    packageVersion: string;
+    environment?: string;
+    disabled?: boolean;
+    sessionId?: string;
+    send?: (o: LambdaSendOptions) => Promise<void>;
+    resolveId?: () => Promise<string>;
+}
+export declare class BotTelemetry {
+    private readonly opts;
+    private readonly disabled;
+    private readonly sendFn;
+    private readonly sessionId;
+    private readonly environment;
+    private readonly resolveId;
+    private idPromise?;
+    private static disclosed;
+    constructor(opts: BotTelemetryOptions);
+    capture(event: BotTelemetryEvent, properties: Record<string, unknown>): void;
+    private disclose;
+    private dispatch;
+}
+//# sourceMappingURL=bot-telemetry.d.ts.map

package/dist/telemetry/bot-telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot-telemetry.d.ts","sourceRoot":"","sources":["../../src/telemetry/bot-telemetry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,eAAO,MAAM,oBAAoB,6HAMvB,CAAC;AACX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAI3C;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,UAAU,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,qBAAa,YAAY;IASX,OAAO,CAAC,QAAQ,CAAC,IAAI;IARjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IACjE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,SAAS,CAAC,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAS;gBAEJ,IAAI,EAAE,mBAAmB;IAStD,OAAO,CAAC,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM5E,OAAO,CAAC,QAAQ;YAQF,QAAQ;CAsBvB"}

package/dist/telemetry/bot-telemetry.js

@@ -0,0 +1,70 @@
+import { lambdaClient, isTelemetryDisabled } from "@copilotkit/shared";
+import { resolveInstallId } from "./install-id.js";
+export const BOT_TELEMETRY_EVENTS = [
+    "oss.bot.configured",
+    "oss.bot.started",
+    "oss.bot.start_failed",
+    "oss.bot.agent_run",
+    "oss.bot.agent_run_failed",
+];
+export function isTestEnv() {
+    const env = process.env;
+    return env.NODE_ENV === "test" || !!env.VITEST || !!env.JEST_WORKER_ID;
+}
+export function resolveEnvironment() {
+    const e = (process.env.NODE_ENV ?? "").toLowerCase();
+    if (e === "production" || e === "development" || e === "test")
+        return e;
+    return "unknown";
+}
+export class BotTelemetry {
+    opts;
+    disabled;
+    sendFn;
+    sessionId;
+    environment;
+    resolveId;
+    idPromise;
+    static disclosed = false;
+    constructor(opts) {
+        this.opts = opts;
+        this.disabled = opts.disabled ?? (isTelemetryDisabled() || isTestEnv());
+        this.sendFn = opts.send ?? lambdaClient.send;
+        this.sessionId = opts.sessionId ?? globalThis.crypto.randomUUID();
+        this.environment = opts.environment ?? resolveEnvironment();
+        this.resolveId =
+            opts.resolveId ?? (() => resolveInstallId({ backend: opts.backend }));
+    }
+    capture(event, properties) {
+        if (this.disabled)
+            return;
+        this.disclose();
+        void this.dispatch(event, properties);
+    }
+    disclose() {
+        if (BotTelemetry.disclosed)
+            return;
+        BotTelemetry.disclosed = true;
+        console.info("[CopilotKit Bot] anonymous telemetry enabled — see https://docs.copilotkit.ai/telemetry to opt out (set COPILOTKIT_TELEMETRY_DISABLED=true).");
+    }
+    async dispatch(event, properties) {
+        try {
+            this.idPromise ??= this.resolveId();
+            const anonymous_id = await this.idPromise;
+            await this.sendFn({
+                event,
+                properties,
+                globalProperties: {
+                    anonymous_id,
+                    bot_session_id: this.sessionId,
+                    environment: this.environment,
+                },
+                packageName: this.opts.packageName,
+                packageVersion: this.opts.packageVersion,
+            });
+        }
+        catch {
+            /* best-effort: telemetry must not break the host app */
+        }
+    }
+}

package/dist/telemetry/bot-telemetry.test.d.ts

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

package/dist/telemetry/bot-telemetry.test.d.ts.map

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

package/dist/telemetry/bot-telemetry.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi } from "vitest";
+import { BotTelemetry, BOT_TELEMETRY_EVENTS } from "./bot-telemetry.js";
+import { MemoryStore } from "../state/memory-store.js";
+const tick = () => new Promise((r) => setTimeout(r, 0));
+const base = {
+    backend: new MemoryStore(),
+    packageName: "@copilotkit/channels",
+    packageVersion: "0.0.3",
+};
+describe("BotTelemetry", () => {
+    it("sends event with anonymous_id + bot_session_id in global_properties", async () => {
+        const send = vi.fn().mockResolvedValue(undefined);
+        const t = new BotTelemetry({
+            ...base,
+            disabled: false,
+            send,
+            sessionId: "S1",
+            resolveId: async () => "ANON",
+        });
+        t.capture("oss.bot.configured", { platforms: ["slack"] });
+        await tick();
+        expect(send).toHaveBeenCalledTimes(1);
+        const arg = send.mock.calls[0][0];
+        expect(arg.event).toBe("oss.bot.configured");
+        expect(arg.properties).toEqual({ platforms: ["slack"] });
+        expect(arg.globalProperties.anonymous_id).toBe("ANON");
+        expect(arg.globalProperties.bot_session_id).toBe("S1");
+    });
+    it("is a no-op when disabled", async () => {
+        const send = vi.fn();
+        const t = new BotTelemetry({ ...base, disabled: true, send });
+        t.capture("oss.bot.started", {});
+        await tick();
+        expect(send).not.toHaveBeenCalled();
+    });
+    it("never throws when send rejects", async () => {
+        const send = vi.fn().mockRejectedValue(new Error("boom"));
+        const t = new BotTelemetry({
+            ...base,
+            disabled: false,
+            send,
+            resolveId: async () => "X",
+        });
+        expect(() => t.capture("oss.bot.agent_run", {})).not.toThrow();
+        await tick();
+    });
+    it("exposes the five event names", () => {
+        expect([...BOT_TELEMETRY_EVENTS].sort()).toEqual([
+            "oss.bot.agent_run",
+            "oss.bot.agent_run_failed",
+            "oss.bot.configured",
+            "oss.bot.start_failed",
+            "oss.bot.started",
+        ]);
+    });
+});

package/dist/telemetry/create-bot-telemetry.test.d.ts

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

package/dist/telemetry/create-bot-telemetry.test.d.ts.map

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