@copilotkit/channels 0.1.0

package/dist/reactions.test.js

@@ -0,0 +1,197 @@
+// packages/channels/src/reactions.test.ts
+import { describe, it, expect } from "vitest";
+import { emoji, Message } from "@copilotkit/channels-ui";
+import { createBot } from "./create-bot.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+import { MemoryStore } from "./state/memory-store.js";
+const tick = () => new Promise((r) => setTimeout(r, 0));
+describe("bot.onReaction", () => {
+    it("routes a specific reaction, normalizing the platform token", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const seen = [];
+        bot.onReaction([emoji.thumbs_up], (evt) => {
+            seen.push({ emoji: evt.emoji, raw: evt.rawEmoji, added: evt.added });
+        });
+        await bot.start();
+        // FakeAdapter.platform === "fake": normalizeEmoji falls through, but engine
+        // normalizes by adapter.platform. Use a Slack-style token via a fake whose
+        // platform normalizes — here we assert passthrough + catch-all instead.
+        fake.emitReaction({ rawEmoji: "👍", added: true });
+        await tick();
+        // "fake" platform isn't in the table, so the raw token passes through.
+        expect(seen).toEqual([]); // specific match on "thumbs_up" did not fire for raw "👍" on platform "fake"
+    });
+    it("fires a catch-all for any reaction and reports added/removed", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const seen = [];
+        bot.onReaction((evt) => {
+            seen.push({
+                raw: evt.rawEmoji,
+                added: evt.added,
+                user: evt.user?.id,
+                messageId: evt.messageId,
+                platform: evt.thread.platform,
+            });
+        });
+        await bot.start();
+        fake.emitReaction({
+            rawEmoji: "🎉",
+            added: true,
+            user: { id: "U1" },
+            messageId: "m9",
+        });
+        fake.emitReaction({ rawEmoji: "🎉", added: false, messageId: "m9" });
+        await tick();
+        expect(seen).toEqual([
+            { raw: "🎉", added: true, user: "U1", messageId: "m9", platform: "fake" },
+            {
+                raw: "🎉",
+                added: false,
+                user: undefined,
+                messageId: "m9",
+                platform: "fake",
+            },
+        ]);
+    });
+    it("matches a normalized name on a platform in the emoji table", async () => {
+        // A fake whose platform === "slack" so normalizeEmoji maps the shortcode.
+        const fake = new FakeAdapter();
+        Object.defineProperty(fake, "platform", { value: "slack" });
+        const bot = createBot({ adapters: [fake] });
+        const hits = [];
+        bot.onReaction(["thumbs_up"], (evt) => {
+            hits.push(evt.emoji);
+        });
+        await bot.start();
+        fake.emitReaction({ rawEmoji: "thumbsup", added: true }); // Slack alias
+        await tick();
+        expect(hits).toEqual(["thumbs_up"]);
+    });
+    it("routes a reaction on a posted message to its <Message onReaction>", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const seen = [];
+        bot.onMessage(async ({ thread }) => {
+            await thread.post(Message({
+                onReaction: (e, r) => {
+                    seen.push({ emoji: e, added: r.added });
+                },
+                children: "hi",
+            }));
+        });
+        await bot.start();
+        fake.emitTurn({});
+        await tick();
+        // The handler is a closure, never serialized into the native payload.
+        expect(fake.posted[0]?.[0]?.props.onReaction).toBeUndefined();
+        // First post → "msg-1" (FakeAdapter counter).
+        fake.emitReaction({ rawEmoji: "🎉", added: true, messageId: "msg-1" });
+        fake.emitReaction({ rawEmoji: "🎉", added: false, messageId: "msg-1" });
+        await tick();
+        expect(seen).toEqual([
+            { emoji: "🎉", added: true },
+            { emoji: "🎉", added: false },
+        ]);
+    });
+    it("re-derives a registered component's onReaction from the store after a restart", async () => {
+        const backend = new MemoryStore(); // shared store survives the simulated restart
+        const seen = [];
+        // A named component so it can be re-registered + re-rendered after restart.
+        const Card = () => Message({
+            onReaction: (e) => {
+                seen.push(e);
+            },
+            children: "deploy done",
+        });
+        // Bot 1 posts the component message, persisting a reaction snapshot.
+        const fake1 = new FakeAdapter();
+        const bot1 = createBot({
+            adapters: [fake1],
+            store: { adapter: backend },
+            components: [Card],
+        });
+        bot1.onMessage(async ({ thread }) => {
+            // A component element ({ type: fn }) — the path that persists, unlike a
+            // pre-rendered Message() node.
+            await thread.post({ type: Card, props: {} });
+        });
+        await bot1.start();
+        fake1.emitTurn({});
+        await tick();
+        // "Restart": a fresh bot + registry sharing the same store, Card re-registered.
+        // Its reaction hot cache is empty, so it must resolve via the durable snapshot.
+        const fake2 = new FakeAdapter();
+        const bot2 = createBot({
+            adapters: [fake2],
+            store: { adapter: backend },
+            components: [Card],
+        });
+        await bot2.start();
+        fake2.emitReaction({ rawEmoji: "🎉", added: true, messageId: "msg-1" });
+        await tick();
+        expect(seen).toEqual(["🎉"]);
+    });
+    it("gives the handler a thread to post new UI and the reacted message's ref", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        let seenRefId;
+        bot.onMessage(async ({ thread }) => {
+            await thread.post(Message({
+                onReaction: async (_e, r) => {
+                    seenRefId = r.messageRef.id;
+                    await r.thread.post("thanks for the reaction"); // post new UI like onClick can
+                },
+                children: "hi",
+            }));
+        });
+        await bot.start();
+        fake.emitTurn({});
+        await tick();
+        const before = fake.posted.length;
+        fake.emitReaction({ rawEmoji: "🎉", added: true, messageId: "msg-1" });
+        await tick();
+        // The handler posted a second message via its thread.
+        expect(fake.posted.length).toBe(before + 1);
+        // …and received an update-capable ref to the reacted message (fallback id here).
+        expect(seenRefId).toBe("msg-1");
+    });
+    it("does not fire a message handler for a reaction on a different message", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        let fired = false;
+        bot.onMessage(async ({ thread }) => {
+            await thread.post(Message({
+                onReaction: () => {
+                    fired = true;
+                },
+                children: "hi",
+            }));
+        });
+        await bot.start();
+        fake.emitTurn({});
+        await tick();
+        fake.emitReaction({ rawEmoji: "🎉", added: true, messageId: "other" });
+        await tick();
+        expect(fired).toBe(false);
+    });
+    it("normalizes a raw-token filter (unicode / slack alias) to canonical", async () => {
+        // Caller registers a raw unicode token; ingress normalizes the inbound
+        // Slack alias to the canonical "thumbs_up", so the filter must too.
+        const fake = new FakeAdapter();
+        Object.defineProperty(fake, "platform", { value: "slack" });
+        const bot = createBot({ adapters: [fake] });
+        const hits = [];
+        bot.onReaction(["👍"], (evt) => {
+            hits.push(evt.emoji);
+        });
+        bot.onReaction(["thumbsup"], (evt) => {
+            hits.push(`alias:${evt.emoji}`);
+        });
+        await bot.start();
+        fake.emitReaction({ rawEmoji: "thumbsup", added: true }); // Slack alias
+        await tick();
+        expect(hits).toEqual(["thumbs_up", "alias:thumbs_up"]);
+    });
+});

package/dist/run-loop.d.ts

@@ -0,0 +1,41 @@
+import type { AbstractAgent } from "@ag-ui/client";
+import type { RunRenderer, CapturedToolCall, CapturedInterrupt } from "./platform-adapter.js";
+import type { BotTool, BotToolContext, AgentToolDescriptor, ContextEntry } from "./tools.js";
+export interface RunLoopArgs {
+    agent: AbstractAgent;
+    renderer: RunRenderer;
+    tools: Map<string, BotTool>;
+    toolDescriptors: AgentToolDescriptor[];
+    context: ContextEntry[];
+    /** ctx passed to tool.handler (thread + platform). */
+    makeToolCtx: (call: CapturedToolCall) => BotToolContext;
+    /** Invoke the registered onInterrupt handler (posts a picker); the loop then ends. */
+    handleInterrupt?: (interrupt: CapturedInterrupt) => Promise<void> | void;
+    isAborted?: () => boolean;
+    /** Hard cap on loop iterations. Default 6. */
+    maxIterations?: number;
+    /** When re-entering via thread.resume, the resume command to replay. */
+    initialResume?: {
+        resume: unknown;
+    };
+}
+/**
+ * Drive the agent, executing frontend-tool calls and re-invoking until the
+ * agent stops calling them (or we hit the iteration cap). On a captured
+ * LangGraph-style interrupt the loop posts the picker via `handleInterrupt`
+ * and returns immediately ("ack-first") — `thread.resume` re-enters later
+ * with `initialResume` set.
+ */
+export declare function runAgentLoop(args: RunLoopArgs): Promise<{
+    iterations: number;
+    interrupted: boolean;
+}>;
+/**
+ * If the agent's latest message isn't already the assistant message that
+ * issued these tool calls, append one. AG-UI's agent middleware *should*
+ * populate this from the streamed events, but we defensively reconcile here
+ * so the next `runAgent` sees a valid transcript even on backends that don't.
+ */
+export declare function ensureAssistantToolCallMessage(agent: AbstractAgent, calls: ReadonlyArray<CapturedToolCall>): void;
+export declare function pushToolResult(agent: AbstractAgent, toolCallId: string, content: string): void;
+//# sourceMappingURL=run-loop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-loop.d.ts","sourceRoot":"","sources":["../src/run-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,mBAAmB,EACnB,YAAY,EACb,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5B,eAAe,EAAE,mBAAmB,EAAE,CAAC;IACvC,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,sDAAsD;IACtD,WAAW,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,cAAc,CAAC;IACxD,sFAAsF;IACtF,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACzE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;IAC1B,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,aAAa,CAAC,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;CACrC;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC,CAsEvD;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC,GACrC,IAAI,CA4BN;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,IAAI,CAQN"}

package/dist/run-loop.js

@@ -0,0 +1,102 @@
+import { parseToolArgs, stringifyHandlerResult } from "./tools.js";
+/**
+ * Drive the agent, executing frontend-tool calls and re-invoking until the
+ * agent stops calling them (or we hit the iteration cap). On a captured
+ * LangGraph-style interrupt the loop posts the picker via `handleInterrupt`
+ * and returns immediately ("ack-first") — `thread.resume` re-enters later
+ * with `initialResume` set.
+ */
+export async function runAgentLoop(args) {
+    const { agent, renderer, tools, toolDescriptors, context, makeToolCtx, handleInterrupt, isAborted, initialResume, } = args;
+    const maxIterations = args.maxIterations ?? 6;
+    const executed = new Set();
+    let resume = initialResume;
+    for (let i = 0; i < maxIterations; i++) {
+        if (resume) {
+            await agent.runAgent({ forwardedProps: { command: resume } }, renderer.subscriber);
+            resume = undefined;
+        }
+        else {
+            await agent.runAgent({ tools: toolDescriptors, context: context }, renderer.subscriber);
+        }
+        if (isAborted?.())
+            return { iterations: i + 1, interrupted: false };
+        const pending = renderer.getPendingInterrupt();
+        if (pending) {
+            renderer.clearPendingInterrupt();
+            if (handleInterrupt)
+                await handleInterrupt(pending);
+            // ack-first: picker posted; thread.resume re-enters later
+            return { iterations: i + 1, interrupted: true };
+        }
+        const calls = renderer
+            .getCapturedToolCalls()
+            .filter((c) => tools.has(c.toolCallName) && !executed.has(c.toolCallId));
+        if (calls.length === 0)
+            return { iterations: i + 1, interrupted: false };
+        ensureAssistantToolCallMessage(agent, calls);
+        for (const call of calls) {
+            const tool = tools.get(call.toolCallName);
+            let result;
+            const parsed = await parseToolArgs(tool.parameters, call.toolCallArgs);
+            if (!parsed.ok) {
+                result = JSON.stringify({
+                    error: `invalid arguments: ${parsed.error}`,
+                });
+            }
+            else {
+                try {
+                    result = stringifyHandlerResult(await tool.handler(parsed.value, makeToolCtx(call)));
+                }
+                catch (err) {
+                    result = JSON.stringify({ error: err.message });
+                }
+            }
+            pushToolResult(agent, call.toolCallId, result);
+            executed.add(call.toolCallId);
+        }
+    }
+    return { iterations: maxIterations, interrupted: false };
+}
+/**
+ * If the agent's latest message isn't already the assistant message that
+ * issued these tool calls, append one. AG-UI's agent middleware *should*
+ * populate this from the streamed events, but we defensively reconcile here
+ * so the next `runAgent` sees a valid transcript even on backends that don't.
+ */
+export function ensureAssistantToolCallMessage(agent, calls) {
+    const messages = agent.messages;
+    const last = messages[messages.length - 1];
+    const lastIsAssistantWithCalls = last !== undefined &&
+        last.role === "assistant" &&
+        Array.isArray(last.toolCalls);
+    if (lastIsAssistantWithCalls) {
+        const existing = (last.toolCalls ?? []).map((tc) => tc.id);
+        const allPresent = calls.every((c) => existing.includes(c.toolCallId));
+        if (allPresent)
+            return;
+    }
+    const assistant = {
+        id: `${calls[0].toolCallId}-assistant`,
+        role: "assistant",
+        content: "",
+        toolCalls: calls.map((c) => ({
+            id: c.toolCallId,
+            type: "function",
+            function: {
+                name: c.toolCallName,
+                arguments: JSON.stringify(c.toolCallArgs),
+            },
+        })),
+    };
+    agent.addMessage(assistant);
+}
+export function pushToolResult(agent, toolCallId, content) {
+    const toolMessage = {
+        id: `${toolCallId}-result`,
+        role: "tool",
+        toolCallId,
+        content,
+    };
+    agent.addMessage(toolMessage);
+}

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

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

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

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

package/dist/run-loop.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import { z } from "zod";
+import { runAgentLoop } from "./run-loop.js";
+import { makeFakeRunRenderer } from "./testing/fake-adapter.js";
+import { FakeAgent } from "./testing/fake-agent.js";
+const toolDescriptors = [];
+const context = [];
+describe("runAgentLoop", () => {
+    it("executes a frontend tool call and pushes the result, then terminates", async () => {
+        const renderer = makeFakeRunRenderer();
+        const recorded = [];
+        const echo = {
+            name: "echo",
+            description: "echo back",
+            parameters: z.object({ msg: z.string() }),
+            handler: (args) => {
+                recorded.push(args);
+                return { ok: true };
+            },
+        };
+        const tools = new Map([["echo", echo]]);
+        // Step 1: agent emits an `echo` tool call, then finishes.
+        // Step 2: agent just finishes (no further tool calls) -> loop terminates.
+        const agent = new FakeAgent([
+            (sub) => {
+                sub.onToolCallEndEvent?.({
+                    event: { toolCallId: "t1" },
+                    toolCallName: "echo",
+                    toolCallArgs: { msg: "hi" },
+                });
+                sub.onRunFinishedEvent?.({ event: {} });
+            },
+            (sub) => {
+                sub.onRunFinishedEvent?.({ event: {} });
+            },
+        ]);
+        await runAgentLoop({
+            agent,
+            renderer,
+            tools,
+            toolDescriptors,
+            context,
+            makeToolCtx: () => ({ thread: {}, platform: "fake" }),
+        });
+        expect(recorded).toEqual([{ msg: "hi" }]);
+        expect(agent.runAgentCalls).toBe(2);
+        const toolResult = agent.messages.find((m) => m.role === "tool");
+        expect(toolResult).toBeDefined();
+        expect(toolResult.toolCallId).toBe("t1");
+    });
+    it("posts the picker via handleInterrupt and returns without running tools", async () => {
+        const renderer = makeFakeRunRenderer();
+        const tools = new Map();
+        const handleInterrupt = vi.fn();
+        const agent = new FakeAgent([
+            (sub) => {
+                sub.onCustomEvent?.({
+                    event: { name: "on_interrupt", value: { q: 1 } },
+                });
+                sub.onRunFinishedEvent?.({ event: {} });
+            },
+        ]);
+        await runAgentLoop({
+            agent,
+            renderer,
+            tools,
+            toolDescriptors,
+            context,
+            makeToolCtx: () => ({ thread: {}, platform: "fake" }),
+            handleInterrupt,
+        });
+        expect(handleInterrupt).toHaveBeenCalledTimes(1);
+        expect(handleInterrupt).toHaveBeenCalledWith({
+            eventName: "on_interrupt",
+            value: { q: 1 },
+        });
+        expect(agent.runAgentCalls).toBe(1);
+        expect(agent.messages.some((m) => m.role === "tool")).toBe(false);
+    });
+    it("returns interrupted=true and an iteration count when the agent interrupts", async () => {
+        const renderer = makeFakeRunRenderer();
+        const tools = new Map();
+        const handleInterrupt = vi.fn();
+        const agent = new FakeAgent([
+            (sub) => {
+                sub.onCustomEvent?.({
+                    event: { name: "on_interrupt", value: { q: 1 } },
+                });
+                sub.onRunFinishedEvent?.({ event: {} });
+            },
+        ]);
+        const args = {
+            agent,
+            renderer,
+            tools,
+            toolDescriptors,
+            context,
+            makeToolCtx: () => ({ thread: {}, platform: "fake" }),
+            handleInterrupt,
+        };
+        const result = await runAgentLoop(args);
+        expect(result.interrupted).toBe(true);
+        expect(result.iterations).toBeGreaterThanOrEqual(1);
+    });
+    it("returns interrupted=false on a normal completion", async () => {
+        const renderer = makeFakeRunRenderer();
+        const tools = new Map();
+        const agent = new FakeAgent([
+            (sub) => {
+                sub.onRunFinishedEvent?.({ event: {} });
+            },
+        ]);
+        const args = {
+            agent,
+            renderer,
+            tools,
+            toolDescriptors,
+            context,
+            makeToolCtx: () => ({ thread: {}, platform: "fake" }),
+        };
+        const result = await runAgentLoop(args);
+        expect(result.interrupted).toBe(false);
+        expect(result.iterations).toBeGreaterThanOrEqual(1);
+    });
+});

package/dist/standard-schema.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Schema-library-agnostic helpers for the Slack SDK.
+ *
+ * The public API accepts any [Standard Schema](https://standardschema.dev)
+ * validator — Zod 3.24+, Valibot v1+, ArkType v2+, and anything else that
+ * implements the `~standard` protocol. We deliberately keep `zod` out of
+ * the public type surface so consumers aren't locked to a single library
+ * or a single Zod major (the v3 ↔ v4 type split otherwise leaks into
+ * every signature that mentions `z.ZodType`).
+ *
+ * These wrap the canonical primitives from `@copilotkit/shared` (the same
+ * ones `@copilotkit/core` uses for its `FrontendTool` parameters) plus a
+ * couple of Slack-local conveniences.
+ */
+import { type StandardSchemaV1, type InferSchemaOutput } from "@copilotkit/shared";
+export type { StandardSchemaV1, InferSchemaOutput };
+/**
+ * A Standard Schema whose validated output is an object record.
+ *
+ * Tool args, component props, HITL props, and interrupt payloads are all
+ * objects (and `@copilotkit/core` constrains tool args to
+ * `Record<string, unknown>`). Bounding those generics by `ObjectSchema`
+ * — rather than coercing a non-object output to `Record` after the fact —
+ * makes a primitive/array schema (e.g. `z.string()`) a compile error at
+ * the `parameters`/`props` field instead of silently widening it.
+ */
+export type ObjectSchema = StandardSchemaV1<unknown, Record<string, unknown>>;
+/**
+ * Convert any Standard Schema to a JSON Schema object suitable for an LLM
+ * tool/parameter descriptor. Prefers a native JSON Schema (Standard JSON
+ * Schema for Valibot/ArkType, `toJSONSchema()` for Zod v4); falls back to
+ * `zod-to-json-schema` only for Zod v3 schemas, which don't emit JSON
+ * Schema themselves. `$ref`s are inlined (`$refStrategy: "none"`) because
+ * most LLM tool-call APIs reject composite `$ref` schemas.
+ */
+export declare function toJsonSchema(schema: StandardSchemaV1): Record<string, unknown>;
+/** Discriminated result of validating a value against a Standard Schema. */
+export type SchemaParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Validate a value against a Standard Schema, awaiting async validators.
+ * Returns a discriminated result with a path-qualified, human-readable
+ * error string on failure — the caller (turn-runner) turns the error into
+ * a JSON tool result so the agent can recover from a bad tool call.
+ */
+export declare function validateSchema<S extends StandardSchemaV1>(schema: S, value: unknown): Promise<SchemaParseResult<InferSchemaOutput<S>>>;
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,CAAC;AAEpD;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,gBAAgB,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB;AAED,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,gBAAgB,EAC7D,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAWlD"}

package/dist/standard-schema.js

@@ -0,0 +1,66 @@
+/**
+ * Schema-library-agnostic helpers for the Slack SDK.
+ *
+ * The public API accepts any [Standard Schema](https://standardschema.dev)
+ * validator — Zod 3.24+, Valibot v1+, ArkType v2+, and anything else that
+ * implements the `~standard` protocol. We deliberately keep `zod` out of
+ * the public type surface so consumers aren't locked to a single library
+ * or a single Zod major (the v3 ↔ v4 type split otherwise leaks into
+ * every signature that mentions `z.ZodType`).
+ *
+ * These wrap the canonical primitives from `@copilotkit/shared` (the same
+ * ones `@copilotkit/core` uses for its `FrontendTool` parameters) plus a
+ * couple of Slack-local conveniences.
+ */
+import { schemaToJsonSchema as sharedSchemaToJsonSchema, } from "@copilotkit/shared";
+import { zodToJsonSchema } from "zod-to-json-schema";
+/**
+ * Convert any Standard Schema to a JSON Schema object suitable for an LLM
+ * tool/parameter descriptor. Prefers a native JSON Schema (Standard JSON
+ * Schema for Valibot/ArkType, `toJSONSchema()` for Zod v4); falls back to
+ * `zod-to-json-schema` only for Zod v3 schemas, which don't emit JSON
+ * Schema themselves. `$ref`s are inlined (`$refStrategy: "none"`) because
+ * most LLM tool-call APIs reject composite `$ref` schemas.
+ */
+export function toJsonSchema(schema) {
+    return sharedSchemaToJsonSchema(schema, {
+        // Adapt `zod-to-json-schema`'s `(schema: ZodType, ...)` signature to
+        // shared's `(schema: unknown, ...)` injection point. Only invoked for
+        // Zod v3 inputs that don't emit Standard JSON Schema themselves.
+        zodToJsonSchema: (s, options) => zodToJsonSchema(s, options),
+    });
+}
+/**
+ * Validate a value against a Standard Schema, awaiting async validators.
+ * Returns a discriminated result with a path-qualified, human-readable
+ * error string on failure — the caller (turn-runner) turns the error into
+ * a JSON tool result so the agent can recover from a bad tool call.
+ */
+export async function validateSchema(schema, value) {
+    const raw = schema["~standard"].validate(value);
+    // The Standard Schema spec permits `validate` to return any thenable,
+    // not strictly a native `Promise` (e.g. a Promise from another realm or
+    // a library's custom async result). Detect thenables, not `Promise`
+    // instances, so async validators are always awaited.
+    const result = isThenable(raw) ? await raw : raw;
+    if (result.issues) {
+        return { ok: false, error: formatIssues(result.issues) };
+    }
+    return { ok: true, value: result.value };
+}
+function isThenable(value) {
+    return (value != null && typeof value.then === "function");
+}
+/** Format Standard Schema issues as `path: message; path: message`. */
+function formatIssues(issues) {
+    return issues
+        .map((issue) => {
+        const path = (issue.path ?? [])
+            .map((segment) => typeof segment === "object" && segment !== null
+            ? String(segment.key)
+            : String(segment))
+            .join(".");
+        return `${path || "(root)"}: ${issue.message}`;
+    })
+        .join("; ");
+}

package/dist/state/duration.d.ts

@@ -0,0 +1,3 @@
+/** Parse "30d" | "12h" | "500ms" | 5000 → milliseconds. Throws on bad input. */
+export declare function parseDuration(input: string | number): number;
+//# sourceMappingURL=duration.d.ts.map

package/dist/state/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../src/state/duration.ts"],"names":[],"mappings":"AAOA,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAK5D"}

package/dist/state/duration.js

@@ -0,0 +1,16 @@
+const UNITS = {
+    ms: 1,
+    s: 1000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+/** Parse "30d" | "12h" | "500ms" | 5000 → milliseconds. Throws on bad input. */
+export function parseDuration(input) {
+    if (typeof input === "number")
+        return input;
+    const m = /^(\d+)(ms|s|m|h|d)$/.exec(input.trim());
+    if (!m)
+        throw new Error(`Invalid duration: ${input}`);
+    return Number(m[1]) * UNITS[m[2]];
+}

package/dist/state/duration.test.d.ts

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

package/dist/state/duration.test.d.ts.map

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

package/dist/state/duration.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { parseDuration } from "./duration.js";
+describe("parseDuration", () => {
+    it("parses units", () => {
+        expect(parseDuration("500ms")).toBe(500);
+        expect(parseDuration("30s")).toBe(30_000);
+        expect(parseDuration("5m")).toBe(300_000);
+        expect(parseDuration("2h")).toBe(7_200_000);
+        expect(parseDuration("30d")).toBe(2_592_000_000);
+    });
+    it("passes numbers through", () => expect(parseDuration(1234)).toBe(1234));
+    it("throws on garbage", () => expect(() => parseDuration("nope")).toThrow());
+});

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

@@ -0,0 +1,7 @@
+import type { ActionStore } from "../action-store.js";
+import type { StateStore } from "./state-store.js";
+/** Back the legacy ActionStore shape with state.kv. Durable iff `state` is durable. */
+export declare function kvActionStore(state: StateStore, opts?: {
+    defaultTtlMs?: number;
+}): ActionStore;
+//# sourceMappingURL=kv-action-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kv-action-store.d.ts","sourceRoot":"","sources":["../../src/state/kv-action-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,uFAAuF;AACvF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/B,WAAW,CAOb"}