@calliopelabs/ui 0.13.0 → 0.16.0

package/dist/agent/controller.js

@@ -0,0 +1,496 @@
+import { EventType, } from "@ag-ui/core";
+import { createChatView, reduceChat, } from "../chat/model.js";
+import { userMessageEvents } from "../chat/useAgUiRun.js";
+import { validateToolArgs } from "./tool.js";
+const contextText = (value) => {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value) ?? "";
+    }
+    catch {
+        return String(value);
+    }
+};
+let counter = 0;
+/** An id unique in this page: crypto when there is one, a counter otherwise. */
+export function agentId(prefix = "msg") {
+    const c = globalThis.crypto;
+    return c?.randomUUID ? c.randomUUID() : `${prefix}-${Date.now().toString(36)}-${++counter}`;
+}
+const errorText = (error) => error instanceof Error && error.message
+    ? error.message
+    : typeof error === "string" && error
+        ? error
+        : "The agent run failed.";
+const isAbort = (error) => error instanceof Error && (error.name === "AbortError" || /abort/i.test(error.message));
+export class AgentController {
+    options;
+    engine;
+    unsubscribe = () => { };
+    listeners = new Set();
+    view = createChatView();
+    running = false;
+    runSeq = 0;
+    tools = new Map();
+    toolOrder = 0;
+    context = new Map();
+    suggestionSets = new Map();
+    waiting = new Map();
+    executing = new Set();
+    failed = new Map();
+    decisions = new Map();
+    visible = true;
+    read = 0;
+    snapshot;
+    /** Where each custom event arrived, by its index in the view. */
+    anchors = [];
+    disposed = false;
+    connected = false;
+    threadSeq = 0;
+    /** Set by stop until the next run: a stopped run's late events (its abort error) are dropped. */
+    halted = false;
+    constructor(createEngine, options = {}) {
+        this.options = options;
+        this.engine = createEngine(this.invoke);
+        this.view = this.fromAgent(this.engine.agent.threadId);
+        this.snapshot = this.build();
+        this.read = this.finishedAnswers();
+    }
+    /**
+     * Starts reading the agent's events; returns the disconnect, which stops a
+     * run in flight. Called from an effect, so nothing subscribes on the server
+     * and a StrictMode remount reconnects cleanly.
+     */
+    connect() {
+        this.disposed = false;
+        this.bind();
+        this.syncTools();
+        this.syncContext();
+        return () => {
+            this.stop();
+            this.unsubscribe();
+            this.unsubscribe = () => { };
+            this.connected = false;
+            // Takes back what the engine registered (CopilotKit tools and context in a shared core).
+            this.engine.dispose();
+        };
+    }
+    get agent() {
+        return this.engine.agent;
+    }
+    setOptions(options) {
+        this.options = options;
+    }
+    /** Swaps the engine (CopilotKit hands over a new agent once its runtime connects). */
+    attach(createEngine) {
+        this.stop();
+        this.unsubscribe();
+        this.engine.dispose();
+        this.engine = createEngine(this.invoke);
+        this.view = this.fromAgent(this.engine.agent.threadId);
+        if (this.connected)
+            this.bind();
+        this.syncTools();
+        this.syncContext();
+        this.emit();
+    }
+    // The store.
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getSnapshot = () => this.snapshot;
+    emit() {
+        if (this.visible)
+            this.read = this.finishedAnswers();
+        this.snapshot = this.build();
+        for (const listener of this.listeners)
+            listener();
+    }
+    finishedAnswers() {
+        return this.view.messages.filter((m) => m.role === "assistant" && !m.streaming && m.content)
+            .length;
+    }
+    build() {
+        const touched = this.executing.size > 0 || this.failed.size > 0;
+        const view = touched
+            ? {
+                ...this.view,
+                toolCalls: this.view.toolCalls.map((c) => {
+                    const error = this.failed.get(c.id);
+                    if (error !== undefined)
+                        return { ...c, status: "failed", error };
+                    if (this.executing.has(c.id) && c.result === undefined)
+                        return { ...c, status: "running" };
+                    return c;
+                }),
+            }
+            : this.view;
+        const seen = new Set();
+        const suggestions = [...this.suggestionSets.values()].flat().filter((s) => {
+            if (seen.has(s.message))
+                return false;
+            seen.add(s.message);
+            return true;
+        });
+        return {
+            view,
+            running: this.running,
+            waiting: [...this.waiting.keys()],
+            threadId: this.agent.threadId,
+            unread: Math.max(0, this.finishedAnswers() - this.read),
+            suggestions,
+            tools: [...this.tools.values()].sort((a, b) => a.order - b.order).map((t) => t.tool),
+            custom: this.customItems(),
+        };
+    }
+    customItems() {
+        const items = new Map();
+        this.view.custom.forEach((event, i) => {
+            const value = event.value;
+            const id = typeof value === "object" && value !== null && typeof value.id === "string";
+            const key = id ? `${event.name}:${value.id}` : `${event.name}#${i}`;
+            const item = items.get(key);
+            if (item) {
+                item.value = event.value;
+                item.history.push(event.value);
+            }
+            else {
+                items.set(key, {
+                    key,
+                    name: event.name,
+                    value: event.value,
+                    history: [event.value],
+                    after: this.anchors[i] ?? null,
+                });
+            }
+        });
+        return [...items.values()];
+    }
+    bind() {
+        const agent = this.engine.agent;
+        this.unsubscribe();
+        this.connected = true;
+        const subscriber = {
+            onEvent: ({ event }) => {
+                const e = event;
+                this.fold(e);
+                this.options.onEvent?.(e);
+            },
+            onMessagesChanged: () => this.syncResults(),
+        };
+        const { unsubscribe } = agent.subscribe(subscriber);
+        this.unsubscribe = unsubscribe;
+    }
+    /** The view the agent's own messages and state make, for a fresh start or a thread switch. */
+    fromAgent(threadId) {
+        const agent = this.engine.agent;
+        this.anchors = [];
+        let view = { ...createChatView(), threadId };
+        if (agent.messages.length > 0) {
+            view = reduceChat(view, {
+                type: EventType.MESSAGES_SNAPSHOT,
+                messages: agent.messages,
+            });
+        }
+        const state = agent.state;
+        if (state !== undefined && !(isEmptyObject(state) && view.state === undefined)) {
+            view = reduceChat(view, { type: EventType.STATE_SNAPSHOT, snapshot: state });
+        }
+        return view;
+    }
+    fold(event) {
+        if (this.disposed)
+            return;
+        // A run started elsewhere (CopilotKit's own follow-up) ends the halt; anything else is the stopped run's.
+        if (this.halted && event.type !== EventType.RUN_STARTED)
+            return;
+        this.halted = false;
+        const before = this.view.custom.length;
+        this.view = reduceChat(this.view, event);
+        if (this.view.custom.length > before) {
+            const last = this.view.timeline.at(-1);
+            this.anchors.push(last ? `${last.kind}:${last.id}` : null);
+        }
+        this.emit();
+    }
+    /** Tool results the agent's messages gained outside the event stream: the browser's own tools. */
+    syncResults() {
+        let changed = false;
+        for (const m of this.agent.messages) {
+            if (m.role !== "tool")
+                continue;
+            const call = this.view.toolCalls.find((c) => c.id === m.toolCallId);
+            if (!call || call.result !== undefined)
+                continue;
+            this.view = reduceChat(this.view, {
+                type: EventType.TOOL_CALL_RESULT,
+                messageId: m.id,
+                toolCallId: m.toolCallId,
+                content: typeof m.content === "string" ? m.content : "",
+            });
+            const error = m.error;
+            if (error)
+                this.failed.set(m.toolCallId, error);
+            this.executing.delete(m.toolCallId);
+            changed = true;
+        }
+        if (changed)
+            this.emit();
+    }
+    // Running.
+    invoke = async (tool, raw, { toolCallId, signal }) => {
+        this.executing.add(toolCallId);
+        this.emit();
+        try {
+            const args = await validateToolArgs(tool, raw);
+            if (tool.handler)
+                return await tool.handler(args, { signal, toolCallId });
+            if (!tool.render)
+                return undefined;
+            return await new Promise((resolve, reject) => {
+                if (signal.aborted)
+                    return reject(new Error("aborted"));
+                this.waiting.set(toolCallId, { resolve });
+                this.emit();
+                signal.addEventListener("abort", () => {
+                    this.waiting.delete(toolCallId);
+                    reject(new Error("aborted"));
+                }, { once: true });
+            });
+        }
+        finally {
+            this.waiting.delete(toolCallId);
+            this.executing.delete(toolCallId);
+            this.emit();
+        }
+    };
+    async run(resume) {
+        const seq = ++this.runSeq;
+        this.halted = false;
+        this.decisions.clear();
+        this.running = true;
+        this.emit();
+        try {
+            const forwardedProps = this.options.forwardedProps?.();
+            await this.engine.run({
+                ...(forwardedProps ? { forwardedProps } : {}),
+                ...(resume ? { resume } : {}),
+            });
+        }
+        catch (error) {
+            if (seq === this.runSeq && !isAbort(error)) {
+                if (this.view.status !== "error") {
+                    this.view = reduceChat(this.view, {
+                        type: EventType.RUN_ERROR,
+                        message: errorText(error),
+                    });
+                }
+                this.options.onError?.(error);
+            }
+        }
+        finally {
+            if (seq === this.runSeq) {
+                this.running = false;
+                this.emit();
+            }
+        }
+    }
+    /** Answers every interrupt still open as cancelled, so a new message can start a run. */
+    cancelOpen() {
+        const open = this.view.status === "interrupted" ? this.view.interrupts : [];
+        if (open.length === 0)
+            return undefined;
+        return open.map((i) => this.decisions.get(i.id) ?? { interruptId: i.id, status: "cancelled" });
+    }
+    /** Sends the person's message and runs the agent. Ignored while a run is in flight. */
+    send = (text, options = {}) => {
+        if (this.running || (!text.trim() && !options.parts?.length))
+            return Promise.resolve();
+        const id = agentId();
+        const content = options.parts?.length
+            ? [{ type: "text", text }, ...options.parts]
+            : text;
+        this.agent.addMessage({ id, role: "user", content });
+        for (const event of userMessageEvents(id, text))
+            this.view = reduceChat(this.view, event);
+        return this.run(this.cancelOpen());
+    };
+    /** Stops the run in flight and any tool waiting on the person. */
+    stop = () => {
+        if (!this.running && this.view.status !== "running")
+            return;
+        this.runSeq++;
+        this.halted = true;
+        this.engine.stop();
+        this.running = false;
+        if (this.view.status === "running" || this.executing.size > 0) {
+            this.view = reduceChat({ ...this.view, status: "running" }, {
+                type: EventType.RUN_FINISHED,
+                threadId: this.view.threadId ?? "",
+                runId: this.view.runId ?? "",
+                outcome: { type: "cancelled" },
+            });
+        }
+        this.executing.clear();
+        this.waiting.clear();
+        this.emit();
+    };
+    /** Drops the answer to the last message and asks again. */
+    regenerate = () => {
+        if (this.running)
+            return Promise.resolve();
+        const messages = this.agent.messages;
+        let last = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i]?.role === "user") {
+                last = i;
+                break;
+            }
+        }
+        if (last < 0)
+            return Promise.resolve();
+        this.agent.setMessages(messages.slice(0, last + 1));
+        this.failed.clear();
+        this.view = this.fromAgent(this.agent.threadId);
+        this.emit();
+        return this.run();
+    };
+    /**
+     * Answers one interrupt. When every open interrupt has an answer, the run
+     * resumes with them (AG-UI `resume`).
+     */
+    resolveInterrupt = (interruptId, response) => {
+        if (this.view.status !== "interrupted")
+            return;
+        this.decisions.set(interruptId, { interruptId, ...response });
+        const open = this.view.interrupts;
+        if (open.every((i) => this.decisions.has(i.id))) {
+            void this.run(open.map((i) => this.decisions.get(i.id)));
+        }
+    };
+    /** Approves a tool call the run paused on. */
+    approve = (call, payload) => {
+        if (call.approval)
+            this.resolveInterrupt(call.approval.interruptId, {
+                status: "resolved",
+                payload: { approved: true, ...payload },
+            });
+    };
+    /** Denies it, with the person's reason. */
+    deny = (call, reason) => {
+        if (call.approval)
+            this.resolveInterrupt(call.approval.interruptId, {
+                status: "resolved",
+                payload: { approved: false, reason },
+            });
+    };
+    /** Answers a human-in-the-loop tool call: the result goes back to the agent. */
+    respond = (toolCallId, result) => {
+        const pending = this.waiting.get(toolCallId);
+        if (!pending)
+            return;
+        this.waiting.delete(toolCallId);
+        pending.resolve(result);
+        this.emit();
+    };
+    // Shared state.
+    getState = () => this.view.state;
+    /** Replaces the shared state: the next run sends it, and the view shows it now. */
+    setState = (state) => {
+        this.agent.setState(state);
+        this.view = reduceChat(this.view, { type: EventType.STATE_SNAPSHOT, snapshot: state });
+        this.emit();
+    };
+    // Registries.
+    registerTool = (given) => {
+        const tool = given;
+        const entry = { tool, order: this.toolOrder++ };
+        this.tools.set(tool.name, entry);
+        this.syncTools();
+        this.emit();
+        return () => {
+            if (this.tools.get(tool.name) !== entry)
+                return;
+            this.tools.delete(tool.name);
+            this.syncTools();
+            this.emit();
+        };
+    };
+    syncTools() {
+        this.engine.setTools([...this.tools.values()].map((t) => t.tool));
+    }
+    addContext = (entry) => {
+        const id = agentId("ctx");
+        this.context.set(id, { description: entry.description, value: contextText(entry.value) });
+        this.syncContext();
+        return () => {
+            this.context.delete(id);
+            this.syncContext();
+        };
+    };
+    syncContext() {
+        this.engine.setContext([...this.context.values()]);
+    }
+    addSuggestions = (suggestions) => {
+        const id = agentId("sug");
+        this.suggestionSets.set(id, suggestions);
+        this.emit();
+        return () => {
+            this.suggestionSets.delete(id);
+            this.emit();
+        };
+    };
+    // Threads.
+    /** Opens another conversation: stops this one, loads the other's history. */
+    switchThread = async (threadId) => {
+        this.stop();
+        const seq = ++this.threadSeq;
+        const thread = (await this.options.loadThread?.(threadId)) ?? { messages: [] };
+        // A later switch (or a dispose) while this one loaded wins.
+        if (this.disposed || seq !== this.threadSeq)
+            return;
+        this.agent.threadId = threadId;
+        this.agent.setMessages(thread.messages);
+        this.agent.setState((thread.state ?? {}));
+        this.failed.clear();
+        this.view = this.fromAgent(threadId);
+        this.emit();
+    };
+    /** Starts a new, empty conversation and returns its id. */
+    newThread = async () => {
+        const id = agentId("thread");
+        this.threadSeq++;
+        this.stop();
+        this.agent.threadId = id;
+        this.agent.setMessages([]);
+        this.agent.setState({});
+        this.failed.clear();
+        this.anchors = [];
+        this.view = { ...createChatView(), threadId: id };
+        this.emit();
+        return id;
+    };
+    // The surface.
+    /** Whether the person can see the conversation: answers that land while hidden count as unread. */
+    setVisible = (visible) => {
+        if (this.visible === visible)
+            return;
+        this.visible = visible;
+        this.emit();
+    };
+    dispose() {
+        this.stop();
+        this.disposed = true;
+        this.unsubscribe();
+        this.engine.dispose();
+        this.listeners.clear();
+    }
+}
+function isEmptyObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+}

package/dist/agent/copilotkit/CopilotKitAgentProvider.d.ts

@@ -0,0 +1,41 @@
+import type { AbstractAgent } from "@ag-ui/client";
+import { CopilotKitCoreReact } from "@copilotkit/react-core/v2/context";
+import * as React from "react";
+import { type CalliopeAgentOptions } from "../AgentProvider.js";
+import type { AgentEngine, ToolInvoker } from "../engine.js";
+type CopilotKitCore = CopilotKitCoreReact;
+/**
+ * The engine over CopilotKit's core: CopilotKit runs the agent, executes the
+ * browser's tools, makes follow-ups and carries context, so a host's own
+ * `useFrontendTool`, `useAgentContext` or `useHumanInTheLoop` calls keep
+ * working beside the ones registered here.
+ */
+export declare function createCopilotKitEngine(copilotkit: CopilotKitCore, agent: AbstractAgent, invoke: ToolInvoker, agentId?: string): AgentEngine;
+export interface CopilotKitAgentProviderProps extends Omit<CalliopeAgentOptions, "forwardedProps"> {
+    /** The CopilotKit runtime's route (the Next.js handler around `CopilotRuntime`). */
+    runtimeUrl?: string;
+    /** True for a single-route runtime (`createCopilotRuntimeHandler({ mode: "single-route" })`). */
+    useSingleEndpoint?: boolean;
+    /** Request headers for the runtime (a project id). Never a secret: this runs in the browser. */
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    /** Sent to the runtime with every request (CopilotKit `properties`). */
+    properties?: Record<string, unknown>;
+    /** Agents that run in the page instead of behind the runtime: a story's mock, a test's. */
+    agents?: Record<string, AbstractAgent>;
+    /** The runtime's agent. Defaults to CopilotKit's default agent. */
+    agentId?: string;
+    /** Sent with every run (the model picked, the page). */
+    forwardedProps?: Record<string, unknown>;
+    children: React.ReactNode;
+}
+/**
+ * The agent for a page tree, over a CopilotKit runtime (`runtimeUrl`, the
+ * route around `CopilotRuntime`). CopilotKit wires the runtime and runs the
+ * agent through its headless core; every pixel is the library's
+ * (`CalliopeAgent`, the chat kit), never CopilotKit's UI or stylesheet.
+ * Inside an existing `CopilotKitProvider` it uses that one instead, so a
+ * host's own CopilotKit hooks and these share one core.
+ */
+export declare function CopilotKitAgentProvider({ runtimeUrl, useSingleEndpoint, headers, credentials, properties, agents, agentId, forwardedProps, children, ...options }: CopilotKitAgentProviderProps): React.JSX.Element;
+export {};

package/dist/agent/copilotkit/CopilotKitAgentProvider.js

@@ -0,0 +1,145 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CopilotKitContext, CopilotKitCoreReact, useCopilotKit, } from "@copilotkit/react-core/v2/context";
+import { useAgent } from "@copilotkit/react-core/v2/headless";
+import * as React from "react";
+import { AgentHost } from "../AgentProvider.js";
+import { toolStandardSchema } from "../tool.js";
+/**
+ * The engine over CopilotKit's core: CopilotKit runs the agent, executes the
+ * browser's tools, makes follow-ups and carries context, so a host's own
+ * `useFrontendTool`, `useAgentContext` or `useHumanInTheLoop` calls keep
+ * working beside the ones registered here.
+ */
+export function createCopilotKitEngine(copilotkit, agent, invoke, agentId) {
+    let tools = [];
+    let context = [];
+    const clearTools = () => {
+        for (const name of tools)
+            copilotkit.removeTool(name, agentId);
+        tools = [];
+    };
+    const clearContext = () => {
+        for (const id of context)
+            copilotkit.removeContext(id);
+        context = [];
+    };
+    return {
+        agent,
+        async run({ forwardedProps, resume }) {
+            await copilotkit.runAgent({
+                agent,
+                ...(forwardedProps ? { forwardedProps } : {}),
+                ...(resume ? { resume } : {}),
+            });
+        },
+        stop() {
+            copilotkit.stopAgent({ agent });
+        },
+        setTools(next) {
+            clearTools();
+            // A render-only tool (available: false) draws the agent's own calls; CopilotKit must not run it.
+            for (const tool of next.filter((t) => t.available !== false)) {
+                copilotkit.addTool({
+                    name: tool.name,
+                    ...(tool.description !== undefined ? { description: tool.description } : {}),
+                    parameters: toolStandardSchema(tool),
+                    ...(tool.followUp !== undefined ? { followUp: tool.followUp } : {}),
+                    ...(agentId ? { agentId } : {}),
+                    handler: (args, ctx) => invoke(tool, args, {
+                        toolCallId: ctx.toolCall.id,
+                        signal: ctx.signal ?? new AbortController().signal,
+                    }),
+                });
+                tools.push(tool.name);
+            }
+        },
+        setContext(next) {
+            clearContext();
+            context = next.map((entry) => copilotkit.addContext({ ...entry, ...(agentId ? { agentIds: [agentId] } : {}) }));
+        },
+        dispose() {
+            clearTools();
+            clearContext();
+        },
+    };
+}
+function Bridge({ agentId, forwardedProps, options, children, }) {
+    const { copilotkit } = useCopilotKit();
+    // The view comes from the agent's events, so the hook need not re-render on each one.
+    const { agent } = useAgent({ ...(agentId ? { agentId } : {}), updates: [] });
+    const props = React.useRef(forwardedProps);
+    React.useEffect(() => {
+        props.current = forwardedProps;
+    });
+    return (_jsx(AgentHost, { engineKey: agent, createEngine: (invoke) => createCopilotKitEngine(copilotkit, agent, invoke, agentId), options: { ...options, forwardedProps: () => props.current }, children: children }));
+}
+const EMPTY = {};
+function transport(single) {
+    return single === true ? "single" : single === false ? "rest" : "auto";
+}
+/**
+ * CopilotKit's core for the tree, without CopilotKit's UI: the headless
+ * equivalent of its provider (no styled chat, no stylesheet, no inspector).
+ */
+function CopilotKitCoreHost({ runtimeUrl, useSingleEndpoint, headers: givenHeaders = EMPTY, credentials, properties: givenProperties = EMPTY, agents = EMPTY, onError, children, }) {
+    // Inline objects from the host keep their identity while their content does not change.
+    const headersKey = JSON.stringify(givenHeaders);
+    const propertiesKey = JSON.stringify(givenProperties);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const headers = React.useMemo(() => givenHeaders, [headersKey]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const properties = React.useMemo(() => givenProperties, [propertiesKey]);
+    const [copilotkit] = React.useState(() => new CopilotKitCoreReact({
+        runtimeUrl,
+        runtimeTransport: transport(useSingleEndpoint),
+        deferInitialConnection: true,
+        headers,
+        credentials,
+        properties,
+        agents__unsafe_dev_only: agents,
+    }));
+    const [executing, setExecuting] = React.useState(() => new Set());
+    React.useEffect(() => {
+        copilotkit.setRuntimeUrl(runtimeUrl);
+        copilotkit.setRuntimeTransport(transport(useSingleEndpoint));
+        copilotkit.setHeaders(headers);
+        copilotkit.setCredentials(credentials);
+        copilotkit.setProperties(properties);
+        copilotkit.setAgents__unsafe_dev_only(agents);
+        copilotkit.connect();
+    }, [copilotkit, runtimeUrl, useSingleEndpoint, headers, credentials, properties, agents]);
+    const onErrorRef = React.useRef(onError);
+    React.useEffect(() => {
+        onErrorRef.current = onError;
+    });
+    React.useEffect(() => {
+        const { unsubscribe } = copilotkit.subscribe({
+            onError: (event) => onErrorRef.current?.(event.error),
+            onToolExecutionStart: ({ toolCallId }) => setExecuting((prev) => new Set(prev).add(toolCallId)),
+            onToolExecutionEnd: ({ toolCallId }) => setExecuting((prev) => {
+                const next = new Set(prev);
+                next.delete(toolCallId);
+                return next;
+            }),
+        });
+        return unsubscribe;
+    }, [copilotkit]);
+    const value = React.useMemo(() => ({ copilotkit, executingToolCallIds: executing, showIntelligenceIndicator: false }), [copilotkit, executing]);
+    return _jsx(CopilotKitContext.Provider, { value: value, children: children });
+}
+/**
+ * The agent for a page tree, over a CopilotKit runtime (`runtimeUrl`, the
+ * route around `CopilotRuntime`). CopilotKit wires the runtime and runs the
+ * agent through its headless core; every pixel is the library's
+ * (`CalliopeAgent`, the chat kit), never CopilotKit's UI or stylesheet.
+ * Inside an existing `CopilotKitProvider` it uses that one instead, so a
+ * host's own CopilotKit hooks and these share one core.
+ */
+export function CopilotKitAgentProvider({ runtimeUrl, useSingleEndpoint, headers, credentials, properties, agents, agentId, forwardedProps, children, ...options }) {
+    const existing = React.useContext(CopilotKitContext);
+    const bridge = (_jsx(Bridge, { agentId: agentId, forwardedProps: forwardedProps, options: options, children: children }));
+    if (existing)
+        return bridge;
+    return (_jsx(CopilotKitCoreHost, { runtimeUrl, useSingleEndpoint, headers, credentials, properties, agents, ...(options.onError ? { onError: options.onError } : {}), children: bridge }));
+}

package/dist/agent/copilotkit/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `@calliopelabs/ui/agent/copilotkit`: the agent over a CopilotKit runtime.
+ * Needs `@copilotkit/react-core` (1.79.1 or later, 1.x) and `@ag-ui/client`;
+ * uses only CopilotKit's headless core, never its UI or stylesheet.
+ */
+export { CopilotKitAgentProvider, createCopilotKitEngine, type CopilotKitAgentProviderProps, } from "./CopilotKitAgentProvider.js";

package/dist/agent/copilotkit/index.js

@@ -0,0 +1,6 @@
+/**
+ * `@calliopelabs/ui/agent/copilotkit`: the agent over a CopilotKit runtime.
+ * Needs `@copilotkit/react-core` (1.79.1 or later, 1.x) and `@ag-ui/client`;
+ * uses only CopilotKit's headless core, never its UI or stylesheet.
+ */
+export { CopilotKitAgentProvider, createCopilotKitEngine, } from "./CopilotKitAgentProvider.js";