@copilotkit/vue 2.0.0-rc.0 → 2.0.0-rc.2

package/dist/v2/components/chat/message-feedback.d.ts

@@ -0,0 +1,89 @@
+import type { AssistantMessage } from "@ag-ui/core";
+import type { CopilotKitCore } from "@copilotkit/core";
+import type { ComputedRef, InjectionKey, Ref } from "vue";
+import type { MessageFeedback, MessageFeedbackRating } from "../../lib/message-feedback";
+/** The chat whose assistant messages collect feedback for Learning. */
+export interface MessageFeedbackScope {
+    readonly copilotkit: CopilotKitCore;
+    readonly agentId: string;
+    readonly threadId: string;
+}
+/**
+ * Provided by the message view while Learning is on for this chat. Assistant
+ * messages without it show thumbs only when the app passes its own handlers
+ * or thumb slots.
+ * @internal
+ */
+export declare const MessageFeedbackScopeKey: InjectionKey<Ref<MessageFeedbackScope | null>>;
+/**
+ * Whether the thumbs record feedback for Learning. True once a Trajectory of
+ * this Core has started and as long as Learning stays configured, also while
+ * capture reconnects or is stopped, so the buttons do not flicker. Ratings
+ * given meanwhile still show but, like any Trajectory event, are not sent.
+ * @internal
+ */
+export declare function useLearningFeedbackEnabled(copilotkit: Ref<CopilotKitCore>): ComputedRef<boolean>;
+/** Current feedback for one assistant message, and how to change it. */
+export interface MessageFeedbackControls {
+    readonly feedback: MessageFeedback | undefined;
+    /** Gives `rating`; a different rating than before starts without a comment. */
+    readonly rate: (rating: MessageFeedbackRating) => void;
+    /** Removes the rating and its comment. */
+    readonly clear: () => void;
+    /** Sets the current rating's comment; an empty one removes it. */
+    readonly comment: (comment: string) => void;
+}
+/** Feedback controls for `message`, or `null` when this chat collects none. */
+export declare function useMessageFeedback(message: Ref<AssistantMessage>): ComputedRef<MessageFeedbackControls | null>;
+/**
+ * How long the pointer may be away from the rating and its comment before the
+ * comment closes: enough to cross the gap between them, short enough that
+ * passing over a rating does not leave it open.
+ */
+export declare const FEEDBACK_COMMENT_CLOSE_DELAY_MS = 150;
+/** The comment popover of one rated message: when it shows and what it holds. */
+export interface FeedbackComment {
+    readonly open: Ref<boolean>;
+    /** The comment being edited. */
+    readonly draft: Ref<string>;
+    /** Grows each time the field should take focus: after a keyboard rating. */
+    readonly focusRequest: Ref<number>;
+    /** Whether a focus request waits; reading it answers the request. */
+    readonly takeFocusRequest: () => boolean;
+    /** The comment field, for moving focus into it. */
+    readonly input: Ref<HTMLInputElement | null>;
+    /** Opens with `comment` in the field. */
+    readonly show: (options: {
+        comment: string;
+        focus: boolean;
+    }) => void;
+    /** The pointer or focus reached the rating or the popover. */
+    readonly enter: (via?: "pointer" | "focus") => void;
+    /**
+     * It left them: close soon, unless the user is editing the comment or, when
+     * focus left, the pointer is still on the rating or the popover.
+     */
+    readonly leave: (via?: "pointer" | "focus") => void;
+    /** Tracks whether focus is in the comment form. */
+    readonly setEditing: (editing: boolean) => void;
+    /** Closes, saving a changed comment unless `save` is false. */
+    readonly close: (options?: {
+        save?: boolean;
+    }) => void;
+    /** Moves focus back to the thumb without opening the comment again. */
+    readonly returnFocus: (target: HTMLElement | null) => void;
+}
+/**
+ * Drives the comment popover of a rated message, as React's
+ * `useFeedbackComment` does.
+ *
+ * It opens when a rating is given and whenever the pointer or keyboard focus
+ * reaches the chosen thumb, with the saved comment in the field. It closes by
+ * itself shortly after the pointer leaves the thumb and the popover, unless
+ * focus is in the field: then it stays until focus moves away, Enter, or
+ * Escape. Closing saves a changed comment; Escape, a click on a thumb, and
+ * removing the rating discard it.
+ * @internal
+ */
+export declare function useFeedbackComment(controls: Ref<MessageFeedbackControls | null>): FeedbackComment;
+//# sourceMappingURL=message-feedback.d.ts.map

package/dist/v2/components/chat/message-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-feedback.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/chat/message-feedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAM1D,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AAEpC,uEAAuE;AACvE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAChD,GAAG,CAAC,oBAAoB,GAAG,IAAI,CAAC,CACO,CAAC;AAgB1C;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,GAC9B,WAAW,CAAC,OAAO,CAAC,CA4BtB;AAED,wEAAwE;AACxE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAC;IAC/C,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACvD,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,GAC7B,WAAW,CAAC,uBAAuB,GAAG,IAAI,CAAC,CA2C7C;AAED;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAEnD,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAC5B,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnC,qEAAqE;IACrE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,OAAO,CAAC;IACzC,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC7C,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IACtE,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,KAAK,IAAI,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,KAAK,IAAI,CAAC;IACpD,mDAAmD;IACnD,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAChD,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IACvD,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;CAC5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,GAC5C,eAAe,CAkGjB"}

package/dist/v2/components/chat/tool-call-capture.d.ts

@@ -0,0 +1,39 @@
+import type { PropType, Ref } from "vue";
+import type { CopilotKitCore } from "@copilotkit/core";
+/**
+ * Whether interaction capture is configured on the core. Driven by the
+ * learning config, not by the Trajectory, so a wrapper keyed on it does not
+ * remount the tool UI on every reconnect.
+ * @internal
+ */
+export declare function useLearningConfigured(copilotkit: Ref<CopilotKitCore>): Readonly<Ref<boolean>>;
+/**
+ * Wraps a tool call's UI in `data-tool-call-id` while learning is configured,
+ * so interaction capture can attribute clicks to the tool call. The wrapper
+ * uses `display: contents`, so it does not change the layout.
+ * @internal
+ */
+export declare const ToolCallCaptureScope: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    toolCallId: {
+        type: StringConstructor;
+        required: true;
+    };
+    enabled: {
+        type: PropType<boolean>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    toolCallId: {
+        type: StringConstructor;
+        required: true;
+    };
+    enabled: {
+        type: PropType<boolean>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=tool-call-capture.d.ts.map

package/dist/v2/components/chat/tool-call-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-capture.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/chat/tool-call-capture.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,GAC9B,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAexB;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;cAID,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;;;;cAAjB,QAAQ,CAAC,OAAO,CAAC;;;iGAe/C,CAAC"}

package/dist/v2/components/chat/tool-call-display-context.d.ts

@@ -0,0 +1,39 @@
+import type { ComputedRef, InjectionKey } from "vue";
+import type { CopilotChatToolCallDisplay, ToolCallLayout } from "./tool-call-layout";
+/**
+ * Provided by the message view so each message's tool calls follow the view's
+ * `toolCallDisplay` without every layer passing it along.
+ * @internal
+ */
+export interface ToolCallDisplayContextValue {
+    display: CopilotChatToolCallDisplay;
+    isRunning: boolean;
+    /** Each assistant message's tool calls, laid out across the whole list. */
+    layouts: ReadonlyMap<string, ToolCallLayout>;
+    /**
+     * `"turn"` display: for each message in a reply's working phase, whether
+     * that work is showing. Messages not in here are the reply itself.
+     */
+    workOpen: ReadonlyMap<string, boolean>;
+    /**
+     * Like `workOpen`, for the messages' text: text that ends the reply stays
+     * out of it even when its message also calls a tool.
+     */
+    workTextOpen: ReadonlyMap<string, boolean>;
+}
+/** @internal */
+export declare const ToolCallDisplayContextKey: InjectionKey<ComputedRef<ToolCallDisplayContextValue>>;
+/**
+ * Provided by a group around the calls it shows, so CopilotKit's built-in tool
+ * card draws itself as a compact row that fits the group instead of a card.
+ * @internal
+ */
+export interface ToolCallGroupContextValue {
+    appearance: "card" | "line" | "stack";
+    failedIds: ReadonlySet<string>;
+    /** The agent may still finish the group's calls; see `isActive`. */
+    active: boolean;
+}
+/** @internal */
+export declare const ToolCallGroupContextKey: InjectionKey<ComputedRef<ToolCallGroupContextValue | null>>;
+//# sourceMappingURL=tool-call-display-context.d.ts.map

package/dist/v2/components/chat/tool-call-display-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-display-context.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/chat/tool-call-display-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AACrD,OAAO,KAAK,EACV,0BAA0B,EAC1B,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,0BAA0B,CAAC;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,2EAA2E;IAC3E,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC7C;;;OAGG;IACH,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC;;;OAGG;IACH,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;AAED,gBAAgB;AAChB,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAClD,WAAW,CAAC,2BAA2B,CAAC,CACF,CAAC;AAEzC;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACtC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,oEAAoE;IACpE,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,gBAAgB;AAChB,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAChD,WAAW,CAAC,yBAAyB,GAAG,IAAI,CAAC,CACT,CAAC"}

package/dist/v2/components/chat/tool-call-group-parts.d.ts

@@ -0,0 +1,144 @@
+import type { PropType } from "vue";
+import type { ToolCallEntry } from "./tool-call-layout";
+/** A call that never got a result after the run ended (Stop, an error) is "stopped". */
+export type ToolCallStatusName = "running" | "done" | "failed" | "stopped";
+/**
+ * A call without a result is running only while the group is active: once
+ * the run has moved on or ended, its result is never coming.
+ * @internal
+ */
+export declare const entryStatus: ({ toolMessage }: ToolCallEntry, active: boolean) => ToolCallStatusName;
+/** @internal */
+export declare const statusLabels: Record<ToolCallStatusName, string>;
+/** The first non-empty string argument: usually a command, path or query. */
+export declare function argumentPreview(parameters: unknown): string | undefined;
+/** @internal */
+export declare const entryPreview: (entry: ToolCallEntry) => string | undefined;
+/** "run_command ×2, read_file" */
+export declare function toolNames(calls: ToolCallEntry[]): string;
+/** @internal */
+export declare const pluralize: (count: number, noun: string) => string;
+/**
+ * Height transition between closed and its content's height. Closed content
+ * stays mounted (so its state survives) but is inert.
+ * @internal
+ */
+export declare const CopilotChatCollapsible: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    id: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** @internal */
+export declare const ToolCallStatusIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    status: {
+        type: PropType<ToolCallStatusName>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    status: {
+        type: PropType<ToolCallStatusName>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** @internal */
+export declare const ToolCallChevron: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** "2 failed", or nothing. @internal */
+export declare const ToolCallFailedCount: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    calls: {
+        type: PropType<ToolCallEntry[]>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    calls: {
+        type: PropType<ToolCallEntry[]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * The built-in tool card drawn as a row inside a group: status, name and main
+ * argument, opening to the payloads.
+ * @internal
+ */
+export declare const ToolCallRow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    parameters: {
+        type: null;
+        default: undefined;
+    };
+    result: {
+        type: null;
+        default: undefined;
+    };
+    status: {
+        type: PropType<ToolCallStatusName>;
+        required: true;
+    };
+    appearance: {
+        type: PropType<"card" | "line" | "stack">;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    parameters: {
+        type: null;
+        default: undefined;
+    };
+    result: {
+        type: null;
+        default: undefined;
+    };
+    status: {
+        type: PropType<ToolCallStatusName>;
+        required: true;
+    };
+    appearance: {
+        type: PropType<"card" | "line" | "stack">;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    parameters: any;
+    result: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=tool-call-group-parts.d.ts.map

package/dist/v2/components/chat/tool-call-group-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-group-parts.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/chat/tool-call-group-parts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAUpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,wFAAwF;AACxF,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,WAAW,GACtB,iBAAiB,aAAa,EAC9B,QAAQ,OAAO,KACd,kBAOc,CAAC;AAElB,gBAAgB;AAChB,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAK3D,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAMvE;AAED,gBAAgB;AAChB,eAAO,MAAM,YAAY,GAAI,OAAO,aAAa,uBACqB,CAAC;AAEvE,kCAAkC;AAClC,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,MAAM,CASxD;AAED,gBAAgB;AAChB,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,EAAE,MAAM,MAAM,WACR,CAAC;AAuB9C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;4EAwBjC,CAAC;AAEH,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;cAIT,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;cAA5B,QAAQ,CAAC,kBAAkB,CAAC;;;iGAuBhD,CAAC;AAEH,gBAAgB;AAChB,eAAO,MAAM,eAAe;;;;;;;;;;;;iGAa1B,CAAC;AAEH,wCAAwC;AACxC,eAAO,MAAM,mBAAmB;;cAGJ,QAAQ,CAAC,aAAa,EAAE,CAAC;;;;;;;cAAzB,QAAQ,CAAC,aAAa,EAAE,CAAC;;;iGAenD,CAAC;AASH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;cAOF,QAAQ,CAAC,kBAAkB,CAAC;;;;cAI5B,QAAQ,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;;;;;;;;;;;;;;;;;;;cAJnC,QAAQ,CAAC,kBAAkB,CAAC;;;;cAI5B,QAAQ,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;;;;;;4EA+EvD,CAAC"}

package/dist/v2/components/chat/tool-call-layout.d.ts

@@ -0,0 +1,115 @@
+import type { Message, ToolCall, ToolMessage } from "@ag-ui/core";
+/**
+ * How the chat shows tool calls.
+ *
+ * - `"grouped"` (default): calls made in a row share one card, collapsed to a
+ *   summary ("Used 3 tools") that opens to a row per call.
+ * - `"line"`: the same grouping as a quiet line of text, like the reasoning
+ *   message's "Thought for 4 seconds".
+ * - `"stacked"`: the latest call on top of a stack of the earlier ones; click
+ *   to fan the stack out into its cards.
+ * - `"turn"`: the agent works in the open (narration, then a row per call),
+ *   and when the reply is done everything before it folds into "Worked for 9s".
+ * - `"separate"`: every call gets its own card, as before grouping existed.
+ *
+ * Only calls drawn by a renderer that opts into grouping (`group: true`) are
+ * grouped; CopilotKit's built-in card from `useDefaultRenderTool()` does. Any
+ * other call always shows on its own and splits the group around it.
+ */
+export type CopilotChatToolCallDisplay = "grouped" | "line" | "stacked" | "turn" | "separate";
+/** One tool call and, once it has finished, the message carrying its result. */
+export interface ToolCallEntry {
+    toolCall: ToolCall;
+    toolMessage?: ToolMessage;
+}
+export type ToolCallSegment = 
+/** Consecutive calls drawn by renderers that opted into grouping. */
+{
+    kind: "group";
+    id: string;
+    calls: ToolCallEntry[];
+    /** Nothing renders after this group yet, so a running agent may add to it. */
+    trailing: boolean;
+}
+/**
+ * A call drawn by a renderer that didn't opt into grouping, or with no
+ * renderer at all. The latter renders nothing (and warns in development)
+ * without breaking a group.
+ */
+ | {
+    kind: "call";
+    id: string;
+    call: ToolCallEntry;
+    rendered: boolean;
+};
+/** What one assistant message's tool-call area renders. */
+export interface ToolCallLayout {
+    segments: ToolCallSegment[];
+    /** Changes whenever anything this layout renders changes; for memoization. */
+    signature: string;
+}
+/** Which tool-call renderers are registered. */
+export interface ToolCallRendererNames {
+    /** Tool names with a renderer of their own. */
+    named: ReadonlySet<string>;
+    /** Of those, the ones whose renderer opted into grouping. */
+    groupedNames: ReadonlySet<string>;
+    /** A wildcard (`"*"`) renderer is registered. */
+    wildcard: boolean;
+    /** The wildcard renderer opted into grouping (the built-in card does). */
+    wildcardGroups: boolean;
+}
+/** Index of tool results by the call they answer. */
+export declare function getToolResults(messages: Message[]): Map<string, ToolMessage>;
+/**
+ * Lays out the tool calls of every assistant message in `rendered`.
+ *
+ * Calls drawn by a renderer that opted into grouping join the group that's
+ * open; anything else that shows between them closes it: assistant text, a
+ * user, reasoning or activity message, or a call drawn by any other renderer. A group belongs to
+ * the message where it starts, so later messages whose calls joined it render
+ * no tool calls themselves.
+ *
+ * @param rendered - The messages as the chat renders them, in order.
+ * @param all - Every message, for finding tool results (a transform may hide them).
+ * @param renderers - The registered renderers.
+ */
+export declare function getToolCallLayouts(rendered: Message[], all: Message[], renderers: ToolCallRendererNames): Map<string, ToolCallLayout>;
+/**
+ * Which renderers draw tool calls, from the registered renderers and the
+ * view's tool-call slots. A slot wins over a registered renderer and never
+ * groups, since the chat can't tell what it draws: `#tool-call-<name>` takes
+ * that tool, and `#tool-call` takes every tool.
+ *
+ * @param renderers - The registered renderers (`copilotkit.renderToolCalls`).
+ * @param slotNames - The names of the slots the view was given.
+ */
+export declare function getToolCallRendererNames(renderers: readonly {
+    name: string;
+    group?: boolean;
+}[], slotNames?: readonly string[]): ToolCallRendererNames;
+/** A reply's working phase, for the `"turn"` display. */
+export interface TurnWork {
+    /** Stable across the turn's life: the id of the user message it answers. */
+    key: string;
+    /** The first assistant-side message, where the "Worked for" line goes. */
+    firstMessageId: string;
+    /** Everything up to and including the last message with a tool call. */
+    workMessageIds: ReadonlySet<string>;
+    /**
+     * The reply's last assistant message, when it has text and is part of the
+     * work (it also calls a tool). Its text is the answer, so it stays out.
+     */
+    replyTextMessageId?: string;
+    calls: ToolCallEntry[];
+    /** No user message follows, so the agent may still be working on it. */
+    isLatest: boolean;
+}
+/**
+ * Finds the working phase of every reply in `rendered`: its messages up to the
+ * last one that calls a tool. Text in there was narration; what follows is the
+ * reply itself. Replies that called no tools are omitted, except the latest,
+ * which may be about to.
+ */
+export declare function getTurnWork(rendered: Message[], layouts: ReadonlyMap<string, ToolCallLayout>): Map<string, TurnWork>;
+//# sourceMappingURL=tool-call-layout.d.ts.map

package/dist/v2/components/chat/tool-call-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-layout.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/chat/tool-call-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,0BAA0B,GAClC,SAAS,GACT,MAAM,GACN,SAAS,GACT,MAAM,GACN,UAAU,CAAC;AAEf,gFAAgF;AAChF,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,MAAM,MAAM,eAAe;AACzB,qEAAqE;AACnE;IACE,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,EAAE,OAAO,CAAC;CACnB;AACH;;;;GAIG;GACD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzE,2DAA2D;AAC3D,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,gDAAgD;AAChD,MAAM,WAAW,qBAAqB;IACpC,+CAA+C;IAC/C,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,6DAA6D;IAC7D,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,iDAAiD;IACjD,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,cAAc,EAAE,OAAO,CAAC;CACzB;AA4BD,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAM5E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,OAAO,EAAE,EACd,SAAS,EAAE,qBAAqB,GAC/B,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAuD7B;AAID;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,EACvD,SAAS,GAAE,SAAS,MAAM,EAAO,GAChC,qBAAqB,CAuBvB;AAED,yDAAyD;AACzD,MAAM,WAAW,QAAQ;IACvB,4EAA4E;IAC5E,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,cAAc,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,wEAAwE;IACxE,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAC3C,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CA6DvB"}

package/dist/v2/components/chat/turn-work.d.ts

@@ -0,0 +1,35 @@
+import type { FunctionalComponent } from "vue";
+/** "45s", "1m 5s", "2m". Used for the live timer and the final duration. */
+export declare function formatDuration(ms: number): string;
+/**
+ * Folds its content away with a reply's work in the `"turn"` display. Without
+ * `open` (any other display) it renders the content as is.
+ * @internal
+ */
+export declare const TurnWorkFold: FunctionalComponent<{
+    open?: boolean;
+}>;
+/**
+ * In the `"turn"` tool-call display, text in a reply's working phase was
+ * narration: it fades to muted once a call follows it, and folds away with the
+ * rest of the work when the reply is done. The wrapper is there for every
+ * message in that display, so text that turns into narration keeps its node
+ * (and its place) rather than remounting.
+ * @internal
+ */
+export declare const CopilotChatWorkText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    messageId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    messageId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=turn-work.d.ts.map

package/dist/v2/components/chat/turn-work.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-work.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/chat/turn-work.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,KAAK,CAAC;AAI/C,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,mBAAmB,CAAC;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAML,CAAC;AAG7D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iGAwB9B,CAAC"}

package/dist/v2/components/chat/types.d.ts

@@ -1,16 +1,58 @@
 import type { AssistantMessage, Message, ReasoningMessage, ToolCall, ToolMessage, UserMessage } from "@ag-ui/core";
+import type { VNode } from "vue";
 import type { CopilotKitCoreErrorCode, ToolCallStatus } from "@copilotkit/core";
 import type { Suggestion } from "@copilotkit/core";
-import type { Attachment, AttachmentsConfig, AttachmentModality } from "@copilotkit/shared";
+import type { Attachment, AttachmentsConfig, AttachmentModality, InputContentSource } from "@copilotkit/shared";
 import type { CopilotChatLabels } from "../../providers/types";
 import type { InterruptEvent } from "../../types";
 import type { AutoScrollMode } from "./normalize-auto-scroll";
+import type { CopilotChatToolCallDisplay, ToolCallEntry } from "./tool-call-layout";
 export type CopilotChatInputMode = "input" | "transcribe" | "processing";
 export type { Attachment, AttachmentsConfig, AttachmentModality };
 export type { AutoScrollMode };
+export type { CopilotChatToolCallDisplay, ToolCallEntry };
+/** How a `CopilotChatToolCallGroup` draws its calls. */
+export type CopilotChatToolCallGroupAppearance = "card" | "line" | "stack";
+/** Props of the `#tool-calls-group` slot, which replaces a group of calls. */
+export interface CopilotChatToolCallsGroupSlotProps {
+    /** The calls in the group, in order. */
+    calls: ToolCallEntry[];
+    /** The appearance the view's `toolCallDisplay` asks for. */
+    appearance: CopilotChatToolCallGroupAppearance;
+    /** The agent is running and nothing follows the group, so more calls may join it. */
+    isActive: boolean;
+    /**
+     * Draws one call through the registered renderers and tool-call slots.
+     * Render the VNode with `<component :is="renderCall(call)" />`.
+     */
+    renderCall: (call: ToolCallEntry) => VNode;
+}
+/**
+ * Props of `CopilotChatWorkSummary` and of the `#work-summary` slot, which
+ * replaces the "Working… / Worked for 9s" line of the `"turn"` display.
+ */
+export interface CopilotChatWorkSummarySlotProps {
+    /** The agent is still working on this reply. */
+    isWorking: boolean;
+    /** Whether the work (narration and tool calls) is showing. */
+    isOpen: boolean;
+    /** The tool calls the reply made. */
+    calls: ToolCallEntry[];
+    /**
+     * How long the agent has worked on the reply, in ms, summed over its runs
+     * so time spent waiting between them doesn't count. Only known for replies
+     * this client watched start; without it the summary shows the tool count.
+     */
+    elapsedMs?: number;
+    /** When the current run started (epoch ms), while the agent is working. */
+    workingSince?: number;
+    /** Opens or closes the reply's work. */
+    onClick: () => void;
+}
 export interface CopilotChatAttachmentRendererProps {
     type: AttachmentModality;
-    source: Attachment["source"];
+    /** Any AG-UI content source, as in React; a `file` handle shows no preview. */
+    source: InputContentSource;
     filename?: string;
     className?: string;
 }
@@ -76,6 +118,20 @@ export interface CopilotChatViewProps {
     onDragLeave?: (event: DragEvent) => void;
     onDrop?: (event: DragEvent) => void;
     onFinishTranscribeWithAudio?: (audioBlob: Blob) => void | Promise<void>;
+    /**
+     * How tool calls show. Defaults to `"grouped"`: calls made in a row share
+     * one card that opens to a row per call. `"line"` and `"stacked"` group
+     * them too; `"separate"` gives every call its own card. Calls drawn by a
+     * renderer that does not set `group: true`, or by a tool-call slot, always
+     * show on their own.
+     */
+    toolCallDisplay?: CopilotChatToolCallDisplay;
+    /**
+     * Whether reply thumbs record ratings for Automatic Learning once a
+     * Trajectory has started. Defaults to `true`; set `false` to keep the
+     * thumbs to your own `thumbs-up` / `thumbs-down` handlers and slots.
+     */
+    messageFeedback?: boolean;
 }
 export interface CopilotChatProps extends Omit<CopilotChatViewProps, "messages" | "isRunning" | "suggestions" | "suggestionLoadingIndexes" | "attachments" | "onRemoveAttachment" | "onAddFile" | "dragOver" | "onDragOver" | "onDragLeave" | "onDrop" | "onSubmitMessage" | "onStop" | "onInputChange" | "onSelectSuggestion" | "onStartTranscribe" | "onCancelTranscribe" | "onFinishTranscribe"> {
     agentId?: string;
@@ -247,12 +303,52 @@ export interface CopilotChatAssistantMessageCopyButtonSlotProps {
     copied: boolean;
     label: string;
 }
+/**
+ * Attributes and listeners that let a thumb record a Learning rating and open
+ * its comment popover. Bind them on the thumb's `<button>` with `v-bind`;
+ * they are empty while the chat records no ratings.
+ */
+export type CopilotChatAssistantMessageThumbProps = Record<string, unknown>;
 export interface CopilotChatAssistantMessageThumbsUpButtonSlotProps {
-    onThumbsUp: () => void;
+    /**
+     * Rates the reply. Pass the click event, so the comment points at the
+     * clicked thumb and a keyboard click moves focus into it.
+     */
+    onThumbsUp: (event?: MouseEvent) => void;
     label: string;
+    /** This rating is the chosen one (Learning only). */
+    pressed: boolean;
+    thumbProps: CopilotChatAssistantMessageThumbProps;
 }
 export interface CopilotChatAssistantMessageThumbsDownButtonSlotProps {
-    onThumbsDown: () => void;
+    /** See {@link CopilotChatAssistantMessageThumbsUpButtonSlotProps.onThumbsUp}. */
+    onThumbsDown: (event?: MouseEvent) => void;
+    label: string;
+    /** This rating is the chosen one (Learning only). */
+    pressed: boolean;
+    thumbProps: CopilotChatAssistantMessageThumbProps;
+}
+/** Props of the `feedback-comment` slot: the comment field of a rating. */
+export interface CopilotChatAssistantMessageFeedbackCommentSlotProps {
+    value: string;
+    /** The comment already saved. */
+    savedComment: string;
+    /** Bind as `:ref` on the text field, so a keyboard rating can focus it. */
+    inputRef: (element: unknown) => void;
+    onChange: (value: string) => void;
+    /** Saves the comment, closes the popover and returns focus to the thumb. */
+    onSubmit: () => void;
+    onEditingChange: (editing: boolean) => void;
+    /**
+     * Focus left the form for `next`, or for no focusable element when null.
+     * Not called when the window loses focus.
+     */
+    onLeave: (next: Element | null) => void;
+}
+/** Props of the `inspector-button` slot. */
+export interface CopilotChatAssistantMessageInspectorButtonSlotProps {
+    /** Opens this message in the Inspector. */
+    onInspect: () => void;
     label: string;
 }
 export interface CopilotChatAssistantMessageReadAloudButtonSlotProps {
@@ -381,6 +477,8 @@ export interface CopilotSidebarViewToggleButtonSlotProps {
 export interface CopilotSidebarViewProps extends CopilotChatViewProps {
     width?: number | string;
     defaultOpen?: boolean;
+    /** The edge the sidebar docks to. Defaults to `"right"`. */
+    position?: "left" | "right";
 }
 export type CopilotPopupViewHeaderSlotProps = CopilotSidebarViewHeaderSlotProps;
 export type CopilotPopupViewToggleButtonSlotProps = CopilotSidebarViewToggleButtonSlotProps;
@@ -403,5 +501,7 @@ export interface CopilotPopupProps extends CopilotChatProps {
 export interface CopilotSidebarProps extends CopilotChatProps {
     width?: number | string;
     defaultOpen?: boolean;
+    /** The edge the sidebar docks to. Defaults to `"right"`. */
+    position?: CopilotSidebarViewProps["position"];
 }
 //# sourceMappingURL=types.d.ts.map