@copilotkit/bot 0.0.1

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

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

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

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

package/dist/platform-adapter.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+describe("FakeAdapter", () => {
+    it("records posts and drives ingress", async () => {
+        const a = new FakeAdapter();
+        let got;
+        await a.start({
+            onTurn: (t) => {
+                got = t.userText;
+            },
+            onInteraction: () => { },
+            onCommand: () => { },
+        });
+        a.emitTurn({ userText: "hi" });
+        expect(got).toBe("hi");
+        await a.post({}, [{ type: "text", props: { value: "x" } }]);
+        expect(a.posted.length).toBe(1);
+    });
+    it("delivers interactions to the sink", async () => {
+        const a = new FakeAdapter();
+        let id;
+        await a.start({
+            onTurn: () => { },
+            onInteraction: (e) => {
+                id = e.id;
+            },
+            onCommand: () => { },
+        });
+        a.emitInteraction({ id: "ck:abc" });
+        expect(id).toBe("ck:abc");
+    });
+});

package/dist/run-loop.d.ts

@@ -0,0 +1,38 @@
+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<void>;
+/**
+ * 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,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAoEnE;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,100 @@
+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;
+        const pending = renderer.getPendingInterrupt();
+        if (pending) {
+            renderer.clearPendingInterrupt();
+            if (handleInterrupt)
+                await handleInterrupt(pending);
+            return; // ack-first: picker posted; thread.resume re-enters later
+        }
+        const calls = renderer
+            .getCapturedToolCalls()
+            .filter((c) => tools.has(c.toolCallName) && !executed.has(c.toolCallId));
+        if (calls.length === 0)
+            return;
+        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);
+        }
+    }
+}
+/**
+ * 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,80 @@
+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);
+    });
+});

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/testing/fake-adapter.d.ts

@@ -0,0 +1,44 @@
+import type { BotNode, MessageRef, PlatformUser, ThreadMessage } from "@copilotkit/bot-ui";
+import type { PlatformAdapter, SurfaceCapabilities, IngressSink, IncomingTurn, InteractionEvent, IncomingCommand, RunRenderer, ReplyTarget, NativePayload, UserQuery, ConversationStore } from "../platform-adapter.js";
+import type { CommandSpec } from "../commands.js";
+/** A RunRenderer whose subscriber captures tool-call-end and custom (interrupt) events — used by run-loop tests. */
+export declare function makeFakeRunRenderer(): RunRenderer;
+export declare class FakeAdapter implements PlatformAdapter {
+    readonly platform = "fake";
+    readonly capabilities: SurfaceCapabilities;
+    readonly ackDeadlineMs = 3000;
+    readonly conversationStore: ConversationStore;
+    posted: BotNode[][];
+    updated: {
+        ref: MessageRef;
+        ir: BotNode[];
+    }[];
+    interactionsSeen: InteractionEvent[];
+    lastRunRenderer?: RunRenderer;
+    /** History returned by getMessages(); override in tests. */
+    messages: ThreadMessage[];
+    /** User returned by lookupUser(); override in tests. */
+    user?: PlatformUser;
+    private sink?;
+    private counter;
+    start(sink: IngressSink): Promise<void>;
+    stop(): Promise<void>;
+    render(ir: BotNode[]): NativePayload;
+    post(_target: ReplyTarget, ir: BotNode[]): Promise<MessageRef>;
+    update(ref: MessageRef, ir: BotNode[]): Promise<void>;
+    stream(_target: ReplyTarget, chunks: AsyncIterable<string>): Promise<MessageRef>;
+    delete(_ref: MessageRef): Promise<void>;
+    createRunRenderer(_target: ReplyTarget): RunRenderer;
+    decodeInteraction(raw: unknown): InteractionEvent | undefined;
+    lookupUser(_q: UserQuery): Promise<PlatformUser | undefined>;
+    getMessages(_target: ReplyTarget): Promise<ThreadMessage[]>;
+    emitTurn(partial: Partial<IncomingTurn>): void;
+    emitInteraction(partial: Partial<InteractionEvent>): void;
+    emitCommand(partial: Partial<IncomingCommand> & {
+        command: string;
+    }): Promise<void> | void;
+    /** Commands handed to the adapter via `registerCommands`; asserts the capability hook fires. */
+    registeredCommands?: readonly CommandSpec[];
+    registerCommands(commands: readonly CommandSpec[]): void;
+}
+//# sourceMappingURL=fake-adapter.d.ts.map

package/dist/testing/fake-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-adapter.d.ts","sourceRoot":"","sources":["../../src/testing/fake-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,YAAY,EACZ,aAAa,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,WAAW,EAGX,WAAW,EACX,aAAa,EACb,SAAS,EACT,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,oHAAoH;AACpH,wBAAgB,mBAAmB,IAAI,WAAW,CAyBjD;AAED,qBAAa,WAAY,YAAW,eAAe;IACjD,QAAQ,CAAC,QAAQ,UAAU;IAC3B,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAKxC;IACF,QAAQ,CAAC,aAAa,QAAQ;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAI3C;IAEF,MAAM,EAAE,OAAO,EAAE,EAAE,CAAM;IACzB,OAAO,EAAE;QAAE,GAAG,EAAE,UAAU,CAAC;QAAC,EAAE,EAAE,OAAO,EAAE,CAAA;KAAE,EAAE,CAAM;IACnD,gBAAgB,EAAE,gBAAgB,EAAE,CAAM;IAC1C,eAAe,CAAC,EAAE,WAAW,CAAC;IAC9B,4DAA4D;IAC5D,QAAQ,EAAE,aAAa,EAAE,CAAM;IAC/B,wDAAwD;IACxD,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,OAAO,CAAC,IAAI,CAAC,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAK;IAEd,KAAK,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAGvC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAE3B,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,aAAa;IAG9B,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAI9D,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAGrD,MAAM,CACV,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAC5B,OAAO,CAAC,UAAU,CAAC;IAMhB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAE7C,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW;IAKpD,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS;IAGvD,UAAU,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAG5D,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAKjE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAS9C,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAUzD,WAAW,CACT,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GACtD,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAUvB,gGAAgG;IAChG,kBAAkB,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC5C,gBAAgB,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI;CAGzD"}

package/dist/testing/fake-adapter.js

@@ -0,0 +1,123 @@
+/** A RunRenderer whose subscriber captures tool-call-end and custom (interrupt) events — used by run-loop tests. */
+export function makeFakeRunRenderer() {
+    const toolCalls = [];
+    let pending;
+    const subscriber = {
+        onToolCallEndEvent(p) {
+            toolCalls.push({
+                toolCallId: p.event.toolCallId,
+                toolCallName: p.toolCallName,
+                toolCallArgs: (p.toolCallArgs ?? {}),
+            });
+        },
+        onCustomEvent(p) {
+            const e = p.event;
+            if (e.name)
+                pending = { eventName: e.name, value: e.value };
+        },
+    };
+    return {
+        subscriber,
+        async markInterrupted() { },
+        getCapturedToolCalls: () => toolCalls,
+        getPendingInterrupt: () => pending,
+        clearPendingInterrupt: () => {
+            pending = undefined;
+        },
+    };
+}
+export class FakeAdapter {
+    platform = "fake";
+    capabilities = {
+        supportsModals: false,
+        supportsTyping: false,
+        supportsReactions: false,
+        supportsStreaming: true,
+    };
+    ackDeadlineMs = 3000;
+    conversationStore = {
+        async getOrCreate(conversationKey, _replyTarget, makeAgent) {
+            return { agent: makeAgent(conversationKey) };
+        },
+    };
+    posted = [];
+    updated = [];
+    interactionsSeen = [];
+    lastRunRenderer;
+    /** History returned by getMessages(); override in tests. */
+    messages = [];
+    /** User returned by lookupUser(); override in tests. */
+    user;
+    sink;
+    counter = 0;
+    async start(sink) {
+        this.sink = sink;
+    }
+    async stop() { }
+    render(ir) {
+        return ir;
+    }
+    async post(_target, ir) {
+        this.posted.push(ir);
+        return { id: `msg-${++this.counter}` };
+    }
+    async update(ref, ir) {
+        this.updated.push({ ref, ir });
+    }
+    async stream(_target, chunks) {
+        let s = "";
+        for await (const c of chunks)
+            s += c;
+        this.posted.push([{ type: "text", props: { value: s } }]);
+        return { id: `msg-${++this.counter}` };
+    }
+    async delete(_ref) { }
+    createRunRenderer(_target) {
+        const r = makeFakeRunRenderer();
+        this.lastRunRenderer = r;
+        return r;
+    }
+    decodeInteraction(raw) {
+        return raw;
+    }
+    async lookupUser(_q) {
+        return this.user;
+    }
+    async getMessages(_target) {
+        return this.messages;
+    }
+    // --- test helpers ---
+    emitTurn(partial) {
+        void this.sink?.onTurn({
+            conversationKey: "c",
+            replyTarget: {},
+            userText: "",
+            platform: "fake",
+            ...partial,
+        });
+    }
+    emitInteraction(partial) {
+        const evt = {
+            id: "",
+            conversationKey: "c",
+            replyTarget: {},
+            ...partial,
+        };
+        this.interactionsSeen.push(evt);
+        void this.sink?.onInteraction(evt);
+    }
+    emitCommand(partial) {
+        return this.sink?.onCommand({
+            text: "",
+            conversationKey: "c",
+            replyTarget: {},
+            platform: "fake",
+            ...partial,
+        });
+    }
+    /** Commands handed to the adapter via `registerCommands`; asserts the capability hook fires. */
+    registeredCommands;
+    registerCommands(commands) {
+        this.registeredCommands = commands;
+    }
+}

package/dist/testing/fake-agent.d.ts

@@ -0,0 +1,28 @@
+import { AbstractAgent } from "@ag-ui/client";
+import type { AgentSubscriber, RunAgentParameters, RunAgentResult } from "@ag-ui/client";
+import type { RunAgentInput } from "@ag-ui/core";
+/**
+ * One scripted `runAgent` invocation. Each step receives the subscriber the
+ * run-loop passed into `runAgent` and simulates the agent's behaviour by
+ * calling the subscriber's callbacks (e.g. `onToolCallEndEvent`,
+ * `onCustomEvent`, `onRunFinishedEvent`).
+ */
+export type FakeAgentScriptStep = (subscriber: AgentSubscriber) => void | Promise<void>;
+/**
+ * A scriptable fake `AbstractAgent` for exercising the run/tool/interrupt
+ * loop without a real backend. The constructor (or `setScript`) supplies an
+ * ordered list of steps; each `runAgent` call shifts and runs the next step.
+ */
+export declare class FakeAgent extends AbstractAgent {
+    private script;
+    /** Number of `runAgent` invocations seen — handy for loop-termination asserts. */
+    runAgentCalls: number;
+    /** Flipped to true by `abortRun()`. */
+    aborted: boolean;
+    constructor(script?: FakeAgentScriptStep[]);
+    setScript(script: FakeAgentScriptStep[]): void;
+    run(_input: RunAgentInput): ReturnType<AbstractAgent["run"]>;
+    runAgent(_parameters?: RunAgentParameters, subscriber?: AgentSubscriber): Promise<RunAgentResult>;
+    abortRun(): void;
+}
+//# sourceMappingURL=fake-agent.d.ts.map

package/dist/testing/fake-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-agent.d.ts","sourceRoot":"","sources":["../../src/testing/fake-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,UAAU,EAAE,eAAe,KACxB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,aAAa;IAC1C,OAAO,CAAC,MAAM,CAAwB;IACtC,kFAAkF;IAClF,aAAa,SAAK;IAClB,uCAAuC;IACvC,OAAO,UAAS;gBAEJ,MAAM,GAAE,mBAAmB,EAAO;IAK9C,SAAS,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,IAAI;IAM9C,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAI7C,QAAQ,CACrB,WAAW,CAAC,EAAE,kBAAkB,EAChC,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,cAAc,CAAC;IASjB,QAAQ,IAAI,IAAI;CAG1B"}

package/dist/testing/fake-agent.js

@@ -0,0 +1,36 @@
+import { AbstractAgent } from "@ag-ui/client";
+/**
+ * A scriptable fake `AbstractAgent` for exercising the run/tool/interrupt
+ * loop without a real backend. The constructor (or `setScript`) supplies an
+ * ordered list of steps; each `runAgent` call shifts and runs the next step.
+ */
+export class FakeAgent extends AbstractAgent {
+    script;
+    /** Number of `runAgent` invocations seen — handy for loop-termination asserts. */
+    runAgentCalls = 0;
+    /** Flipped to true by `abortRun()`. */
+    aborted = false;
+    constructor(script = []) {
+        super({ agentId: "fake" });
+        this.script = [...script];
+    }
+    setScript(script) {
+        this.script = [...script];
+    }
+    // The base class declares `run` abstract. It's never invoked here because
+    // `runAgent` is overridden to drive the script directly (no rxjs stream).
+    run(_input) {
+        throw new Error("FakeAgent.run unused; runAgent is overridden");
+    }
+    async runAgent(_parameters, subscriber) {
+        this.runAgentCalls += 1;
+        const step = this.script.shift();
+        if (step && subscriber) {
+            await step(subscriber);
+        }
+        return { result: undefined, newMessages: [] };
+    }
+    abortRun() {
+        this.aborted = true;
+    }
+}