@copilotkit/core 2.0.0-rc.26 → 2.0.0-rc.27

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,9 +1,9 @@
1
- import * as _copilotkit_learning0 from "@copilotkit/learning";
2
- import { CaptureOptions, CollectorOptions, JsonValue, JsonValue as JsonValue$1, StartResult, StartResult as StartResult$1, TrajectoryCaptureOptions } from "@copilotkit/learning";
3
1
  import * as _ag_ui_client0 from "@ag-ui/client";
4
- import { AbstractAgent, ActivityMessage, AgentCapabilities, AgentSubscriber, BaseEvent, Context, HttpAgent, HttpAgentConfig, Interrupt, Message, ResumeEntry, RunAgentInput, RunAgentParameters, RunAgentResult, State, Tool, ToolCall } from "@ag-ui/client";
2
+ import { AbstractAgent, ActivityMessage, AgentCapabilities, AgentSubscriber, BaseEvent, ContentPart, Context, HttpAgent, HttpAgentConfig, Interrupt, Message, ResumeEntry, RunAgentInput, RunAgentParameters, RunAgentResult, State, Tool, ToolCall } from "@ag-ui/client";
5
3
  import { A2UIOperation, Attachment, AttachmentsConfig, AudioInputPart, CopilotKitUIEnvelope, DebugConfig, DocumentInputPart, GenerativeUIComponentManifest, GenerativeUIJSONSchema, GenerativeUIRejectedOperation, GenerativeUISurfaceStatus, GenerativeUITarget, ImageInputPart, InspectorMetadataV1, InspectorMetadataV1 as InspectorMetadataV1$1, IntelligenceRuntimeInfo, IntelligenceRuntimeInfo as IntelligenceRuntimeInfo$1, LicenseContextValue, ResolvedDebugConfig, RuntimeEntitlementResponse, RuntimeInfo, RuntimeLicenseStatus, RuntimeLicenseStatus as RuntimeLicenseStatus$1, RuntimeMode, RuntimeMode as RuntimeMode$1, StandardJSONSchemaV1, StandardSchemaV1, ThreadEndpointRuntimeInfo, ThreadEndpointRuntimeInfo as ThreadEndpointRuntimeInfo$1, TranscriptionErrorCode, VideoInputPart } from "@copilotkit/shared";
6
4
  import { Observable, OperatorFunction, Subscription } from "rxjs";
5
+ import * as _copilotkit_learning0 from "@copilotkit/learning";
6
+ import { CaptureOptions, CollectorOptions, JsonValue, JsonValue as JsonValue$1, StartResult, StartResult as StartResult$1, TrajectoryCaptureOptions } from "@copilotkit/learning";
7
7
  import * as _ag_ui_core0 from "@ag-ui/core";
8
8
  import { AgentCapabilities as AgentCapabilities$1, AssistantMessage, Message as Message$1, ToolCall as ToolCall$1, ToolMessage, UserMessage } from "@ag-ui/core";
9
9
  import * as _standard_schema_spec0 from "@standard-schema/spec";
@@ -1614,7 +1614,7 @@ declare class ɵAgentResolver {
1614
1614
  runtimeAgentId,
1615
1615
  caller
1616
1616
  }: ɵAgentResolveInput): {
1617
- agent: ProxiedCopilotRuntimeAgent | AbstractAgent;
1617
+ agent: AbstractAgent | ProxiedCopilotRuntimeAgent;
1618
1618
  isReady: boolean;
1619
1619
  };
1620
1620
  /**
@@ -1826,12 +1826,15 @@ interface ɵRendererRegistryInit<TTool, TActivity, TCustom> {
1826
1826
  * Holds the renderers of one provider and tells subscribers when a list
1827
1827
  * changes.
1828
1828
  *
1829
- * Tool-call renderers come from two places. Prop renderers are the list the
1829
+ * Tool-call renderers come from three places. Prop renderers are the list the
1830
1830
  * provider was given (`setPropToolCalls`). Hook renderers are added one at a
1831
- * time (`addHookToolCall`), for example by `useRenderTool`. Each renderer has
1832
- * a key made of its `agentId` and `name`. A hook renderer replaces a prop
1833
- * renderer with the same key, and a later hook renderer replaces an earlier
1834
- * one with the same key, so the latest registration wins.
1831
+ * time (`addHookToolCall`), for example by `useRenderTool`. Built-in
1832
+ * renderers are added by CopilotKit features such as A2UI
1833
+ * (`addBuiltInToolCall`). Each renderer has a key made of its `agentId` and
1834
+ * `name`. A hook renderer replaces a prop renderer with the same key, and a
1835
+ * later hook renderer replaces an earlier one with the same key, so the
1836
+ * latest registration wins. A built-in renderer shows only when no prop or
1837
+ * hook renderer has its key, so an app can always replace it.
1835
1838
  *
1836
1839
  * Fields are TypeScript `private`, not `#private`, so the registry keeps
1837
1840
  * working behind a Vue reactive proxy.
@@ -1858,6 +1861,7 @@ declare class ɵRendererRegistry<TTool extends {
1858
1861
  }, TActivity, TCustom> {
1859
1862
  private _propToolCalls;
1860
1863
  private _hookToolCalls;
1864
+ private _builtInToolCalls;
1861
1865
  private _mergedToolCalls;
1862
1866
  private _activity;
1863
1867
  private _custom;
@@ -1866,9 +1870,10 @@ declare class ɵRendererRegistry<TTool extends {
1866
1870
  /** The prop renderers, as last set. */
1867
1871
  get propToolCalls(): readonly TTool[];
1868
1872
  /**
1869
- * Every tool-call renderer: prop renderers, then hook renderers, with one
1870
- * entry per `agentId` + `name` key. A prop renderer that a hook renderer
1871
- * replaces keeps its position in the list.
1873
+ * Every tool-call renderer: prop renderers, then hook renderers, then
1874
+ * built-in renderers, with one entry per `agentId` + `name` key. A prop
1875
+ * renderer that a hook renderer replaces keeps its position in the list. A
1876
+ * built-in renderer is left out when a prop or hook renderer has its key.
1872
1877
  */
1873
1878
  get toolCalls(): readonly TTool[];
1874
1879
  get activity(): readonly TActivity[];
@@ -1897,6 +1902,34 @@ declare class ɵRendererRegistry<TTool extends {
1897
1902
  * renderer with no `agentId`.
1898
1903
  */
1899
1904
  removeHookToolCall(name: string, agentId?: string): void;
1905
+ /**
1906
+ * Remove the prop and hook renderers for `name` and `agentId`. Built-in
1907
+ * renderers stay. Does nothing when no such renderer exists.
1908
+ *
1909
+ * @param name - The tool name.
1910
+ * @param agentId - The agent the renderers belong to. Omit it for
1911
+ * renderers with no `agentId`.
1912
+ */
1913
+ removeToolCall(name: string, agentId?: string): void;
1914
+ /**
1915
+ * Add a built-in renderer, for a tool that a CopilotKit feature owns (for
1916
+ * example the A2UI render tool). Prop and hook renderers with the same
1917
+ * `agentId` and `name` win over it, and setting the prop renderers never
1918
+ * removes it.
1919
+ *
1920
+ * @param entry - The renderer to add. It replaces an earlier built-in
1921
+ * renderer with the same key.
1922
+ * @returns A function that removes this renderer, if it is still the
1923
+ * built-in renderer for its key. Calling it more than once does nothing.
1924
+ *
1925
+ * @example
1926
+ * ```ts
1927
+ * const remove = registry.addBuiltInToolCall({ name: "render_a2ui", render: Nothing });
1928
+ * // when the feature turns off
1929
+ * remove();
1930
+ * ```
1931
+ */
1932
+ addBuiltInToolCall(entry: TTool): () => void;
1900
1933
  /**
1901
1934
  * Replace the activity message renderers.
1902
1935
  *
@@ -2663,6 +2696,186 @@ interface ɵToolRendererShape {
2663
2696
  * ɵtoolRendererShapeChanged([{ name: "a" }], [{ name: "b" }]); // true
2664
2697
  */
2665
2698
  declare function ɵtoolRendererShapeChanged(previous: readonly ɵToolRendererShape[], next: readonly ɵToolRendererShape[]): boolean;
2699
+ /** @internal A provider array prop that must keep its identity. */
2700
+ type ɵStableArrayProp = keyof typeof ɵSTABLE_ARRAY_WARNINGS;
2701
+ /**
2702
+ * @internal The warning for a provider array prop that changed after mount,
2703
+ * or `undefined` when the change is fine.
2704
+ *
2705
+ * `renderToolCalls` warns only when its shape changes (see
2706
+ * {@link ɵtoolRendererShapeChanged}), so new render closures for the same
2707
+ * tools are fine. Every other prop warns on a new array.
2708
+ *
2709
+ * @param prop - Which prop changed.
2710
+ * @param initial - The value at mount. `undefined` counts as an empty list.
2711
+ * @param next - The new value.
2712
+ *
2713
+ * @example
2714
+ * const warning = ɵstableArrayPropWarning("frontendTools", initial, next);
2715
+ * if (warning) console.error(warning);
2716
+ */
2717
+ declare function ɵstableArrayPropWarning(prop: ɵStableArrayProp, initial: readonly unknown[] | undefined, next: readonly unknown[] | undefined): string | undefined;
2718
+ /** @internal A tool-call renderer the provider builds from a tool. */
2719
+ interface ɵProviderToolRenderer<TRender> {
2720
+ name: string;
2721
+ args: unknown;
2722
+ render: TRender;
2723
+ agentId?: string;
2724
+ }
2725
+ type AnyFrontendTool$1 = FrontendTool<any>;
2726
+ /** @internal A provider `frontendTools` entry, with its framework render. */
2727
+ type ɵProviderFrontendTool<TRender> = AnyFrontendTool$1 & {
2728
+ render?: TRender;
2729
+ };
2730
+ /** @internal A provider `humanInTheLoop` entry, with its framework render. */
2731
+ type ɵProviderHumanInTheLoop<THitlRender> = Omit<AnyFrontendTool$1, "handler" | "type"> & {
2732
+ render?: THitlRender;
2733
+ };
2734
+ /** @internal The input of {@link ɵassembleProviderRegistry}. */
2735
+ interface ɵProviderRegistryInput<TRenderer, TRender, THitlRender> {
2736
+ /** The provider's `renderToolCalls`. They come first, unchanged. */
2737
+ renderToolCalls?: readonly TRenderer[];
2738
+ /** The provider's `frontendTools`. */
2739
+ frontendTools?: readonly ɵProviderFrontendTool<TRender>[];
2740
+ /** Tools a built-in feature adds, such as Open Generative UI. */
2741
+ builtInFrontendTools?: readonly ɵProviderFrontendTool<TRender>[];
2742
+ /** The provider's `humanInTheLoop`. */
2743
+ humanInTheLoop?: readonly ɵProviderHumanInTheLoop<THitlRender>[];
2744
+ /**
2745
+ * The registry that parks human-in-the-loop calls. Pass a getter when the
2746
+ * core does not exist yet.
2747
+ */
2748
+ humanInTheLoopRegistry: ɵHumanInTheLoopRegistry | (() => ɵHumanInTheLoopRegistry);
2749
+ /**
2750
+ * Wrap a human-in-the-loop render into a tool-call render. The wrapper
2751
+ * passes `ɵhitlRenderProps(props, tool, registry())` to `render`.
2752
+ */
2753
+ wrapHumanInTheLoopRender: (render: THitlRender, tool: ɵProviderHumanInTheLoop<THitlRender>, registry: () => ɵHumanInTheLoopRegistry) => TRender;
2754
+ }
2755
+ /**
2756
+ * @internal Build the tool list and the tool-call renderer list of a
2757
+ * provider from its props.
2758
+ *
2759
+ * - Tools: `frontendTools`, then `builtInFrontendTools`, then one tool per
2760
+ * `humanInTheLoop` entry (see `ɵbuildHumanInTheLoopTool`).
2761
+ * - Renderers: `renderToolCalls`, then one renderer per frontend tool with a
2762
+ * `render`, then one per human-in-the-loop entry with a `render`. A tool
2763
+ * renderer keeps the tool's `agentId`. A frontend tool without
2764
+ * `parameters` gets a renderer only when it is the `"*"` wildcard, which
2765
+ * then accepts any arguments.
2766
+ *
2767
+ * @example
2768
+ * const { tools, renderToolCalls } = ɵassembleProviderRegistry({
2769
+ * renderToolCalls: props.renderToolCalls,
2770
+ * frontendTools: props.frontendTools,
2771
+ * humanInTheLoop: props.humanInTheLoop,
2772
+ * humanInTheLoopRegistry: () => core.ɵhumanInTheLoop,
2773
+ * wrapHumanInTheLoopRender: (Render, tool, registry) => (props) =>
2774
+ * <Render {...ɵhitlRenderProps(props, tool, registry())} />,
2775
+ * });
2776
+ */
2777
+ declare function ɵassembleProviderRegistry<TRenderer, TRender, THitlRender>(input: ɵProviderRegistryInput<TRenderer, TRender, THitlRender>): {
2778
+ tools: FrontendTool[];
2779
+ renderToolCalls: Array<TRenderer | ɵProviderToolRenderer<TRender>>;
2780
+ };
2781
+ /** @internal The tools and renderers that a provider's `humanInTheLoop` gives. */
2782
+ interface ɵAssembledHumanInTheLoop<TRender> {
2783
+ tools: FrontendTool[];
2784
+ renderToolCalls: ɵProviderToolRenderer<TRender>[];
2785
+ }
2786
+ /**
2787
+ * @internal The human-in-the-loop part of {@link ɵassembleProviderRegistry}:
2788
+ * one tool per `humanInTheLoop` entry, and one renderer per entry with a
2789
+ * `render`.
2790
+ *
2791
+ * Each call wraps every render again, and a new wrapper is a new component
2792
+ * type to React and Vue, so the card remounts. Adapters memoize this result
2793
+ * on `humanInTheLoop` alone, and pass it to {@link ɵassembleProviderTools}
2794
+ * and {@link ɵassembleProviderToolRenderers}.
2795
+ */
2796
+ declare function ɵassembleHumanInTheLoop<TRender, THitlRender>(input: Pick<ɵProviderRegistryInput<unknown, TRender, THitlRender>, "humanInTheLoop" | "humanInTheLoopRegistry" | "wrapHumanInTheLoopRender">): ɵAssembledHumanInTheLoop<TRender>;
2797
+ /**
2798
+ * @internal The tool list of {@link ɵassembleProviderRegistry}:
2799
+ * `frontendTools`, then `builtInFrontendTools`, then the human-in-the-loop
2800
+ * tools. It does not read `renderToolCalls`.
2801
+ */
2802
+ declare function ɵassembleProviderTools(input: {
2803
+ frontendTools?: readonly AnyFrontendTool$1[];
2804
+ builtInFrontendTools?: readonly AnyFrontendTool$1[];
2805
+ humanInTheLoop: Pick<ɵAssembledHumanInTheLoop<unknown>, "tools">;
2806
+ }): FrontendTool[];
2807
+ /**
2808
+ * @internal The renderer list of {@link ɵassembleProviderRegistry}:
2809
+ * `renderToolCalls`, then one renderer per frontend tool with a `render`,
2810
+ * then the human-in-the-loop renderers, which keep their identity.
2811
+ */
2812
+ declare function ɵassembleProviderToolRenderers<TRenderer, TRender>(input: {
2813
+ renderToolCalls?: readonly TRenderer[];
2814
+ frontendTools?: readonly ɵProviderFrontendTool<TRender>[];
2815
+ builtInFrontendTools?: readonly ɵProviderFrontendTool<TRender>[];
2816
+ humanInTheLoop: Pick<ɵAssembledHumanInTheLoop<TRender>, "renderToolCalls">;
2817
+ }): Array<TRenderer | ɵProviderToolRenderer<TRender>>;
2818
+ /** @internal The input of {@link ɵresolveA2UIActivation}. */
2819
+ interface ɵA2UIActivationInput {
2820
+ /** The runtime reports `a2uiEnabled`. */
2821
+ runtimeEnabled: boolean;
2822
+ /** The provider has an `a2ui.catalog`. */
2823
+ hasCatalog: boolean;
2824
+ /**
2825
+ * Keep A2UI off without a catalog, even when the runtime enables it.
2826
+ * Angular sets it: it has no default catalog to render surfaces with.
2827
+ */
2828
+ requireCatalog?: boolean;
2829
+ }
2830
+ /**
2831
+ * @internal Whether the provider turns on A2UI: its built-in renderers and
2832
+ * its agent context.
2833
+ *
2834
+ * A2UI is active when the runtime enables it or the provider has a catalog.
2835
+ * With `requireCatalog`, only a catalog turns it on. `missingCatalog` is
2836
+ * true when the runtime enables A2UI but `requireCatalog` keeps it off;
2837
+ * the provider should tell the developer to configure a catalog.
2838
+ *
2839
+ * @example
2840
+ * ɵresolveA2UIActivation({ runtimeEnabled: true, hasCatalog: false });
2841
+ * // { active: true, missingCatalog: false }
2842
+ * ɵresolveA2UIActivation({ runtimeEnabled: true, hasCatalog: false, requireCatalog: true });
2843
+ * // { active: false, missingCatalog: true }
2844
+ */
2845
+ declare function ɵresolveA2UIActivation({
2846
+ runtimeEnabled,
2847
+ hasCatalog,
2848
+ requireCatalog
2849
+ }: ɵA2UIActivationInput): {
2850
+ active: boolean;
2851
+ missingCatalog: boolean;
2852
+ };
2853
+ /** @internal The input of {@link ɵassembleActivityRenderers}. */
2854
+ interface ɵActivityRenderersInput<R> {
2855
+ /** The app's activity renderers. They come first, so they win. */
2856
+ app?: readonly R[];
2857
+ /** The A2UI surface renderer, when A2UI is active. */
2858
+ a2ui?: R;
2859
+ /** The other built-in renderers, in order. */
2860
+ builtIns?: readonly (R | undefined | false)[];
2861
+ }
2862
+ /**
2863
+ * @internal The provider's activity renderer list: the app's renderers, then
2864
+ * the A2UI renderer, then the other built-in renderers. Missing entries are
2865
+ * left out.
2866
+ *
2867
+ * @example
2868
+ * ɵassembleActivityRenderers({
2869
+ * app: props.renderActivityMessages,
2870
+ * a2ui: a2uiActive ? a2uiRenderer : undefined,
2871
+ * builtIns: [mcpAppsRenderer, openGenUIActive && openGenUIRenderer],
2872
+ * });
2873
+ */
2874
+ declare function ɵassembleActivityRenderers<R>({
2875
+ app,
2876
+ a2ui,
2877
+ builtIns
2878
+ }: ɵActivityRenderersInput<R>): R[];
2666
2879
  /** @internal The object form of the provider `learning` option. */
2667
2880
  type ɵCopilotKitLearningOptions = LearningConfig & {
2668
2881
  /**
@@ -2948,6 +3161,54 @@ declare class ɵRuntimeInfoStore {
2948
3161
  dispose(): void;
2949
3162
  }
2950
3163
  //#endregion
3164
+ //#region src/core/frontend-tool-registration.d.ts
3165
+ type AnyFrontendTool = FrontendTool<any>;
3166
+ /** @internal The renderer that {@link ɵregisterFrontendTools} adds for a tool. */
3167
+ interface ɵFrontendToolRenderer<TRender> {
3168
+ name: string;
3169
+ args: AnyFrontendTool["parameters"];
3170
+ agentId: string | undefined;
3171
+ render: TRender;
3172
+ }
3173
+ /**
3174
+ * @internal Register frontend tools from a hook (`useFrontendTool`,
3175
+ * `useFrontendTools`) and their renderers.
3176
+ *
3177
+ * - Tools with the same `name` and `agentId` in `tools` collapse to the last
3178
+ * one, with a warning.
3179
+ * - A tool that hides an already registered tool (a provider tool or another
3180
+ * hook) logs a warning. Core runs the newest registration until it is
3181
+ * removed, and then the hidden tool runs again.
3182
+ * - A tool with a `render` gets a renderer through `addRenderer`, also when
3183
+ * it has no `parameters` (for example a confirm dialog). The returned
3184
+ * function does not remove renderers, so past calls still render in the
3185
+ * chat history.
3186
+ *
3187
+ * @param core - The core to register the tools with.
3188
+ * @param tools - The tools, in order.
3189
+ * @param addRenderer - Adds a hook renderer in the framework's registry.
3190
+ * @returns A function that removes exactly the tools this call registered.
3191
+ *
3192
+ * @example
3193
+ * const unregister = ɵregisterFrontendTools(core, [tool], (renderer) =>
3194
+ * core.addHookRenderToolCall(renderer),
3195
+ * );
3196
+ * // on unmount
3197
+ * unregister();
3198
+ */
3199
+ declare function ɵregisterFrontendTools<TTool extends AnyFrontendTool & {
3200
+ render?: unknown;
3201
+ }>(core: Pick<CopilotKitCore, "getTool" | "addTool">, tools: readonly TTool[], addRenderer: (renderer: ɵFrontendToolRenderer<NonNullable<TTool["render"]>>) => void): () => void;
3202
+ //#endregion
3203
+ //#region src/core/tool-result-content.d.ts
3204
+ /**
3205
+ * Mirrors `ContentPartSchema` from `@ag-ui/core/schemas`. The runtime parses
3206
+ * the request with that schema, and one invalid part there fails the whole run.
3207
+ * Core does not import the schema because the UMD build has no global for it.
3208
+ * A test checks this function against the schema.
3209
+ */
3210
+ declare function isContentPart(value: unknown): value is ContentPart;
3211
+ //#endregion
2951
3212
  //#region src/utils/markdown/complete-partial-markdown.d.ts
2952
3213
  declare function completePartialMarkdown(input: string): string;
2953
3214
  //#endregion
@@ -4983,6 +5244,27 @@ declare function ɵresolveCustomMessageRenderContext<R extends CustomMessageRend
4983
5244
  };
4984
5245
  /** The run lookups {@link ɵgetCustomMessageRenderProps} needs from core. */
4985
5246
  type ɵCustomMessageRunSource = Pick<CopilotKitCore, "getRunIdForMessage" | "getRunIdsForThread" | "getStateByRun">;
5247
+ /**
5248
+ * The agent state of the run that produced a message: the same value as
5249
+ * {@link ɵgetCustomMessageRenderProps}'s `stateSnapshot`, without the work of
5250
+ * placing the message in its run. Adapters use it to tell when a custom
5251
+ * message renderer must draw again.
5252
+ *
5253
+ * It clones the run state on each call. With no run at all it returns
5254
+ * `undefined`.
5255
+ *
5256
+ * @example
5257
+ * ```ts
5258
+ * const snapshot = ɵgetMessageRunStateSnapshot(core, {
5259
+ * agentId, threadId, messageId: message.id,
5260
+ * });
5261
+ * ```
5262
+ */
5263
+ declare function ɵgetMessageRunStateSnapshot(core: ɵCustomMessageRunSource, params: {
5264
+ agentId: string;
5265
+ threadId: string;
5266
+ messageId: string;
5267
+ }): unknown;
4986
5268
  /**
4987
5269
  * The props a custom message renderer gets for one message: the run that
4988
5270
  * produced it, its place in the conversation and in the run, and the agent
@@ -5173,6 +5455,52 @@ declare function ɵgetToolCallBadge(status: ɵToolCallCardStatus): {
5173
5455
  * @param description - Extra text from the app, added after a blank line.
5174
5456
  */
5175
5457
  declare function ɵcomponentToolDescription(name: string, description?: string): string;
5458
+ /**
5459
+ * What the default (`"*"`) tool-call renderer gets: the documented shape of
5460
+ * `useDefaultRenderTool`'s `render`, in React and Vue.
5461
+ */
5462
+ interface ɵDefaultToolCallRenderProps {
5463
+ /** The name of the tool being called. */
5464
+ name: string;
5465
+ /** The id of the tool call being rendered. */
5466
+ toolCallId: string;
5467
+ /** The parsed parameters passed to the tool call. */
5468
+ parameters: unknown;
5469
+ /** Current execution status of the tool call. */
5470
+ status: "inProgress" | "executing" | "complete";
5471
+ /** The tool call result string, available only when `status` is `"complete"`. */
5472
+ result: string | undefined;
5473
+ }
5474
+ /**
5475
+ * What a framework calls a registered `"*"` renderer with: core's raw shape
5476
+ * (`args` and a `ToolCallStatus`), or the documented shape when a call site
5477
+ * already adapted it.
5478
+ */
5479
+ interface ɵRawToolCallRenderProps {
5480
+ name: string;
5481
+ toolCallId: string;
5482
+ args?: unknown;
5483
+ parameters?: unknown;
5484
+ status?: unknown;
5485
+ result?: string;
5486
+ }
5487
+ /**
5488
+ * The status the default tool-call renderer shows. A status this version
5489
+ * does not know (a newer runtime could send one) reads `"inProgress"`, and
5490
+ * logs one warning per distinct value.
5491
+ *
5492
+ * @param status - A `ToolCallStatus`, or any framework's spelling of one.
5493
+ */
5494
+ declare function ɵtoDefaultToolCallStatus(status: unknown): ɵDefaultToolCallRenderProps["status"];
5495
+ /**
5496
+ * Turns the props a `"*"` renderer is called with into the documented
5497
+ * {@link ɵDefaultToolCallRenderProps}: `args` becomes `parameters`, and the
5498
+ * status goes through {@link ɵtoDefaultToolCallStatus}. Props already in the
5499
+ * documented shape stay as they are.
5500
+ *
5501
+ * @param raw - The props the renderer was called with.
5502
+ */
5503
+ declare function ɵadaptDefaultToolCallRenderProps(raw: ɵRawToolCallRenderProps): ɵDefaultToolCallRenderProps;
5176
5504
  //#endregion
5177
5505
  //#region src/chat/tool-call-layout.d.ts
5178
5506
  /**
@@ -6130,6 +6458,165 @@ declare class ɵChatSubmitter {
6130
6458
  */
6131
6459
  declare function ɵcreateChatSubmitter(options: ɵChatSubmitterOptions): ɵChatSubmitter;
6132
6460
  //#endregion
6461
+ //#region src/chat/chat-connection.d.ts
6462
+ /** An error core reported, as a chat's `onError` receives it. */
6463
+ interface ɵChatErrorEvent {
6464
+ error: Error;
6465
+ code: CopilotKitCoreErrorCode;
6466
+ context: Record<string, unknown>;
6467
+ }
6468
+ /**
6469
+ * Calls `handler` for every core error that belongs to `agentId`, and for
6470
+ * errors that name no agent. Core awaits its subscribers, so the handler's
6471
+ * promise is not awaited: a slow handler must not hold up the run that
6472
+ * reported the error. Returns the unsubscribe.
6473
+ */
6474
+ declare function ɵsubscribeToAgentErrors(core: Pick<CopilotKitCore, "subscribe">, agentId: string, handler: (event: ɵChatErrorEvent) => unknown): () => void;
6475
+ /**
6476
+ * The thread a chat shows when no caller picked one: a locally minted id.
6477
+ * The id stays the same while no thread is provided, and a new one is minted
6478
+ * each time a provided thread goes away, so removing a thread starts a fresh
6479
+ * one instead of returning to an older fresh thread.
6480
+ *
6481
+ * {@link resolve} returns the same id for the same input, so a framework can
6482
+ * call it while it renders.
6483
+ */
6484
+ declare class ɵFreshThreadId {
6485
+ private generated;
6486
+ private lastProvided;
6487
+ /** `providedThreadId` when set, else the fresh thread's id. */
6488
+ resolve(providedThreadId: string | undefined): string;
6489
+ }
6490
+ /**
6491
+ * Whether `agent` can load a thread from its backend: it overrides AG-UI's
6492
+ * `connect` or `connectAgent`. The base versions only throw
6493
+ * `AGUIConnectNotImplementedError`.
6494
+ */
6495
+ declare function ɵimplementsConnect(agent: AbstractAgent): boolean;
6496
+ /** What {@link ɵChatConnection} works with. */
6497
+ interface ɵChatConnectionOptions {
6498
+ /** The CopilotKit core that connects, stops and reports errors. */
6499
+ core: Pick<CopilotKitCore, "connectAgent" | "stopAgent" | "subscribe">;
6500
+ /**
6501
+ * Called when the thread an Inspector override shows fails to load, so the
6502
+ * override ends and the chat returns to its own thread.
6503
+ */
6504
+ onInspectorOverrideFailed?: (requestId: string) => void;
6505
+ /**
6506
+ * Runs `callback` once the view has painted what a connect applied. The
6507
+ * default is the next animation frame (16 ms where there is none), so the
6508
+ * chat stops showing "connecting" only after the restored messages render.
6509
+ */
6510
+ afterPaint?: (callback: () => void) => void;
6511
+ }
6512
+ /** Hooks for one connect, for framework state such as React's run-activity reconnects. */
6513
+ interface ɵChatConnectHooks {
6514
+ /** Called when the connect starts, before it waits for earlier teardowns. */
6515
+ onStart?: () => void;
6516
+ /**
6517
+ * Called when the connect has settled. `current` is `false` when the chat
6518
+ * released the thread before the connect settled.
6519
+ */
6520
+ onSettled?: (current: boolean) => void;
6521
+ }
6522
+ /** What a chat's connection shows. */
6523
+ interface ɵChatConnectionSnapshot {
6524
+ /** The last thread whose connect settled (succeeded or failed), or `null`. */
6525
+ connectedThreadId: string | null;
6526
+ }
6527
+ /** The thread a chat shows, from {@link ɵChatConnection.open}. */
6528
+ interface ɵChatConnectionHandle {
6529
+ /** The selection the chat shows. */
6530
+ readonly selection: ɵThreadSelection;
6531
+ /**
6532
+ * Stops showing the thread. A connect still loading is aborted and its run
6533
+ * detached. A run that started after the connect, or that took over its
6534
+ * pipeline, is left running. Safe to call more than once.
6535
+ */
6536
+ release(): void;
6537
+ }
6538
+ /**
6539
+ * The connect side of a chat: keeps the agent on the thread the chat shows
6540
+ * and loads that thread from the backend. Owns the rules all three
6541
+ * frameworks share:
6542
+ *
6543
+ * - Only a thread a caller picked (explicit) is connected. A locally minted
6544
+ * thread has never reached the backend, so `/connect` would 404.
6545
+ * - A connect waits for the previous thread's teardown, and a send waits for
6546
+ * the connect ({@link threads}).
6547
+ * - An `HttpAgent` connect gets its own `AbortController`, aborted when the
6548
+ * chat leaves the thread before the connect settles.
6549
+ * - Leaving a thread detaches the agent's run only while that run is the
6550
+ * connect's own. A run the user started after the connect keeps running.
6551
+ * - An agent that does not implement connect is not connected, and its
6552
+ * thread counts as loaded at once. On the agent's first thread its
6553
+ * messages stay, so a message sent right after mount survives. A move
6554
+ * from another thread detaches the old thread's run and empties the agent,
6555
+ * as a connect would. An `AGUIConnectNotImplementedError` from a connect
6556
+ * is not an error.
6557
+ * - A failed connect of an Inspector override ends the override.
6558
+ * - The chat shows "connecting" for an explicit thread until its connect has
6559
+ * settled and painted ({@link isConnecting}).
6560
+ *
6561
+ * @example
6562
+ * ```ts
6563
+ * const connection = new ɵChatConnection({ core, onInspectorOverrideFailed });
6564
+ * const handle = connection.open({ agent, threadId, explicit: true });
6565
+ * connection.isConnecting({ threadId, explicit: true }); // true until settled
6566
+ * // cleanup:
6567
+ * handle.release();
6568
+ * ```
6569
+ */
6570
+ declare class ɵChatConnection {
6571
+ private readonly options;
6572
+ /** The thread coordinator; a chat submitter waits on its connections. */
6573
+ readonly threads: ɵThreadSwitchCoordinator;
6574
+ private snapshot;
6575
+ private readonly listeners;
6576
+ private readonly afterPaint;
6577
+ /** The thread each agent showed last, to tell a thread switch from a first open. */
6578
+ private readonly openedThreads;
6579
+ constructor(options: ɵChatConnectionOptions);
6580
+ /** The last connected thread. Keeps its identity until it changes. */
6581
+ getSnapshot(): ɵChatConnectionSnapshot;
6582
+ /** Calls `listener` after every snapshot change. Returns the unsubscribe. */
6583
+ subscribe(listener: () => void): () => void;
6584
+ /**
6585
+ * Whether the chat waits for `threadId` to load: an explicit thread whose
6586
+ * connect has not settled yet. Pure, so a framework can call it while it
6587
+ * renders, before {@link open} has run for a new thread.
6588
+ */
6589
+ isConnecting({
6590
+ threadId,
6591
+ explicit
6592
+ }: {
6593
+ threadId: string;
6594
+ explicit: boolean;
6595
+ }): boolean;
6596
+ /**
6597
+ * Shows a thread: selects it on the coordinator (pinning `agent.threadId`)
6598
+ * and, for an explicit thread, connects it. Release the handle when the
6599
+ * chat moves on or unmounts.
6600
+ */
6601
+ open(input: ɵThreadSelectionInput, hooks?: ɵChatConnectHooks): ɵChatConnectionHandle;
6602
+ /**
6603
+ * Runs `connect` as a connection of the current thread, so a send waits for
6604
+ * it. With no current thread it just runs, and a failure is logged.
6605
+ */
6606
+ track(connect: () => Promise<unknown>): Promise<void>;
6607
+ /** Releases the current thread and drops the listeners. */
6608
+ dispose(): void;
6609
+ /**
6610
+ * What a connect does when an agent without `connect` moves to another
6611
+ * thread: detaches the old thread's run and empties the agent. The reset
6612
+ * runs again once the detach and every earlier teardown finished, and a
6613
+ * send waits for it, so nothing of the old thread lands on the new one.
6614
+ */
6615
+ private clearSwitchedThread;
6616
+ private setConnectedThreadId;
6617
+ private connect;
6618
+ }
6619
+ //#endregion
6133
6620
  //#region src/chat/message-view.d.ts
6134
6621
  /** What the message view shows now. Each call to {@link ɵMessageViewModel.update} passes it. */
6135
6622
  interface ɵMessageViewInput {
@@ -6359,7 +6846,7 @@ interface ɵComposerKeyEvent {
6359
6846
  * This handles Enter only. Keys for the slash-command menu stay in each
6360
6847
  * framework, and the framework handles them before it calls this function.
6361
6848
  *
6362
- * Results:
6849
+ * `action`:
6363
6850
  * - `"send"`: send the trimmed text.
6364
6851
  * - `"stop"`: stop the run. This happens for Enter in an empty input while
6365
6852
  * the agent runs. Text in the input always means send, not stop.
@@ -6368,9 +6855,9 @@ interface ɵComposerKeyEvent {
6368
6855
  * is disabled, for keys other than Enter, and for an Enter that has
6369
6856
  * nothing to send or stop.
6370
6857
  *
6371
- * Call `preventDefault()` for every Enter without Shift that is not part of
6372
- * IME composition, including when the result is `"none"`. This stops Enter
6373
- * from adding a line break that the user cannot send.
6858
+ * `preventDefault` is `true` for every Enter without Shift that is not part
6859
+ * of IME composition, also when `action` is `"none"`: Enter never adds a line
6860
+ * break that the user cannot send.
6374
6861
  *
6375
6862
  * @param event - The keyboard event, or an object with the same fields.
6376
6863
  * @param input - The current state of the chat input.
@@ -6378,16 +6865,20 @@ interface ɵComposerKeyEvent {
6378
6865
  * @example
6379
6866
  * ```ts
6380
6867
  * function onKeyDown(event: KeyboardEvent) {
6381
- * if (event.isComposing || event.keyCode === 229) return;
6382
6868
  * // ...slash-command menu keys...
6383
- * const result = ɵresolveComposerKey(event, composerInput);
6384
- * if (event.key === "Enter" && !event.shiftKey) event.preventDefault();
6385
- * if (result === "send") sendMessage(composerInput.value.trim());
6386
- * if (result === "stop") stopRun();
6869
+ * const { action, preventDefault } = ɵresolveComposerKey(event, composerInput);
6870
+ * if (preventDefault) event.preventDefault();
6871
+ * if (action === "send") sendMessage(composerInput.value.trim());
6872
+ * if (action === "stop") stopRun();
6387
6873
  * }
6388
6874
  * ```
6389
6875
  */
6390
- declare function ɵresolveComposerKey(event: ɵComposerKeyEvent, input: ɵComposerInput): "none" | "send" | "stop" | "newline";
6876
+ declare function ɵresolveComposerKey(event: ɵComposerKeyEvent, input: ɵComposerInput): {
6877
+ action: ɵComposerKeyAction;
6878
+ preventDefault: boolean;
6879
+ };
6880
+ /** What a key press in the chat input does. See {@link ɵresolveComposerKey}. */
6881
+ type ɵComposerKeyAction = "send" | "stop" | "newline" | "none";
6391
6882
  /**
6392
6883
  * One entry of the chat input's tools menu, as the framework packages type
6393
6884
  * it: a leaf with an `action`, or a group with nested `items`. `"-"` in a
@@ -6521,6 +7012,186 @@ declare function ɵresolveSlashKey<T>(event: Pick<ɵComposerKeyEvent, "key">, st
6521
7012
  readonly index?: undefined;
6522
7013
  readonly command?: undefined;
6523
7014
  };
7015
+ /**
7016
+ * The tools menu the "+" button opens: the default "Add file" item first,
7017
+ * then the app's items. A separator goes between the two parts. Separators
7018
+ * next to each other become one, and separators at the start or end are
7019
+ * dropped. Nested groups stay as they are.
7020
+ *
7021
+ * @param toolsMenu - The app's items. `"-"` is a separator.
7022
+ * @param addFileItem - The default "Add file" item, or `undefined` when the
7023
+ * chat takes no files.
7024
+ *
7025
+ * @example
7026
+ * ```ts
7027
+ * ɵnormalizeToolsMenu(["-", search, "-", "-", summarize, "-"], addFile);
7028
+ * // → [addFile, "-", search, "-", summarize]
7029
+ * ```
7030
+ */
7031
+ declare function ɵnormalizeToolsMenu<T>(toolsMenu: readonly (T | "-")[] | undefined, addFileItem?: T): (T | "-")[];
7032
+ /** One row of a tools menu drawn as a flat list. */
7033
+ type ɵToolsMenuDisplayEntry = {
7034
+ type: "separator";
7035
+ key: string;
7036
+ } | {
7037
+ type: "label";
7038
+ key: string;
7039
+ label: string;
7040
+ depth: number;
7041
+ } | {
7042
+ type: "item";
7043
+ key: string;
7044
+ label: string;
7045
+ depth: number;
7046
+ action: () => void;
7047
+ };
7048
+ /**
7049
+ * The tools menu as a flat list of rows, for a menu that draws groups inline
7050
+ * instead of as submenus. A group becomes a label row followed by its items
7051
+ * one level deeper. Leaf items without an `action` are dropped. Each row has
7052
+ * a `key` that stays the same while the menu does.
7053
+ *
7054
+ * @param menu - The menu from {@link ɵnormalizeToolsMenu}.
7055
+ */
7056
+ declare function ɵflattenToolsMenuForDisplay<T extends ɵCommandMenuItem<T>>(menu: readonly (T | "-")[]): ɵToolsMenuDisplayEntry[];
7057
+ /** The parts of an audio recorder that {@link ɵsyncRecorderToMode} uses. */
7058
+ interface ɵModeRecorder {
7059
+ /** `"idle"`, `"recording"`, or another state of the recorder. */
7060
+ readonly state: string;
7061
+ start(): Promise<unknown>;
7062
+ stop(): Promise<unknown>;
7063
+ }
7064
+ /**
7065
+ * Make the recorder follow the chat input's mode: it starts recording when
7066
+ * the mode is `"transcribe"` and it is idle, and it stops when the mode
7067
+ * changes while it records. Call it when the mode or the recorder changes.
7068
+ * Errors are logged, not thrown.
7069
+ *
7070
+ * @param recorder - The recorder, or `null` before it renders.
7071
+ * @param mode - The chat input's mode.
7072
+ */
7073
+ declare function ɵsyncRecorderToMode(recorder: ɵModeRecorder | null | undefined, mode: ɵComposerMode): Promise<void>;
7074
+ /**
7075
+ * Whether the chat input shows its disclaimer: as `showDisclaimer` says, or,
7076
+ * when it is not set, only when the input is pinned with absolute
7077
+ * positioning.
7078
+ */
7079
+ declare function ɵshowsComposerDisclaimer(options: {
7080
+ showDisclaimer?: boolean;
7081
+ positioning?: "static" | "absolute";
7082
+ }): boolean;
7083
+ /** What the chat input shows. See {@link ɵComposerController}. */
7084
+ interface ɵComposerSnapshot<T> {
7085
+ /** The text in the input. */
7086
+ readonly value: string;
7087
+ /** The slash-menu query, or `null` while the slash menu is closed. */
7088
+ readonly slashQuery: string | null;
7089
+ /** The commands the slash menu lists for the query. */
7090
+ readonly slashCommands: readonly ɵRunnableCommand<T>[];
7091
+ /** The highlighted row of the slash menu, or `-1` when no row matches. */
7092
+ readonly slashHighlightIndex: number;
7093
+ }
7094
+ /** What the framework passes to {@link ɵComposerController.setInputs}. */
7095
+ interface ɵComposerControllerInputs<T> {
7096
+ /** The text when the app controls it, or `undefined` to keep it inside. */
7097
+ value: string | undefined;
7098
+ mode: ɵComposerMode;
7099
+ /** The tools menu, from {@link ɵnormalizeToolsMenu}. */
7100
+ menu: readonly (T | "-")[];
7101
+ }
7102
+ interface ɵComposerControllerOptions {
7103
+ /** The starting text when the app does not control it. */
7104
+ initialValue?: string;
7105
+ /** Called with each new text: typing, and clearing after a send or command. */
7106
+ onChange?: (value: string) => void;
7107
+ }
7108
+ /** The result of {@link ɵComposerController.keyDown}. */
7109
+ interface ɵComposerKeyDownResult {
7110
+ /** Call `preventDefault()` on the event. */
7111
+ preventDefault: boolean;
7112
+ /**
7113
+ * `"send"` or `"stop"`: do that now. `"command"`: a slash command ran and
7114
+ * the input cleared; give the text box focus again.
7115
+ */
7116
+ action: ɵComposerKeyAction | "command";
7117
+ }
7118
+ /**
7119
+ * The text and slash-command menu of one chat input.
7120
+ *
7121
+ * - The text is the app's `value` when it sets one (controlled), else the
7122
+ * controller keeps it. Every change calls `onChange`, in both cases.
7123
+ * - The slash menu opens while the text starts with `/` in input mode and
7124
+ * the menu has commands. Escape, running a command, and leaving input mode
7125
+ * close it until the text changes.
7126
+ * - The highlight goes to the first row when the query changes and stays on
7127
+ * a row that exists when the list changes.
7128
+ *
7129
+ * Frameworks render from `getSnapshot()` and re-render when `subscribe()`
7130
+ * notifies. Call `setInputs()` whenever the app's value, the mode, or the
7131
+ * tools menu changes.
7132
+ *
7133
+ * @example
7134
+ * ```ts
7135
+ * const composer = new ɵComposerController({ onChange: emitChange });
7136
+ * composer.setInputs({ value: undefined, mode: "input", menu });
7137
+ * textarea.oninput = () => composer.setValue(textarea.value);
7138
+ * textarea.onkeydown = (event) => {
7139
+ * const { preventDefault, action } = composer.keyDown(event, composerInput);
7140
+ * if (preventDefault) event.preventDefault();
7141
+ * if (action === "send") composer.submit(sendMessage);
7142
+ * };
7143
+ * ```
7144
+ */
7145
+ declare class ɵComposerController<T extends ɵCommandMenuItem<T>> {
7146
+ #private;
7147
+ constructor({
7148
+ initialValue,
7149
+ onChange
7150
+ }?: ɵComposerControllerOptions);
7151
+ /** The current state. The same object until something changes. */
7152
+ getSnapshot: () => ɵComposerSnapshot<T>;
7153
+ /** Calls `listener` when the state changes. Returns the unsubscribe function. */
7154
+ subscribe: (listener: () => void) => () => void;
7155
+ /** Takes the app's value, the mode, and the tools menu. */
7156
+ setInputs: ({
7157
+ value,
7158
+ mode,
7159
+ menu
7160
+ }: ɵComposerControllerInputs<T>) => void;
7161
+ /** The user changed the text. */
7162
+ setValue: (value: string) => void;
7163
+ /** Highlights row `index` of the slash menu, for example on hover. */
7164
+ highlight: (index: number) => void;
7165
+ /** Closes the slash menu and keeps the text. */
7166
+ closeSlashMenu: () => void;
7167
+ /** Clears the text, closes the slash menu, and runs `command`. */
7168
+ runCommand: (command: T) => void;
7169
+ /**
7170
+ * Sends the trimmed text with `send` and then clears the input. Does
7171
+ * nothing for text that is only whitespace.
7172
+ *
7173
+ * @param send - Receives the trimmed text.
7174
+ * @param options.value - The text to send, when the framework has a newer
7175
+ * one than the snapshot (a controlled value can lag a tick).
7176
+ * @param options.clear - Clear the input after sending. Default: `true`.
7177
+ * @returns Whether `send` was called.
7178
+ */
7179
+ submit: (send: (text: string) => void, {
7180
+ value,
7181
+ clear
7182
+ }?: {
7183
+ value?: string;
7184
+ clear?: boolean;
7185
+ }) => boolean;
7186
+ /**
7187
+ * Handles a key press in the text box: the slash-menu keys first, then
7188
+ * Enter as {@link ɵresolveComposerKey} decides.
7189
+ *
7190
+ * @param event - The keyboard event, or an object with the same fields.
7191
+ * @param input - The chat input's state for the send or stop decision.
7192
+ */
7193
+ keyDown: (event: ɵComposerKeyEvent, input: ɵComposerInput) => ɵComposerKeyDownResult;
7194
+ }
6524
7195
  //#endregion
6525
7196
  //#region src/chat/composer-layout.d.ts
6526
7197
  /** Where the text box sits in the chat input. */
@@ -6858,6 +7529,11 @@ declare class ɵDockedSidebar {
6858
7529
  private owns;
6859
7530
  private hasApplied;
6860
7531
  constructor(document: Document, transitionMs: number);
7532
+ /**
7533
+ * `true` while this sidebar has the page margin. `false` when it is closed,
7534
+ * on a mobile viewport, or when another docked sidebar has the margin.
7535
+ */
7536
+ get isDocked(): boolean;
6861
7537
  /** Apply the sidebar's open state, side, and width. */
6862
7538
  set(state: ɵDockedSidebarState): void;
6863
7539
  /** Give the margins back at once and stop following the viewport. */
@@ -6882,6 +7558,67 @@ declare function ɵcreateDockedSidebar(document: Document, options: {
6882
7558
  }): ɵDockedSidebar;
6883
7559
  /** How long the popup's open animation runs, in ms. */
6884
7560
  declare const ɵPOPUP_ANIMATION_MS = 200;
7561
+ /** The popup's width when the `width` prop is missing, in px. */
7562
+ declare const ɵPOPUP_DEFAULT_WIDTH = 420;
7563
+ /** The popup's height when the `height` prop is missing, in px. */
7564
+ declare const ɵPOPUP_DEFAULT_HEIGHT = 560;
7565
+ /** The sidebar's width when the `width` prop is missing, in px. */
7566
+ declare const ɵSIDEBAR_DEFAULT_WIDTH = 480;
7567
+ /** How long the docked sidebar's page margin animates, in ms. */
7568
+ declare const ɵSIDEBAR_TRANSITION_MS = 260;
7569
+ /** Whether a closing panel is still in the DOM. */
7570
+ interface ɵExitPresenceState {
7571
+ /** Render the panel. */
7572
+ isRendered: boolean;
7573
+ /** The panel is closed but still plays its exit animation. */
7574
+ isClosing: boolean;
7575
+ }
7576
+ /**
7577
+ * Keeps a closed panel in the DOM for its exit animation, then removes it.
7578
+ * Opening again during the animation cancels the removal.
7579
+ *
7580
+ * Create it with {@link ɵcreateExitPresence}. Each change makes a new state
7581
+ * object, so `getState` works with React's `useSyncExternalStore`.
7582
+ */
7583
+ declare class ɵExitPresence {
7584
+ private readonly durationMs;
7585
+ private state;
7586
+ private timer;
7587
+ private readonly listeners;
7588
+ constructor(open: boolean, durationMs: number);
7589
+ /** The current state. */
7590
+ readonly getState: () => ɵExitPresenceState;
7591
+ /**
7592
+ * Call `listener` on each change.
7593
+ *
7594
+ * @returns The unsubscribe function.
7595
+ */
7596
+ readonly subscribe: (listener: (state: ɵExitPresenceState) => void) => () => void;
7597
+ /** Apply the panel's open state. */
7598
+ setOpen(open: boolean): void;
7599
+ /** Cancel a pending removal. */
7600
+ dispose(): void;
7601
+ private set;
7602
+ private clearTimer;
7603
+ }
7604
+ /**
7605
+ * Create the exit-animation state of a popup or another panel.
7606
+ *
7607
+ * @param open - Whether the panel starts open.
7608
+ * @param options - `durationMs`: how long the exit animation runs. Default:
7609
+ * {@link ɵPOPUP_ANIMATION_MS}.
7610
+ *
7611
+ * @example
7612
+ * ```ts
7613
+ * const presence = ɵcreateExitPresence(isOpen);
7614
+ * presence.subscribe(({ isRendered, isClosing }) => render(isRendered, isClosing));
7615
+ * presence.setOpen(false); // renders until the animation ends
7616
+ * presence.dispose(); // on unmount
7617
+ * ```
7618
+ */
7619
+ declare function ɵcreateExitPresence(open: boolean, options?: {
7620
+ durationMs?: number;
7621
+ }): ɵExitPresence;
6885
7622
  interface ɵPopupDismissOptions {
6886
7623
  /** The popup's panel. Reads it at event time. */
6887
7624
  getContainer: () => HTMLElement | null | undefined;
@@ -6921,6 +7658,24 @@ declare function ɵbindPopupDismiss(options: ɵPopupDismissOptions): () => void;
6921
7658
  * @param direction - `"open"` or `"close"`.
6922
7659
  */
6923
7660
  declare function ɵmorphViewTransition(thumbnail: HTMLElement | null | undefined, name: string, apply: () => void | Promise<void>, direction: "open" | "close"): void;
7661
+ /**
7662
+ * Elements Tab stops at: the focusable ones without `tabindex="-1"`. Radix
7663
+ * focus guards, which only pass focus on, are left out.
7664
+ */
7665
+ declare const ɵTAB_STOP_SELECTOR: string;
7666
+ /**
7667
+ * Approximately the element Tab reaches after `element`, in document order.
7668
+ * Elements inside `skip` (for example a popover in a portal) and inside
7669
+ * `[hidden]` or `[inert]` are passed over.
7670
+ *
7671
+ * @returns The next tab stop, or `null` when there is none.
7672
+ */
7673
+ declare function ɵnextTabStop(element: Element, skip: Element | null): HTMLElement | null;
7674
+ /**
7675
+ * Whether focus on `element` came from the keyboard. A pointer click also
7676
+ * focuses buttons, and this tells the two apart.
7677
+ */
7678
+ declare function ɵisFocusVisible(element: Element): boolean;
6924
7679
  interface ɵDialogFocusOptions {
6925
7680
  /** Where focus goes on open. Default: the first focusable element. */
6926
7681
  initialFocus?: HTMLElement | null;
@@ -6945,7 +7700,7 @@ type AttachmentSource = Attachment["source"];
6945
7700
  * @returns `"pdf"`, `"text"` (for `text/*`), or `null` when the browser
6946
7701
  * cannot preview it.
6947
7702
  */
6948
- declare function ɵcanPreviewDocument(mimeType: string | undefined): "pdf" | "text" | null;
7703
+ declare function ɵcanPreviewDocument(mimeType: string | undefined): "text" | "pdf" | null;
6949
7704
  /**
6950
7705
  * A URL a browser can show in an `<iframe>` for an attachment's source.
6951
7706
  *
@@ -6977,6 +7732,53 @@ declare const ɵSCROLL_BOTTOM_THRESHOLD_PX = 12;
6977
7732
  * {@link ɵSCROLL_BOTTOM_THRESHOLD_PX}.
6978
7733
  */
6979
7734
  declare function ɵisScrolledToBottom(element: Pick<HTMLElement, "scrollHeight" | "scrollTop" | "clientHeight">, threshold?: number): boolean;
7735
+ /**
7736
+ * Whether a scroll container shows the end of `content`, an element inside
7737
+ * it. Use it when empty space follows the messages, such as the
7738
+ * `pin-to-send` spacer: scrolling into that space shows no more messages.
7739
+ *
7740
+ * @param element - The scroll container.
7741
+ * @param content - The element that holds the messages.
7742
+ * @param threshold - The pixels of `content` below the viewport that still
7743
+ * count. Default: {@link ɵSCROLL_BOTTOM_THRESHOLD_PX}.
7744
+ */
7745
+ declare function ɵisContentScrolledToBottom(element: Element, content: Element, threshold?: number): boolean;
7746
+ /** How long an element counts as resizing after its last size change, in ms. */
7747
+ declare const ɵRESIZE_SETTLE_MS = 250;
7748
+ /** What {@link ɵwatchElementHeight} reports. */
7749
+ interface ɵElementHeightState {
7750
+ /** The content-box height, in px. */
7751
+ height: number;
7752
+ /** The height changed less than `settleMs` ago. */
7753
+ isResizing: boolean;
7754
+ }
7755
+ /**
7756
+ * Report an element's height now and on each change. `isResizing` is `true`
7757
+ * from a change until the height stays the same for `settleMs`, so callers
7758
+ * can hide UI, such as the scroll-to-bottom button, while a layout moves.
7759
+ *
7760
+ * The first call reads `offsetHeight`. Later calls read the
7761
+ * `ResizeObserver` content box. Without `ResizeObserver`, only the first
7762
+ * call happens.
7763
+ *
7764
+ * @param element - The element to measure.
7765
+ * @param listener - Gets the height and the resizing state.
7766
+ * @param options - `settleMs`: default {@link ɵRESIZE_SETTLE_MS}.
7767
+ * @returns A function that stops the watch.
7768
+ */
7769
+ declare function ɵwatchElementHeight(element: HTMLElement, listener: (state: ɵElementHeightState) => void, options?: {
7770
+ settleMs?: number;
7771
+ }): () => void;
7772
+ /**
7773
+ * Report an element's border-box width now and on each change, skipping
7774
+ * zero widths (a hidden element). Uses `ResizeObserver`, or the window's
7775
+ * `resize` event without it.
7776
+ *
7777
+ * @param element - The element to measure, for example a sidebar.
7778
+ * @param listener - Gets the width in px.
7779
+ * @returns A function that stops the watch.
7780
+ */
7781
+ declare function ɵwatchElementWidth(element: HTMLElement, listener: (width: number) => void): () => void;
6980
7782
  //#endregion
6981
7783
  //#region src/chat/license.d.ts
6982
7784
  /** Input for {@link ɵresolveLicenseState}. */
@@ -7505,6 +8307,12 @@ interface ɵThreadSummary {
7505
8307
  archived: boolean;
7506
8308
  createdAt: string;
7507
8309
  updatedAt: string;
8310
+ /**
8311
+ * ISO-8601 timestamp of the most recent agent run on this thread. Absent
8312
+ * when the thread has never been run. Prefer this over `updatedAt` for
8313
+ * user-facing "last activity" displays — it is not bumped by metadata-only
8314
+ * actions like rename or archive.
8315
+ */
7508
8316
  lastRunAt?: string;
7509
8317
  }
7510
8318
  /** Project a store thread onto the public shape (no internal fields). */
@@ -7774,12 +8582,61 @@ interface ɵFeedbackCommentState {
7774
8582
  readonly draft: string;
7775
8583
  /** Grows each time the field should take focus: after a keyboard rating. */
7776
8584
  readonly focusRequest: number;
8585
+ /** The chosen thumb the popover points at, or `null` before it is known. */
8586
+ readonly anchor: HTMLElement | null;
8587
+ }
8588
+ /**
8589
+ * The attributes a thumb button carries while this chat records ratings.
8590
+ * The chosen thumb also says that it opens the comment popover.
8591
+ */
8592
+ type ɵFeedbackThumbAttributes = {
8593
+ "data-copilotkit-rating": ɵMessageFeedbackRating;
8594
+ "aria-pressed": false;
8595
+ } | {
8596
+ "data-copilotkit-rating": ɵMessageFeedbackRating;
8597
+ "aria-pressed": true;
8598
+ "aria-haspopup": "dialog";
8599
+ "aria-expanded": boolean;
8600
+ };
8601
+ /** Event handlers of the chosen thumb. Bind each to the event it names. */
8602
+ interface ɵFeedbackThumbHandlers {
8603
+ pointerEnter: (event: {
8604
+ currentTarget: EventTarget | null;
8605
+ pointerType: string;
8606
+ }) => void;
8607
+ pointerLeave: (event: {
8608
+ pointerType: string;
8609
+ }) => void;
8610
+ focus: (event: {
8611
+ currentTarget: EventTarget | null;
8612
+ }) => void;
8613
+ blur: () => void;
8614
+ keyDown: (event: ɵFeedbackKeyEvent) => void;
7777
8615
  }
8616
+ /** The keyboard fields the comment popover reads. */
8617
+ interface ɵFeedbackKeyEvent {
8618
+ key: string;
8619
+ shiftKey: boolean;
8620
+ preventDefault: () => void;
8621
+ }
8622
+ /** What {@link ɵFeedbackCommentController.thumb} gives one thumb button. */
8623
+ interface ɵFeedbackThumb {
8624
+ attributes: ɵFeedbackThumbAttributes;
8625
+ /** Handlers for the chosen thumb; `null` for the other one. */
8626
+ handlers: ɵFeedbackThumbHandlers | null;
8627
+ }
8628
+ /**
8629
+ * Whether `target` is a thumb of message `messageId`. A click on one decides
8630
+ * itself what happens to the comment, so the popover ignores it.
8631
+ */
8632
+ declare function ɵisOwnFeedbackThumb(target: EventTarget | null, messageId: string): boolean;
7778
8633
  /** How a pointer or keyboard focus reached or left the rating. */
7779
8634
  type ɵFeedbackCommentVia = "pointer" | "focus";
7780
8635
  interface ɵFeedbackCommentControllerOptions {
7781
8636
  /** The newest feedback controls of the message, or `null` without any. */
7782
8637
  getControls: () => ɵMessageFeedbackControls | null;
8638
+ /** The comment field, while it renders. */
8639
+ getInput?: () => HTMLElement | null;
7783
8640
  /** Defaults to {@link ɵFEEDBACK_COMMENT_CLOSE_DELAY_MS}. */
7784
8641
  closeDelayMs?: number;
7785
8642
  }
@@ -7793,6 +8650,12 @@ interface ɵFeedbackCommentControllerOptions {
7793
8650
  * Escape. Closing saves a changed comment; Escape, a click on a thumb, and
7794
8651
  * removing the rating discard it.
7795
8652
  *
8653
+ * The thumbs are toggles (see `rate()`), and `thumb()` gives each thumb its
8654
+ * attributes and handlers. The popover lives in a portal, so it keeps the
8655
+ * keyboard order by hand (see `popoverKeyDown()` and `popoverEscape()`):
8656
+ * Shift+Tab from its start returns to the thumb, Tab from its end moves on
8657
+ * to the control after the thumb, and Enter or Escape returns to the thumb.
8658
+ *
7796
8659
  * Frameworks render from `getSnapshot()` and re-render when `subscribe()`
7797
8660
  * notifies. Call `dispose()` on unmount: it keeps an unsaved edit, for a
7798
8661
  * message that scrolls out of a virtual list. The controller stays usable
@@ -7843,6 +8706,70 @@ declare class ɵFeedbackCommentController {
7843
8706
  }) => void;
7844
8707
  /** Moves focus back to the thumb without opening the comment again. */
7845
8708
  returnFocus: (target: Pick<HTMLElement, "focus"> | null) => void;
8709
+ /**
8710
+ * A click on thumb `value`. Thumbs are toggles: a new rating is saved and
8711
+ * opens its comment, and clicking the chosen thumb again removes the
8712
+ * rating. A keyboard click moves focus into the comment, as there is no
8713
+ * pointer.
8714
+ *
8715
+ * @param options.target - The clicked thumb, if the click gave one.
8716
+ * @param options.keyboard - The click came from the keyboard (`detail` 0).
8717
+ * @returns Whether the app's handler should run: true for a new rating and
8718
+ * whenever this chat does not record ratings, false when one is removed.
8719
+ */
8720
+ rate: (value: ɵMessageFeedbackRating, options?: {
8721
+ target?: HTMLElement | null;
8722
+ keyboard?: boolean;
8723
+ }) => boolean;
8724
+ /**
8725
+ * The attributes and handlers of thumb `value`, or `null` while this chat
8726
+ * records no ratings. The chosen thumb opens its comment when the pointer
8727
+ * or keyboard focus reaches it, and Tab from it moves into the comment.
8728
+ */
8729
+ thumb: (value: ɵMessageFeedbackRating) => ɵFeedbackThumb | null;
8730
+ /**
8731
+ * Points the popover at the chosen thumb inside `root` when no thumb was
8732
+ * given: a custom thumb can call its click handler without an event. Call
8733
+ * it after each render.
8734
+ */
8735
+ findAnchor: (root: ParentNode | null) => void;
8736
+ /**
8737
+ * Closes a comment that no longer fits: discards it when the rating was
8738
+ * changed or removed elsewhere, and saves it when the toolbar hides. Call
8739
+ * it when the rating or `showsToolbar` changes.
8740
+ */
8741
+ sync: ({
8742
+ showsToolbar
8743
+ }: {
8744
+ showsToolbar: boolean;
8745
+ }) => void;
8746
+ /** Moves focus into the comment field when a keyboard rating asked for it. */
8747
+ focusField: () => void;
8748
+ /** Saves the comment, closes, and moves focus back to the thumb. */
8749
+ submit: () => void;
8750
+ /**
8751
+ * Escape in the popover: closes without saving, and moves focus back to
8752
+ * the thumb when it was in the popover.
8753
+ *
8754
+ * @param content - The popover element.
8755
+ * @returns Whether focus was in the popover. Then stop the event, so it
8756
+ * does not also close a chat popup around the message.
8757
+ */
8758
+ popoverEscape: (content: Element | null) => boolean;
8759
+ /**
8760
+ * A key press in the popover: Tab past its last control or Shift+Tab past
8761
+ * its first one leaves it, as if it sat right after the thumb.
8762
+ *
8763
+ * @param content - The popover element.
8764
+ */
8765
+ popoverKeyDown: (event: ɵFeedbackKeyEvent, content: Element | null) => void;
8766
+ /**
8767
+ * Focus left the comment form for `next`. Moving within the popover or to
8768
+ * a thumb of the message, where the pointer still is, keeps it open.
8769
+ *
8770
+ * @param content - The popover element.
8771
+ */
8772
+ popoverFocusLeave: (next: Element | null, content: Element | null, messageId: string) => void;
7846
8773
  /** Stops the close timer and saves a changed comment that is still open. */
7847
8774
  dispose: () => void;
7848
8775
  }
@@ -7947,6 +8874,118 @@ declare function ɵpinMessageToTop({
7947
8874
  messageId,
7948
8875
  topOffset
7949
8876
  }: ɵPinMessageToTopOptions): () => boolean;
8877
+ /** Input for {@link ɵcreateStickToBottom}. */
8878
+ interface ɵStickToBottomOptions {
8879
+ /** The scroll container of the message list. */
8880
+ scrollElement: HTMLElement;
8881
+ /**
8882
+ * The element that holds the messages. Its size changes and DOM changes
8883
+ * keep the list at the bottom. Default: `scrollElement`.
8884
+ */
8885
+ contentElement?: HTMLElement;
8886
+ /**
8887
+ * The pixels from the end that still count as the bottom. Default:
8888
+ * {@link ɵSCROLL_BOTTOM_THRESHOLD_PX}.
8889
+ */
8890
+ threshold?: number;
8891
+ /**
8892
+ * `true` to follow new content while the reader is at the bottom. `false`
8893
+ * only tracks the position, for the scroll-to-bottom button. Default:
8894
+ * `true`.
8895
+ */
8896
+ follow?: boolean;
8897
+ /** How the first scroll to the bottom moves. Default: `"instant"`. */
8898
+ initialBehavior?: ScrollBehavior;
8899
+ /** How the scrolls that follow new content move. Default: `"instant"`. */
8900
+ followBehavior?: ScrollBehavior;
8901
+ /**
8902
+ * Runs when {@link ɵStickToBottom.isAtBottom} changes. The value starts as
8903
+ * `true`, so the first call is the first `false`.
8904
+ */
8905
+ onChange?: (isAtBottom: boolean) => void;
8906
+ }
8907
+ /**
8908
+ * Keeps a message list at its bottom while content arrives, and stops when
8909
+ * the reader scrolls up. Scrolling back to the bottom, or a call to
8910
+ * {@link ɵStickToBottom.scrollToBottom}, starts it again.
8911
+ *
8912
+ * Content changes come from a `ResizeObserver` on both elements and a
8913
+ * `MutationObserver` on the content. Without them, only scroll events and
8914
+ * explicit calls update it.
8915
+ *
8916
+ * Create it with {@link ɵcreateStickToBottom}.
8917
+ */
8918
+ declare class ɵStickToBottom {
8919
+ private readonly scrollElement;
8920
+ private readonly contentElement;
8921
+ private readonly threshold;
8922
+ private readonly followBehavior;
8923
+ private readonly onChange;
8924
+ private follow;
8925
+ /** The reader has not scrolled away from the bottom. */
8926
+ private stuck;
8927
+ /** A smooth scroll to the bottom is on its way. */
8928
+ private smoothPending;
8929
+ /** `scrollTop` right after the last instant scroll to the bottom. */
8930
+ private programmaticTop;
8931
+ private lastTop;
8932
+ /** The largest `scrollTop` at the last read, to tell when content shrank. */
8933
+ private lastMaxTop;
8934
+ private reported;
8935
+ private frame;
8936
+ private readonly observers;
8937
+ constructor(options: ɵStickToBottomOptions);
8938
+ /**
8939
+ * `true` when the list shows its end, or when it follows new content and
8940
+ * is on its way there.
8941
+ */
8942
+ get isAtBottom(): boolean;
8943
+ /** Turn following new content on or off. */
8944
+ setFollow(follow: boolean): void;
8945
+ /**
8946
+ * Scroll to the end and follow new content again.
8947
+ *
8948
+ * @param behavior - Default: `"smooth"`.
8949
+ */
8950
+ scrollToBottom(behavior?: ScrollBehavior): void;
8951
+ /**
8952
+ * Read the scroll position again, as a scroll event does. Call it when the
8953
+ * framework handles scroll events itself.
8954
+ */
8955
+ readonly update: () => void;
8956
+ /** Stop listening and observing. */
8957
+ dispose(): void;
8958
+ private readonly handleScrollEnd;
8959
+ private readonly followContent;
8960
+ private observeContent;
8961
+ private scrollToEnd;
8962
+ /**
8963
+ * `scrollTop` went down since the last read because the reader scrolled
8964
+ * up. Not when the content (or the viewport) changed so that the browser
8965
+ * clamped `scrollTop`, and not for the controller's own scroll.
8966
+ */
8967
+ private movedUp;
8968
+ private leave;
8969
+ private remember;
8970
+ private maxTop;
8971
+ private atBottom;
8972
+ private report;
8973
+ }
8974
+ /**
8975
+ * Create the controller that keeps a message list at its bottom.
8976
+ *
8977
+ * @example
8978
+ * ```ts
8979
+ * const stick = ɵcreateStickToBottom({
8980
+ * scrollElement,
8981
+ * contentElement,
8982
+ * onChange: (isAtBottom) => (showButton = !isAtBottom),
8983
+ * });
8984
+ * button.onclick = () => stick.scrollToBottom();
8985
+ * stick.dispose(); // on unmount
8986
+ * ```
8987
+ */
8988
+ declare function ɵcreateStickToBottom(options: ɵStickToBottomOptions): ɵStickToBottom;
7950
8989
  //#endregion
7951
8990
  //#region src/chat/message-display.d.ts
7952
8991
  /**
@@ -7957,6 +8996,76 @@ declare function ɵpinMessageToTop({
7957
8996
  * @param labels - The chat labels that hold the duration texts.
7958
8997
  */
7959
8998
  declare function ɵformatReasoningDurationLabel(seconds: number, labels: CopilotChatLabels): string;
8999
+ /**
9000
+ * The header text of a reasoning message: `labels.reasoningMessageThinkingLabel`
9001
+ * while the model reasons, then `labels.reasoningMessageThoughtForLabel`
9002
+ * ("Thought for 4 seconds").
9003
+ *
9004
+ * @param state - Whether the model still reasons, and for how long it did.
9005
+ * @param labels - The chat labels.
9006
+ */
9007
+ declare function ɵgetReasoningHeaderLabel(state: Pick<ɵReasoningDisclosureState, "isStreaming" | "elapsedSeconds">, labels: CopilotChatLabels): string;
9008
+ /** What a reasoning message shows. See {@link ɵReasoningDisclosure}. */
9009
+ interface ɵReasoningDisclosureState {
9010
+ /** The model is reasoning in this message now. */
9011
+ readonly isStreaming: boolean;
9012
+ /** The reasoning text shows. */
9013
+ readonly isOpen: boolean;
9014
+ /**
9015
+ * Seconds since the model started reasoning. It grows every tick while the
9016
+ * model reasons and stays at the final time after. `0` for a message that
9017
+ * never streamed here, such as one loaded from history.
9018
+ */
9019
+ readonly elapsedSeconds: number;
9020
+ }
9021
+ /** Options for {@link ɵReasoningDisclosure}. */
9022
+ interface ɵReasoningDisclosureOptions {
9023
+ /** Whether the message streams when it first renders. Default: `false`. */
9024
+ isStreaming?: boolean;
9025
+ /** How often the elapsed time updates while streaming, in ms. Default: 1000. */
9026
+ tickMs?: number;
9027
+ }
9028
+ /**
9029
+ * The open state and reasoning timer of one reasoning message.
9030
+ *
9031
+ * - It opens when streaming starts and closes by itself when it ends,
9032
+ * unless the user toggled it during that stream: then their choice stays.
9033
+ * Each new stream starts open again and forgets the earlier toggle.
9034
+ * - The elapsed time counts from the first stream start and updates every
9035
+ * tick while streaming. When streaming ends it takes the final time.
9036
+ *
9037
+ * Frameworks render from `getSnapshot()` and re-render when `subscribe()`
9038
+ * notifies. Call `setStreaming()` whenever the streaming state may have
9039
+ * changed, including once after mount. Call `dispose()` on unmount. The
9040
+ * controller stays usable after `dispose()`, so a remount (React Strict
9041
+ * Mode) can keep it: the next `setStreaming(true)` starts the timer again.
9042
+ *
9043
+ * @example
9044
+ * ```ts
9045
+ * const disclosure = new ɵReasoningDisclosure({ isStreaming });
9046
+ * disclosure.subscribe(() => render(disclosure.getSnapshot()));
9047
+ * disclosure.setStreaming(isStreaming);
9048
+ * // Header click, when the message has text:
9049
+ * disclosure.toggle();
9050
+ * ```
9051
+ */
9052
+ declare class ɵReasoningDisclosure {
9053
+ #private;
9054
+ constructor({
9055
+ isStreaming,
9056
+ tickMs
9057
+ }?: ɵReasoningDisclosureOptions);
9058
+ /** The current state. The same object until something changes. */
9059
+ getSnapshot: () => ɵReasoningDisclosureState;
9060
+ /** Calls `listener` when the state changes. Returns the unsubscribe function. */
9061
+ subscribe: (listener: () => void) => () => void;
9062
+ /** Tells the controller whether the model reasons in this message now. */
9063
+ setStreaming: (isStreaming: boolean) => void;
9064
+ /** Opens or closes the reasoning text, and keeps that after the stream. */
9065
+ toggle: () => void;
9066
+ /** Stops the timer. */
9067
+ dispose: () => void;
9068
+ }
7960
9069
  /** Input for {@link ɵgetWorkSummaryText}. */
7961
9070
  interface ɵWorkSummaryInput {
7962
9071
  /** The agent is still working on this reply. */
@@ -8007,8 +9116,8 @@ declare function ɵgetWorkSummaryText({
8007
9116
  type ɵUserMessageMediaPart = ImageInputPart | AudioInputPart | VideoInputPart | DocumentInputPart;
8008
9117
  /**
8009
9118
  * The text of a user message: the string content, or its text parts joined
8010
- * by newlines. Parts that are not text, and malformed parts from untyped
8011
- * data, add nothing.
9119
+ * by newlines. Parts that are not text, and malformed parts or content
9120
+ * that is not a list from untyped data, add nothing.
8012
9121
  */
8013
9122
  declare function ɵflattenUserMessageContent(content?: UserMessage["content"]): string;
8014
9123
  /** The image, audio, video, and document parts of a user message. */
@@ -8462,6 +9571,29 @@ declare function buildOpenGenerativeUIContexts({
8462
9571
  description: string;
8463
9572
  value: string;
8464
9573
  }[];
9574
+ /**
9575
+ * Add the Open Generative UI agent context entries (see
9576
+ * {@link buildOpenGenerativeUIContexts}) to a core.
9577
+ *
9578
+ * @returns A function that removes the entries this call added.
9579
+ *
9580
+ * @example
9581
+ * ```ts
9582
+ * const remove = ɵaddOpenGenerativeUIContexts(core, { designSkill, sandboxFunctions });
9583
+ * // when the feature turns off or the options change
9584
+ * remove();
9585
+ * ```
9586
+ */
9587
+ declare function addOpenGenerativeUIContexts(core: {
9588
+ addContext(entry: {
9589
+ description: string;
9590
+ value: string;
9591
+ }): string;
9592
+ removeContext(id: string): void;
9593
+ }, options: {
9594
+ designSkill?: string;
9595
+ sandboxFunctions: readonly OpenGenerativeUISandboxFunction[];
9596
+ }): () => void;
8465
9597
  //#endregion
8466
9598
  //#region src/open-generative-ui/placeholder.d.ts
8467
9599
  /** How long each placeholder message shows before the next one. */
@@ -9767,5 +10899,5 @@ interface OpenThreadRegistration {
9767
10899
  unregister(): void;
9768
10900
  }
9769
10901
  //#endregion
9770
- export { GENERATE_SANDBOXED_UI_ARGS_SCHEMA as $, A2UISurfaceContent as $a, ɵProviderConfigDiagnosticCode as $c, getLatestTurnKey as $i, ɵRendererRegistryInit as $l, ɵDockedSidebar as $n, emitInspectorActiveThread as $o, ɵMessageViewModel as $r, ɵobservePhoenixEvent$ as $s, ɵwatchKeyboardState as $t, FrontendToolHandlerContext as $u, ɵThreadSelectors as A, ɵfindActivityRenderer as Aa, on as Ac, ɵbuildUserMessageContent as Ai, ɵInterruptRunner as Al, ɵThreadsInput as An, A2UI_SURFACE_ACTIVITY_TYPE as Ao, ɵfitTextareaHeight as Ar, ɵmemoryRestEvents as As, ɵBranchNavInput as At, CopilotKitCoreConnectAgentParams as Au, ɵthreadAdapterEvents as B, ɵformatLabel as Ba, ɵRuntimeInfo as Bc, ToolCallLayout as Bi, ɵInterruptState as Bl, ɵINLINE_FEATURE_WARNING_STYLE as Bn, flattenInformationalCards as Bo, ɵcomposerButtonState as Br, MemoryErrorCode as Bs, ɵgetWorkSummaryText as Bt, ContextStore as Bu, createThreadStore as C, ɵparseToolCallArguments as Ca, createActionGroup as Cc, ɵtranscriptionErrorMessageKey as Ci, CustomMessageRendererPosition as Cl, ɵcreateThreadsDrawerActions as Cn, getA2UIOperationSurfaceId as Co, ɵCOMPOSER_DEFAULT_MAX_ROWS as Cr, ɵMemoryRuntimeContext as Cs, ɵInspectorKiteGradient as Ct, getWebMCPModelContext as Cu, ɵThreadEnvironment as D, ɵActivityRendererQuery as Da, createStore as Dc, ɵThreadSwitchCoordinator as Di, ɵInterruptController as Dl, ɵThreadSummary as Dn, A2UI_DEFAULT_SURFACE_ID as Do, ɵComposerLayout as Dr, ɵmemoryAdapterEvents as Ds, ɵinspectorKiteIcon as Dt, CopilotKitHeadersSource as Du, ɵThread as E, ɵActivityRendererLookup as Ea, createSelector as Ec, ɵThreadSelectionInput as Ei, ToolCallRendererDef as El, ɵtoDrawerThread as En, surfaceHasRenderableContent as Eo, ɵComposerElements as Er, ɵmapMemoryMetadataEvent as Es, ɵinspectorKiteFill as Et, CopilotKitHeaderResolutionError as Eu, ɵselectIsFetchingNextPage as F, ɵresolveCustomMessageRenderers as Fa, IntelligenceAgentConfig as Fc, TOOL_CALL_STATUS_ICONS as Fi, InterruptHandlerProps as Fl, CopilotIconName as Fn, SurfaceSegment as Fo, ɵComposerMode as Fr, ɵselectMemoriesIsMutating as Fs, ɵflattenUserMessageContent as Ft, RunHandler as Fu, PlaceholderCycler as G, A2UIDebugExposure as Ga, ɵLearningAutoStarter as Gc, TurnOpenState as Gi, ɵGenerativeUIDebugFunction as Gl, ɵLicenseBannerSpec as Gn, MarkdownSegment as Go, ɵresolveComposerKey as Gr, ɵPhoenixChannelSession as Gs, ɵKeyboardState as Gt, CopilotKitCoreRegisterProxiedAgentResult as Gu, cn as H, A2UIActivityControllerOptions as Ha, ɵThreadBaselineResetOptions as Hc, ToolCallRendererNamesOptions as Hi, ɵPendingInterrupt as Hl, ɵLICENSE_BANNER_STYLE as Hn, prepareSurfaceOperations as Ho, ɵflattenCommandItems as Hr, isRetryableStatus as Hs, ɵshouldShowAssistantToolbar as Ht, AgentRegistry as Hu, ɵselectIsMutating as I, ɵresolveToolCallRenderer as Ia, RunCompletionAware as Ic, TOOL_CALL_STATUS_LABEL_KEYS as Ii, InterruptRenderProps as Il, CopilotIconNode as In, classifySurfaceCards as Io, ɵRunnableCommand as Ir, ɵselectMemoriesRealtimeStatus as Is, ɵformatReasoningDurationLabel as It, ensureObjectArgs as Iu, OPEN_GENERATIVE_UI_SANDBOX_FUNCTIONS_CONTEXT_DESCRIPTION as J, A2UIProgressPhase as Ja, ɵCOPILOT_CLOUD_PUBLIC_API_KEY_HEADER as Jc, countFailedToolCalls as Ji, ɵGenerativeUIDebugSnapshot as Jl, ɵgetLicenseBannerSpec as Jn, InspectorActiveThreadPayload as Jo, ɵLastUserMessageState as Jr, ɵPhoenixSocketLike as Js, ɵinitialKeyboardState as Jt, ProxiedCopilotRuntimeAgentConfig as Ju, PlaceholderCyclerSnapshot as K, A2UILifecycle as Ka, ɵtoLearningConfig as Kc, TurnWork as Ki, ɵGenerativeUIDebugPromptSection as Kl, ɵLicenseBannerType as Kn, splitA2UIMarkdown as Ko, ɵresolveSlashKey as Kr, ɵPhoenixJoinOutcome as Ks, ɵMOBILE_MAX_WIDTH_QUERY as Kt, ɵRUNTIME_PROBE_TIMEOUT_MS as Ku, ɵselectThreads as L, CopilotChatDefaultLabels as La, isRunCompletionAware as Lc, ToolCallDisplayContextValue as Li, InterruptResolveFn as Ll, ɵcopilotIconSvgAttributes as Ln, extractCompleteArrayItems as Lo, ɵSlashKeyResult as Lr, MEMORY_ERROR_REGISTRY as Ls, ɵgetBranchNavState as Lt, parseToolArguments as Lu, ɵcreateThreadSelectors as M, ɵmatchActivityRenderer as Ma, select as Mc, ɵmessagesFingerprint as Mi, INTERRUPT_EVENT_NAME as Ml, ɵprojectThread as Mn, A2UIMarkdownOperation as Mo, ɵCommandMenuItem as Mr, ɵselectMemoriesAvailable as Ms, ɵCopyFeedback as Mt, CopilotKitCoreRunAgentParams as Mu, ɵselectFetchMoreError as N, ɵresolveActivityRenderer as Na, AgentThreadLockedError as Nc, CopilotChatToolCallDisplay as Ni, InterruptCancelFn as Nl, CopilotIconData as Nn, ChildIdsOf as No, ɵComposerInput as Nr, ɵselectMemoriesError as Ns, ɵUserMessageMediaPart as Nt, CopilotKitCoreRunToolParams as Nu, ɵThreadMetadataEvent as O, ɵCustomMessageRunSource as Oa, empty as Oc, ɵAttachmentQueue as Oi, ɵInterruptControllerOptions as Ol, ɵThreadsController as On, A2UI_OPERATIONS_KEY as Oo, ɵTextareaMetrics as Or, ɵmemoryDomainEvents as Os, ɵinspectorShortcuts as Ot, ɵwithHeaderDefaults as Ou, ɵselectHasNextPage as P, ɵresolveCustomMessageRenderContext as Pa, IntelligenceAgent as Pc, ReasoningDuration as Pi, InterruptEvent as Pl, CopilotIconDefinition as Pn, ChildWalkOptions as Po, ɵComposerKeyEvent as Pr, ɵselectMemoriesIsLoading as Ps, ɵWorkSummaryInput as Pt, CopilotKitCoreRunToolResult as Pu, isOpenGenerativeUIActive as Q, A2UISkeletonPart as Qa, ɵProviderConfigDiagnostic as Qc, getArgumentPreview as Qi, ɵRendererRegistry as Ql, ɵDialogFocusOptions as Qn, createInspectorThreadRequestId as Qo, ɵMessageViewInput as Qr, ɵjoinPhoenixChannel$ as Qs, ɵreadKeyboardState as Qt, FrontendTool as Qu, ɵselectThreadsError as R, CopilotChatLabels as Ra, ɵisHttpAgent as Rc, ToolCallEntry as Ri, ɵInterruptDecision as Rl, ɵcopilotIcons as Rn, extractFenceOperations as Ro, ɵSlashMenuState as Rr, MemoryError as Rs, ɵgetUserMessageMediaFilename as Rt, CopilotKitCoreContinuationHandoff as Ru, ThreadRunActivityNotification as S, ɵnormalizeToolCallStatus as Sa, StoreLifecycleAction as Sc, ɵtranscribeAudio as Si, CustomMessageRendererDef as Sl, ɵThreadsDrawerThreads as Sn, A2UIOperation$1 as So, ɵrmsAmplitude as Sr, ɵMemoryMetadataEvent as Ss, ɵInspectorKiteArtwork as St, WebMCPRegistry as Su, ɵTHREAD_REQUEST_TIMEOUT_MS as T, ɵActivityRendererFailureReason as Ta, createReducer as Tc, ɵThreadSelection as Ti, ToolCallRenderProps as Tl, ɵgetThreadsDrawerElementProps as Tn, groupA2UIOperationsBySurface as To, ɵComposerAutosizeOptions as Tr, ɵMemoryStore as Ts, ɵInspectorKiteStop as Tt, isAbortError as Tu, shallowEqualRecord as U, A2UIActivitySnapshot as Ua, ɵclearAgentThreadCursors as Uc, ToolCallRowStatus as Ui, ɵclearAgentInterruptState as Ul, ɵLicenseBannerDetails as Un, segmentSurfaceProse as Uo, ɵnextSlashIndex as Ur, ɵPhoenixChannelLike as Us, ɵAutoScrollMode as Ut, CopilotKitCoreAddAgentParams as Uu, ClassValue as V, A2UIActivityController as Va, ɵRuntimeInfoStore as Vc, ToolCallRendererNames as Vi, ɵInterruptToolResult as Vl, ɵLICENSE_BANNER_OFFSET as Vn, getMarkdownOperationSurfaceId as Vo, ɵfilterCommands as Vr, MemoryErrorRegistryEntry as Vs, ɵhasAssistantMessageText as Vt, ScopedContext as Vu, PLACEHOLDER_CYCLE_MS as W, A2UIActivityView as Wa, ɵresetAgentThreadBaseline as Wc, ToolCallSegment as Wi, ɵgetAgentInterruptState as Wl, ɵLicenseBannerSeverity as Wn, A2UI_FENCE_LANGUAGE as Wo, ɵparseSlashQuery as Wr, ɵPhoenixChannelOptions as Ws, ɵKEYBOARD_OPEN_THRESHOLD_PX as Wt, CopilotKitCoreRegisterProxiedAgentParams as Wu, buildOpenGenerativeUIContexts as X, A2UIScheduler as Xa, ɵCopilotKitLearningOptions as Xc, formatToolNames as Xi, ɵGenerativeUIDebugSurface as Xl, ɵresolveLicenseState as Xn, InspectorViewThreadPayload as Xo, ɵgetChatViewState as Xr, ɵPhoenixSocketSession as Xs, ɵnormalizeAutoScroll as Xt, CopilotRuntimeTransport as Xu, OpenGenerativeUISandboxFunction as Y, A2UIRecoveryOptions as Ya, ɵCOPILOT_CLOUD_RUNTIME_URL as Yc, formatReasoningDuration as Yi, ɵGenerativeUIDebugSource as Yl, ɵreserveLicenseBannerOffset as Yn, InspectorStopViewingPayload as Yo, ɵcreateLastUserMessageTracker as Yr, ɵPhoenixSocketOptions as Ys, ɵisMobileViewport as Yt, CopilotKitMessageFilter as Yu, createOpenGenerativeUITool as Z, A2UISkeletonBar as Za, ɵCopilotKitProviderBaseOptions as Zc, formatWorkDuration as Zi, ɵRendererKind as Zl, ɵresolveThreadsLicense as Zn, InspectorViewThreadResultPayload as Zo, ɵgetLastUserMessageId as Zr, ɵPhoenixSocketSignal as Zs, ɵpinMessageToTop as Zt, DynamicSuggestionsConfig as Zu, ScopedProperties as _, ɵcomponentToolDescription as _a, NonDispatchingEffectOptions as _c, TranscriptionError as _i, ɵbuildHumanInTheLoopTool as _l, ɵsubscribeToLearningFeedbackEnabled as _n, A2UIDiagnosedSurface as _o, ɵmorphViewTransition as _r, MemoryRealtimeStatus as _s, OPEN_GENERATIVE_UI_ACTIVITY_TYPE as _t, ɵresolveAgentThreadId as _u, CopilotKitCore as a, getToolResults as aa, ActionConfig as ac, StaticSuggestionsConfig as ad, ɵChatSubmitter as ai, ɵpublicKeyHeaderDefaults as al, ɵFeedbackCommentVia as an, formatA2UIRetryLabel as ao, ɵPopupDismissOptions as ar, onInspectorStopViewing as as, OpenGenerativeUIState as at, ɵAgentContextInput as au, SubscribeToAgentSubscriber as b, ɵgetToolCallBadge as ba, Selector as bc, TranscriptionResult as bi, ActivityMessageRendererDef as bl, ɵThreadsDrawerCallbacks as bn, diagnoseUnpaintedSurface as bo, ɵAudioRecorderState as br, createMemoryStore as bs, ɵHoverMenuController as bt, ɵvalidateAgentBinding as bu, CopilotKitCoreErrorEvent as c, isTurnWorkOpen as ca, ActionFromCreators as cc, SuggestionsConfig as cd, ɵTRANSCRIPTION_ERROR_TIMEOUT_MS as ci, ɵtoolRendererShapeChanged as cl, ɵMessageFeedback as cn, resolveA2UIDebugExposure as co, ɵbindDialogFocus as cr, ɵInspectorThreadOverride as cs, WebsandboxConstructor as ct, ɵserializeContextValue as cu, CopilotKitCoreGetSuggestionsResult as d, recordWorkTime as da, AnyAction as dc, WebMCPToolAnnotations as dd, ɵcreateChatSubmitter as di, ɵSuggestionsBindingOptions as dl, ɵMessageFeedbackScope as dn, A2UIActionInterceptor as do, ɵcreateDockedSidebar as dr, ɵCOPILOTKIT_FEATURES as ds, loadWebsandbox as dt, ɵAgentResolveInput as du, getToolCallGroupState as ea, ɵobservePhoenixJoinOutcome$ as ec, FrontendToolReconnectBehavior as ed, ɵcreateMessageViewModel as ei, ɵProviderConfigInput as el, ɵwatchMobileViewport as en, A2UI_LIFECYCLE_TEXT as eo, ɵDockedSidebarPlacement as er, emitInspectorStopViewing as es, OPEN_GENERATIVE_UI_CONTENT_SCHEMA as et, ɵLearnFromUserActionFields as eu, CopilotKitCoreRuntimeConnectionStatus as f, stringifyToolCallAttr as fa, DispatchingEffect as fc, WebMCPToolConfig as fd, ɵresolveChatNotice as fi, ɵSuggestionsConfigInput as fl, ɵgetMessageFeedback as fn, A2UIClientEvent as fo, ɵcreateObjectUrlFromSource as fr, ɵCopilotKitFeature as fs, extractCompleteStyles as ft, ɵAgentResolver as fu, JsonValue$1 as g, ɵbuildToolCallRenderProps as ga, NonDispatchingEffect as gc, TranscriptionCore as gi, ɵHumanInTheLoopRegistry as gl, ɵsetMessageFeedback as gn, toA2UIClientEvent as go, ɵisScrolledToBottom as gr, MemoryKind as gs, GenerateSandboxedUiArgs as gt, ɵresolveAgentId as gu, CopilotKitCoreSubscription as h, ɵToolCallCardStatus as ha, EmptyActionConfig as hc, ɵwaitForActiveRun as hi, ɵHITL_ABORTED_MESSAGE as hl, ɵresetMessageFeedbackCache as hn, runA2UIAction as ho, ɵdockedSidebarRegistryFor as hr, MemoryChanges as hs, GENERATE_SANDBOXED_UI_TOOL_NAME as ht, ɵgetAgentResolver as hu, TrajectoryStartOptions as i, getToolCallRowStatus as ia, ɵphoenixSocket$ as ic, RuntimeMode$1 as id, ɵChatRunScope as ii, ɵToolRendererShape as il, ɵFeedbackCommentState as in, formatA2UIDebugPayload as io, ɵPOPUP_ANIMATION_MS as ir, onInspectorActiveThread as is, OpenGenerativeUIPhase as it, ɵrecordAnnotation as iu, ɵThreadStore as j, ɵgetCustomMessageRenderProps as ja, props as jc, ɵdeduplicateMessages as ji, ɵInterruptSnapshot as jl, ɵThreadsSnapshot as jn, RENDER_A2UI_TOOL_NAME as jo, ɵmeasureTextarea as jr, ɵselectMemories as js, ɵCOPY_FEEDBACK_RESET_MS as jt, CopilotKitCoreGetToolParams as ju, ɵThreadRuntimeContext as k, ɵdescribeActivityRendererFailure as ka, ofType as kc, ɵClipboardItem as ki, ɵInterruptExpiredError as kl, ɵThreadsCore as kn, A2UI_ROOT_COMPONENT_ID as ko, ɵcreateComposerAutosize as kr, ɵmemoryReducer as ks, ɵAssistantToolbarInput as kt, CopilotKitCoreCatalogComponent as ku, CopilotKitCoreErrorHandler as l, isTurnWorking as la, ActionGroupConfig as lc, ThreadEndpointRuntimeInfo$1 as ld, ɵappendTranscript as li, ɵStaticSuggestionInput as ll, ɵMessageFeedbackControls as ln, A2UIActionAgent as lo, ɵbindPopupDismiss as lr, ɵInspectorThreadOverrideInput as ls, WebsandboxInstance as lt, ɵALL_AGENT_UPDATES as lu, CopilotKitCoreSubscriber as m, toolCallAppearance as ma, Effect as mc, ɵtranscriptionErrorNotice as mi, ɵsubscribeToAgentSuggestions as ml, ɵisLearningFeedbackEnabled as mn, A2UIUserAction as mo, ɵdimensionToCss as mr, Memory as ms, DEFAULT_OPEN_GENERATIVE_UI_DESIGN_SKILL as mt, ɵagentUpdateHandlers as mu, LegacyLearningConfig as n, getToolCallPreview as na, ɵobservePhoenixSocketSignals$ as nc, IntelligenceRuntimeInfo$1 as nd, ɵshouldShowMessageCursor as ni, ɵResolvedProviderConfig as nl, ɵFeedbackCommentController as nn, A2UI_SKELETON_ROWS as no, ɵDockedSidebarState as nr, emitInspectorViewThreadResult as ns, OpenGenerativeUIController as nt, ɵRecordAnnotationResult as nu, CopilotKitCoreConfig as o, getTurnWork as oa, ActionCreator as oc, Suggestion as od, ɵChatSubmitterOptions as oi, ɵreportProviderConfigDiagnostics as ol, ɵMESSAGE_FEEDBACK_EVENT_NAME as on, getA2UIProgressPhase as oo, ɵSCROLL_BOTTOM_THRESHOLD_PX as or, onInspectorViewThread as os, SandboxFunctionHandle as ot, ɵJsonSerializable as ou, CopilotKitCoreStopAgentParams as p, stringifyToolCallPayload as pa, DispatchingEffectOptions as pc, ɵstopAgentWithFallback as pi, ɵbindSuggestionsConfig as pl, ɵgetMessageFeedbackControls as pn, A2UIProcessorAction as po, ɵdecodeTextSource as pr, ɵisCopilotKitFeature as ps, processPartialHtml as pt, ɵAgentUpdateFlag as pu, OPEN_GENERATIVE_UI_DESIGN_CONTEXT_DESCRIPTION as q, A2UILifecycleStatus as qa, ɵA2UIBaseOptions as qc, WorkTime as qi, ɵGenerativeUIDebugRun as ql, ɵgetInlineFeatureWarningSpec as qn, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID as qo, ɵChatViewStateInput as qr, ɵPhoenixPushLike as qs, ɵPinMessageToTopOptions as qt, ProxiedCopilotRuntimeAgent as qu, OpenThreadRegistration as r, getToolCallRendererNames as ra, ɵphoenixChannel$ as rc, RuntimeLicenseStatus$1 as rd, ɵChatNotice as ri, ɵSTABLE_ARRAY_WARNINGS as rl, ɵFeedbackCommentControllerOptions as rn, A2UI_SURFACE_CONTENT_SCHEMA as ro, ɵDockedSidebarTransition as rr, isInspectorThreadBridgeEnabled as rs, OpenGenerativeUIControllerOptions as rt, ɵbuildLearnFromUserActionPayload as ru, CopilotKitCoreErrorCode as s, getWorkOpenState as sa, ActionFromCreator as sc, SuggestionAvailability as sd, ɵChatSubmitterSnapshot as si, ɵresolveProviderConfig as sl, ɵMESSAGE_FEEDBACK_MAX_COMMENT_LENGTH as sn, readA2UILifecycle as so, ɵSidebarPosition as sr, onInspectorViewThreadResult as ss, SandboxLocalApi as st, ɵgetAgentCapabilities as su, LearningConfig as t, getToolCallLayouts as ta, ɵobservePhoenixSocketHealth$ as tc, InspectorMetadataV1$1 as td, ɵduplicateMessagesWarning as ti, ɵReportProviderConfigDiagnosticsOptions as tl, ɵFEEDBACK_COMMENT_CLOSE_DELAY_MS as tn, A2UI_RECOVERY_DEFAULTS as to, ɵDockedSidebarRegistry as tr, emitInspectorViewThread as ts, OpenGenerativeUISchema as tt, ɵRecordAnnotationArgs as tu, CopilotKitCoreFriendsAccess as u, pluralize as ua, ActionGroupResult as uc, ToolCallStatus as ud, ɵbuildUserMessage as ui, ɵSuggestionsBinding as ul, ɵMessageFeedbackRating as un, A2UIActionCore as uo, ɵcanPreviewDocument as ur, ɵInspectorThreadOverrideSnapshot as us, WebsandboxLoader as ut, ɵAgentBindingInput as uu, StartResult$1 as v, ɵdescribeUnrenderedToolCalls as va, PropsActionConfig as vc, TranscriptionErrorCode as vi, ɵhitlRenderProps as vl, ɵsubscribeToMessageFeedback as vn, A2UI_PAINT_FALLBACK_MS as vo, ɵAudioRecorder as vr, MemoryScope as vs, OpenGenerativeUIContent as vt, ɵsnapshotAgentState as vu, ɵMAX_SOCKET_RETRIES as w, ɵresolveToolCallAgentId as wa, createEffect as wc, ɵConnectionWaitResult as wi, HumanInTheLoopRenderProps as wl, ɵfindChatInput as wn, getA2UIOperations as wo, ɵComposerAutosize as wr, ɵMemoryState as ws, ɵInspectorKitePath as wt, SuggestionEngine as wu, ɵCopilotKitCoreConfigPatch as x, ɵgetToolCallStatus as xa, Store as xc, ɵTranscriptionErrorLabelKey as xi, CustomMessageRenderProps as xl, ɵThreadsDrawerConfig as xn, diagnoseUnresolvedRoot as xo, ɵcreateWaveformRenderer as xr, ɵMemoryEnvironment as xs, ɵHoverMenuState as xt, WebMCPModelContext as xu, SubscribeToAgentOptions as y, ɵfindToolMessage as ya, Reducer as yc, TranscriptionErrorInfo as yi, ActivityMessageRenderProps as yl, ɵDrawerThread as yn, diagnoseMissingSurface as yo, ɵAudioRecorderError as yr, NewMemory as ys, ɵHOVER_MENU_CLOSE_DELAY_MS as yt, ɵsubscribeToAgentUpdates as yu, ɵselectThreadsIsLoading as z, ɵformatCountLabel as za, completePartialMarkdown as zc, ToolCallGroupAppearance as zi, ɵInterruptEvent as zl, LicenseStateInput as zn, extractStringField as zo, ɵclampSlashIndex as zr, MemoryErrorCategory as zs, ɵgetUserMessageMediaParts as zt, StateManager as zu };
9771
- //# sourceMappingURL=learning-bridge-DyZ7rXrG.d.cts.map
10902
+ export { isOpenGenerativeUIActive as $, getToolCallRowStatus as $a, ɵobservePhoenixEvent$ as $c, RunHandler as $d, ɵChatRunScope as $i, ɵAssembledHumanInTheLoop as $l, ɵINLINE_FEATURE_WARNING_STYLE as $n, A2UISurfaceContent as $o, ɵComposerAutosizeOptions as $r, emitInspectorActiveThread as $s, ɵStickToBottom as $t, InterruptHandlerProps as $u, ɵThreadSelectors as A, TOOL_CALL_STATUS_ICONS as Aa, ɵmemoryRestEvents as Ac, ɵAgentResolver as Ad, WebMCPToolConfig as Af, ɵresolveSlashKey as Ai, on as Al, ɵsubscribeToLearningFeedbackEnabled as An, ɵgetCustomMessageRenderProps as Ao, ɵbindDialogFocus as Ar, A2UI_SURFACE_ACTIVITY_TYPE as As, ɵAssistantToolbarInput as At, ɵSuggestionsConfigInput as Au, ɵthreadAdapterEvents as B, TurnOpenState as Ba, MemoryErrorCode as Bc, WebMCPRegistry as Bd, ɵcreateMessageViewModel as Bi, isContentPart as Bl, ɵThreadSummary as Bn, ɵformatLabel as Bo, ɵisFocusVisible as Br, flattenInformationalCards as Bs, ɵformatReasoningDurationLabel as Bt, CustomMessageRendererDef as Bu, createThreadStore as C, ɵAttachmentQueue as Ca, ɵMemoryRuntimeContext as Cc, ɵAgentContextInput as Cd, StaticSuggestionsConfig as Cf, ɵfilterCommands as Ci, createActionGroup as Cl, ɵMessageFeedbackScope as Cn, ɵtoDefaultToolCallStatus as Co, ɵPopupDismissOptions as Cr, getA2UIOperationSurfaceId as Cs, ɵInspectorKiteArtwork as Ct, ɵresolveA2UIActivation as Cu, ɵThreadEnvironment as D, ɵmessagesFingerprint as Da, ɵmemoryAdapterEvents as Dc, ɵALL_AGENT_UPDATES as Dd, ThreadEndpointRuntimeInfo$1 as Df, ɵnormalizeToolsMenu as Di, createStore as Dl, ɵisOwnFeedbackThumb as Dn, ɵCustomMessageRunSource as Do, ɵSIDEBAR_TRANSITION_MS as Dr, A2UI_DEFAULT_SURFACE_ID as Ds, ɵinspectorKiteFill as Dt, ɵStaticSuggestionInput as Du, ɵThread as E, ɵdeduplicateMessages as Ea, ɵmapMemoryMetadataEvent as Ec, ɵserializeContextValue as Ed, SuggestionsConfig as Ef, ɵnextSlashIndex as Ei, createSelector as El, ɵisLearningFeedbackEnabled as En, ɵActivityRendererQuery as Eo, ɵSIDEBAR_DEFAULT_WIDTH as Er, surfaceHasRenderableContent as Es, ɵInspectorKiteStop as Et, ɵtoolRendererShapeChanged as Eu, ɵselectIsFetchingNextPage as F, ToolCallLayout as Fa, ɵselectMemoriesIsMutating as Fc, ɵresolveAgentThreadId as Fd, ɵcreateLastUserMessageTracker as Fi, IntelligenceAgentConfig as Fl, ɵThreadsDrawerThreads as Fn, ɵresolveCustomMessageRenderers as Fo, ɵcreateObjectUrlFromSource as Fr, SurfaceSegment as Fs, ɵReasoningDisclosureOptions as Ft, ɵbuildHumanInTheLoopTool as Fu, PlaceholderCycler as G, formatToolNames as Ga, ɵPhoenixChannelSession as Gc, CopilotKitHeadersSource as Gd, ɵChatConnectionHandle as Gi, ɵThreadBaselineResetOptions as Gl, ɵprojectThread as Gn, A2UIDebugExposure as Go, ɵwatchElementWidth as Gr, MarkdownSegment as Gs, ɵgetWorkSummaryText as Gt, ɵInterruptController as Gu, cn as H, WorkTime as Ha, isRetryableStatus as Hc, SuggestionEngine as Hd, ɵshouldShowMessageCursor as Hi, ɵregisterFrontendTools as Hl, ɵThreadsCore as Hn, A2UIActivityControllerOptions as Ho, ɵmorphViewTransition as Hr, prepareSurfaceOperations as Hs, ɵgetReasoningHeaderLabel as Ht, HumanInTheLoopRenderProps as Hu, ɵselectIsMutating as I, ToolCallRendererNames as Ia, ɵselectMemoriesRealtimeStatus as Ic, ɵsnapshotAgentState as Id, ɵgetChatViewState as Ii, RunCompletionAware as Il, ɵcreateThreadsDrawerActions as In, ɵresolveToolCallRenderer as Io, ɵdecodeTextSource as Ir, classifySurfaceCards as Is, ɵReasoningDisclosureState as It, ɵhitlRenderProps as Iu, OPEN_GENERATIVE_UI_SANDBOX_FUNCTIONS_CONTEXT_DESCRIPTION as J, getLatestTurnKey as Ja, ɵPhoenixSocketLike as Jc, CopilotKitCoreConnectAgentParams as Jd, ɵChatErrorEvent as Ji, ɵLearningAutoStarter as Jl, CopilotIconName as Jn, A2UIProgressPhase as Jo, ɵAudioRecorderState as Jr, InspectorActiveThreadPayload as Js, ɵAutoScrollMode as Jt, ɵInterruptRunner as Ju, PlaceholderCyclerSnapshot as K, formatWorkDuration as Ka, ɵPhoenixJoinOutcome as Kc, ɵwithHeaderDefaults as Kd, ɵChatConnectionOptions as Ki, ɵclearAgentThreadCursors as Kl, CopilotIconData as Kn, A2UILifecycle as Ko, ɵAudioRecorder as Kr, splitA2UIMarkdown as Ks, ɵhasAssistantMessageText as Kt, ɵInterruptControllerOptions as Ku, ɵselectThreads as L, ToolCallRendererNamesOptions as La, MEMORY_ERROR_REGISTRY as Lc, ɵsubscribeToAgentUpdates as Ld, ɵgetLastUserMessageId as Li, isRunCompletionAware as Ll, ɵfindChatInput as Ln, CopilotChatDefaultLabels as Lo, ɵdimensionToCss as Lr, extractCompleteArrayItems as Ls, ɵUserMessageMediaPart as Lt, ActivityMessageRenderProps as Lu, ɵcreateThreadSelectors as M, ToolCallDisplayContextValue as Ma, ɵselectMemoriesAvailable as Mc, ɵagentUpdateHandlers as Md, ɵsyncRecorderToMode as Mi, select as Ml, ɵDrawerThread as Mn, ɵmatchActivityRenderer as Mo, ɵcanPreviewDocument as Mr, A2UIMarkdownOperation as Ms, ɵCOPY_FEEDBACK_RESET_MS as Mt, ɵsubscribeToAgentSuggestions as Mu, ɵselectFetchMoreError as N, ToolCallEntry as Na, ɵselectMemoriesError as Nc, ɵgetAgentResolver as Nd, ɵChatViewStateInput as Ni, AgentThreadLockedError as Nl, ɵThreadsDrawerCallbacks as Nn, ɵresolveActivityRenderer as No, ɵcreateDockedSidebar as Nr, ChildIdsOf as Ns, ɵCopyFeedback as Nt, ɵHITL_ABORTED_MESSAGE as Nu, ɵThreadMetadataEvent as O, CopilotChatToolCallDisplay as Oa, ɵmemoryDomainEvents as Oc, ɵAgentBindingInput as Od, ToolCallStatus as Of, ɵparseSlashQuery as Oi, empty as Ol, ɵresetMessageFeedbackCache as On, ɵdescribeActivityRendererFailure as Oo, ɵSidebarPosition as Or, A2UI_OPERATIONS_KEY as Os, ɵinspectorKiteIcon as Ot, ɵSuggestionsBinding as Ou, ɵselectHasNextPage as P, ToolCallGroupAppearance as Pa, ɵselectMemoriesIsLoading as Pc, ɵresolveAgentId as Pd, ɵLastUserMessageState as Pi, IntelligenceAgent as Pl, ɵThreadsDrawerConfig as Pn, ɵresolveCustomMessageRenderContext as Po, ɵcreateExitPresence as Pr, ChildWalkOptions as Ps, ɵReasoningDisclosure as Pt, ɵHumanInTheLoopRegistry as Pu, createOpenGenerativeUITool as Q, getToolCallRendererNames as Qa, ɵjoinPhoenixChannel$ as Qc, CopilotKitCoreRunToolResult as Qd, ɵChatNotice as Qi, ɵActivityRenderersInput as Ql, LicenseStateInput as Qn, A2UISkeletonPart as Qo, ɵComposerAutosize as Qr, createInspectorThreadRequestId as Qs, ɵPinMessageToTopOptions as Qt, InterruptEvent as Qu, ɵselectThreadsError as R, ToolCallRowStatus as Ra, MemoryError as Rc, ɵvalidateAgentBinding as Rd, ɵMessageViewInput as Ri, ɵisHttpAgent as Rl, ɵgetThreadsDrawerElementProps as Rn, CopilotChatLabels as Ro, ɵdockedSidebarRegistryFor as Rr, extractFenceOperations as Rs, ɵWorkSummaryInput as Rt, ActivityMessageRendererDef as Ru, ThreadRunActivityNotification as S, ɵThreadSwitchCoordinator as Sa, ɵMemoryMetadataEvent as Sc, ɵrecordAnnotation as Sd, RuntimeMode$1 as Sf, ɵcomposerButtonState as Si, StoreLifecycleAction as Sl, ɵMessageFeedbackRating as Sn, ɵresolveToolCallAgentId as So, ɵPOPUP_DEFAULT_WIDTH as Sr, A2UIOperation$1 as Ss, ɵHoverMenuState as St, ɵreportProviderConfigDiagnostics as Su, ɵTHREAD_REQUEST_TIMEOUT_MS as T, ɵbuildUserMessageContent as Ta, ɵMemoryStore as Tc, ɵgetAgentCapabilities as Td, SuggestionAvailability as Tf, ɵflattenToolsMenuForDisplay as Ti, createReducer as Tl, ɵgetMessageFeedbackControls as Tn, ɵActivityRendererLookup as To, ɵSCROLL_BOTTOM_THRESHOLD_PX as Tr, groupA2UIOperationsBySurface as Ts, ɵInspectorKitePath as Tt, ɵstableArrayPropWarning as Tu, shallowEqualRecord as U, countFailedToolCalls as Ua, ɵPhoenixChannelLike as Uc, isAbortError as Ud, ɵChatConnectHooks as Ui, ɵRuntimeInfo as Ul, ɵThreadsInput as Un, A2UIActivitySnapshot as Uo, ɵnextTabStop as Ur, segmentSurfaceProse as Us, ɵgetUserMessageMediaFilename as Ut, ToolCallRenderProps as Uu, ClassValue as V, TurnWork as Va, MemoryErrorRegistryEntry as Vc, getWebMCPModelContext as Vd, ɵduplicateMessagesWarning as Vi, ɵFrontendToolRenderer as Vl, ɵThreadsController as Vn, A2UIActivityController as Vo, ɵisScrolledToBottom as Vr, getMarkdownOperationSurfaceId as Vs, ɵgetBranchNavState as Vt, CustomMessageRendererPosition as Vu, PLACEHOLDER_CYCLE_MS as W, formatReasoningDuration as Wa, ɵPhoenixChannelOptions as Wc, CopilotKitHeaderResolutionError as Wd, ɵChatConnection as Wi, ɵRuntimeInfoStore as Wl, ɵThreadsSnapshot as Wn, A2UIActivityView as Wo, ɵwatchElementHeight as Wr, A2UI_FENCE_LANGUAGE as Ws, ɵgetUserMessageMediaParts as Wt, ToolCallRendererDef as Wu, addOpenGenerativeUIContexts as X, getToolCallLayouts as Xa, ɵPhoenixSocketSession as Xc, CopilotKitCoreRunAgentParams as Xd, ɵimplementsConnect as Xi, ɵA2UIActivationInput as Xl, ɵcopilotIconSvgAttributes as Xn, A2UIScheduler as Xo, ɵrmsAmplitude as Xr, InspectorViewThreadPayload as Xs, ɵKeyboardState as Xt, INTERRUPT_EVENT_NAME as Xu, OpenGenerativeUISandboxFunction as Y, getToolCallGroupState as Ya, ɵPhoenixSocketOptions as Yc, CopilotKitCoreGetToolParams as Yd, ɵFreshThreadId as Yi, ɵtoLearningConfig as Yl, CopilotIconNode as Yn, A2UIRecoveryOptions as Yo, ɵcreateWaveformRenderer as Yr, InspectorStopViewingPayload as Ys, ɵKEYBOARD_OPEN_THRESHOLD_PX as Yt, ɵInterruptSnapshot as Yu, buildOpenGenerativeUIContexts as Z, getToolCallPreview as Za, ɵPhoenixSocketSignal as Zc, CopilotKitCoreRunToolParams as Zd, ɵsubscribeToAgentErrors as Zi, ɵA2UIBaseOptions as Zl, ɵcopilotIcons as Zn, A2UISkeletonBar as Zo, ɵCOMPOSER_DEFAULT_MAX_ROWS as Zr, InspectorViewThreadResultPayload as Zs, ɵMOBILE_MAX_WIDTH_QUERY as Zt, InterruptCancelFn as Zu, ScopedProperties as _, ɵtranscribeAudio as _a, MemoryRealtimeStatus as _c, ɵRendererRegistryInit as _d, FrontendToolHandlerContext as _f, ɵRunnableCommand as _i, NonDispatchingEffectOptions as _l, ɵFeedbackThumbHandlers as _n, ɵfindToolMessage as _o, ɵElementHeightState as _r, A2UIDiagnosedSurface as _s, GenerateSandboxedUiArgs as _t, ɵassembleHumanInTheLoop as _u, CopilotKitCore as a, ɵbuildUserMessage as aa, onInspectorStopViewing as ac, ɵInterruptToolResult as ad, ScopedContext as af, ɵmeasureTextarea as ai, ActionConfig as al, ɵpinMessageToTop as an, pluralize as ao, ɵLicenseBannerType as ar, formatA2UIRetryLabel as as, OpenGenerativeUIPhase as at, ɵProviderConfigDiagnosticCode as au, SubscribeToAgentSubscriber as b, ɵThreadSelection as ba, createMemoryStore as bc, ɵRecordAnnotationResult as bd, IntelligenceRuntimeInfo$1 as bf, ɵToolsMenuDisplayEntry as bi, Selector as bl, ɵMessageFeedback as bn, ɵnormalizeToolCallStatus as bo, ɵPOPUP_ANIMATION_MS as br, diagnoseUnpaintedSurface as bs, ɵHOVER_MENU_CLOSE_DELAY_MS as bt, ɵassembleProviderTools as bu, CopilotKitCoreErrorEvent as c, ɵstopAgentWithFallback as ca, ɵInspectorThreadOverride as cc, ɵgetAgentInterruptState as cd, CopilotKitCoreRegisterProxiedAgentParams as cf, ɵComposerControllerInputs as ci, ActionFromCreators as cl, ɵwatchMobileViewport as cn, stringifyToolCallPayload as co, ɵreserveLicenseBannerOffset as cr, resolveA2UIDebugExposure as cs, SandboxLocalApi as ct, ɵProviderHumanInTheLoop as cu, CopilotKitCoreGetSuggestionsResult as d, TranscriptionCore as da, ɵCOPILOTKIT_FEATURES as dc, ɵGenerativeUIDebugRun as dd, ProxiedCopilotRuntimeAgent as df, ɵComposerKeyAction as di, AnyAction as dl, ɵFeedbackCommentControllerOptions as dn, ɵRawToolCallRenderProps as do, ɵDialogFocusOptions as dr, A2UIActionInterceptor as ds, WebsandboxLoader as dt, ɵReportProviderConfigDiagnosticsOptions as du, ɵChatSubmitter as ea, emitInspectorStopViewing as ec, InterruptRenderProps as ed, ensureObjectArgs as ef, ɵComposerElements as ei, ɵobservePhoenixJoinOutcome$ as el, ɵStickToBottomOptions as en, getToolResults as eo, ɵLICENSE_BANNER_OFFSET as er, A2UI_LIFECYCLE_TEXT as es, GENERATE_SANDBOXED_UI_ARGS_SCHEMA as et, ɵCOPILOT_CLOUD_PUBLIC_API_KEY_HEADER as eu, CopilotKitCoreRuntimeConnectionStatus as f, TranscriptionError as fa, ɵCopilotKitFeature as fc, ɵGenerativeUIDebugSnapshot as fd, ProxiedCopilotRuntimeAgentConfig as ff, ɵComposerKeyDownResult as fi, DispatchingEffect as fl, ɵFeedbackCommentState as fn, ɵToolCallCardStatus as fo, ɵDockedSidebar as fr, A2UIClientEvent as fs, loadWebsandbox as ft, ɵResolvedProviderConfig as fu, JsonValue$1 as g, ɵTranscriptionErrorLabelKey as ga, MemoryKind as gc, ɵRendererRegistry as gd, FrontendTool as gf, ɵModeRecorder as gi, NonDispatchingEffect as gl, ɵFeedbackThumbAttributes as gn, ɵdescribeUnrenderedToolCalls as go, ɵDockedSidebarTransition as gr, toA2UIClientEvent as gs, GENERATE_SANDBOXED_UI_TOOL_NAME as gt, ɵassembleActivityRenderers as gu, CopilotKitCoreSubscription as h, TranscriptionResult as ha, MemoryChanges as hc, ɵRendererKind as hd, DynamicSuggestionsConfig as hf, ɵComposerSnapshot as hi, EmptyActionConfig as hl, ɵFeedbackThumb as hn, ɵcomponentToolDescription as ho, ɵDockedSidebarState as hr, runA2UIAction as hs, DEFAULT_OPEN_GENERATIVE_UI_DESIGN_SKILL as ht, ɵToolRendererShape as hu, TrajectoryStartOptions as i, ɵappendTranscript as ia, onInspectorActiveThread as ic, ɵInterruptState as id, ContextStore as if, ɵfitTextareaHeight as ii, ɵphoenixSocket$ as il, ɵnormalizeAutoScroll as in, isTurnWorking as io, ɵLicenseBannerSpec as ir, formatA2UIDebugPayload as is, OpenGenerativeUIControllerOptions as it, ɵProviderConfigDiagnostic as iu, ɵThreadStore as j, TOOL_CALL_STATUS_LABEL_KEYS as ja, ɵselectMemories as jc, ɵAgentUpdateFlag as jd, ɵshowsComposerDisclaimer as ji, props as jl, ɵsubscribeToMessageFeedback as jn, ɵgetMessageRunStateSnapshot as jo, ɵbindPopupDismiss as jr, RENDER_A2UI_TOOL_NAME as js, ɵBranchNavInput as jt, ɵbindSuggestionsConfig as ju, ɵThreadRuntimeContext as k, ReasoningDuration as ka, ɵmemoryReducer as kc, ɵAgentResolveInput as kd, WebMCPToolAnnotations as kf, ɵresolveComposerKey as ki, ofType as kl, ɵsetMessageFeedback as kn, ɵfindActivityRenderer as ko, ɵTAB_STOP_SELECTOR as kr, A2UI_ROOT_COMPONENT_ID as ks, ɵinspectorShortcuts as kt, ɵSuggestionsBindingOptions as ku, CopilotKitCoreErrorHandler as l, ɵtranscriptionErrorNotice as la, ɵInspectorThreadOverrideInput as lc, ɵGenerativeUIDebugFunction as ld, CopilotKitCoreRegisterProxiedAgentResult as lf, ɵComposerControllerOptions as li, ActionGroupConfig as ll, ɵFEEDBACK_COMMENT_CLOSE_DELAY_MS as ln, toolCallAppearance as lo, ɵresolveLicenseState as lr, A2UIActionAgent as ls, WebsandboxConstructor as lt, ɵProviderRegistryInput as lu, CopilotKitCoreSubscriber as m, TranscriptionErrorInfo as ma, Memory as mc, ɵGenerativeUIDebugSurface as md, CopilotRuntimeTransport as mf, ɵComposerMode as mi, Effect as ml, ɵFeedbackKeyEvent as mn, ɵbuildToolCallRenderProps as mo, ɵDockedSidebarRegistry as mr, A2UIUserAction as ms, processPartialHtml as mt, ɵStableArrayProp as mu, LegacyLearningConfig as n, ɵChatSubmitterSnapshot as na, emitInspectorViewThreadResult as nc, ɵInterruptDecision as nd, CopilotKitCoreContinuationHandoff as nf, ɵTextareaMetrics as ni, ɵobservePhoenixSocketSignals$ as nl, ɵinitialKeyboardState as nn, getWorkOpenState as no, ɵLicenseBannerDetails as nr, A2UI_SKELETON_ROWS as ns, OpenGenerativeUISchema as nt, ɵCopilotKitLearningOptions as nu, CopilotKitCoreConfig as o, ɵcreateChatSubmitter as oa, onInspectorViewThread as oc, ɵPendingInterrupt as od, AgentRegistry as of, ɵCommandMenuItem as oi, ActionCreator as ol, ɵreadKeyboardState as on, recordWorkTime as oo, ɵgetInlineFeatureWarningSpec as or, getA2UIProgressPhase as os, OpenGenerativeUIState as ot, ɵProviderConfigInput as ou, CopilotKitCoreStopAgentParams as p, TranscriptionErrorCode as pa, ɵisCopilotKitFeature as pc, ɵGenerativeUIDebugSource as pd, CopilotKitMessageFilter as pf, ɵComposerKeyEvent as pi, DispatchingEffectOptions as pl, ɵFeedbackCommentVia as pn, ɵadaptDefaultToolCallRenderProps as po, ɵDockedSidebarPlacement as pr, A2UIProcessorAction as ps, extractCompleteStyles as pt, ɵSTABLE_ARRAY_WARNINGS as pu, OPEN_GENERATIVE_UI_DESIGN_CONTEXT_DESCRIPTION as q, getArgumentPreview as qa, ɵPhoenixPushLike as qc, CopilotKitCoreCatalogComponent as qd, ɵChatConnectionSnapshot as qi, ɵresetAgentThreadBaseline as ql, CopilotIconDefinition as qn, A2UILifecycleStatus as qo, ɵAudioRecorderError as qr, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID as qs, ɵshouldShowAssistantToolbar as qt, ɵInterruptExpiredError as qu, OpenThreadRegistration as r, ɵTRANSCRIPTION_ERROR_TIMEOUT_MS as ra, isInspectorThreadBridgeEnabled as rc, ɵInterruptEvent as rd, StateManager as rf, ɵcreateComposerAutosize as ri, ɵphoenixChannel$ as rl, ɵisMobileViewport as rn, isTurnWorkOpen as ro, ɵLicenseBannerSeverity as rr, A2UI_SURFACE_CONTENT_SCHEMA as rs, OpenGenerativeUIController as rt, ɵCopilotKitProviderBaseOptions as ru, CopilotKitCoreErrorCode as s, ɵresolveChatNotice as sa, onInspectorViewThreadResult as sc, ɵclearAgentInterruptState as sd, CopilotKitCoreAddAgentParams as sf, ɵComposerController as si, ActionFromCreator as sl, ɵwatchKeyboardState as sn, stringifyToolCallAttr as so, ɵgetLicenseBannerSpec as sr, readA2UILifecycle as ss, SandboxFunctionHandle as st, ɵProviderFrontendTool as su, LearningConfig as t, ɵChatSubmitterOptions as ta, emitInspectorViewThread as tc, InterruptResolveFn as td, parseToolArguments as tf, ɵComposerLayout as ti, ɵobservePhoenixSocketHealth$ as tl, ɵcreateStickToBottom as tn, getTurnWork as to, ɵLICENSE_BANNER_STYLE as tr, A2UI_RECOVERY_DEFAULTS as ts, OPEN_GENERATIVE_UI_CONTENT_SCHEMA as tt, ɵCOPILOT_CLOUD_RUNTIME_URL as tu, CopilotKitCoreFriendsAccess as u, ɵwaitForActiveRun as ua, ɵInspectorThreadOverrideSnapshot as uc, ɵGenerativeUIDebugPromptSection as ud, ɵRUNTIME_PROBE_TIMEOUT_MS as uf, ɵComposerInput as ui, ActionGroupResult as ul, ɵFeedbackCommentController as un, ɵDefaultToolCallRenderProps as uo, ɵresolveThreadsLicense as ur, A2UIActionCore as us, WebsandboxInstance as ut, ɵProviderToolRenderer as uu, StartResult$1 as v, ɵtranscriptionErrorMessageKey as va, MemoryScope as vc, ɵLearnFromUserActionFields as vd, FrontendToolReconnectBehavior as vf, ɵSlashKeyResult as vi, PropsActionConfig as vl, ɵMESSAGE_FEEDBACK_EVENT_NAME as vn, ɵgetToolCallBadge as vo, ɵExitPresence as vr, A2UI_PAINT_FALLBACK_MS as vs, OPEN_GENERATIVE_UI_ACTIVITY_TYPE as vt, ɵassembleProviderRegistry as vu, ɵMAX_SOCKET_RETRIES as w, ɵClipboardItem as wa, ɵMemoryState as wc, ɵJsonSerializable as wd, Suggestion as wf, ɵflattenCommandItems as wi, createEffect as wl, ɵgetMessageFeedback as wn, ɵActivityRendererFailureReason as wo, ɵRESIZE_SETTLE_MS as wr, getA2UIOperations as ws, ɵInspectorKiteGradient as wt, ɵresolveProviderConfig as wu, ɵCopilotKitCoreConfigPatch as x, ɵThreadSelectionInput as xa, ɵMemoryEnvironment as xc, ɵbuildLearnFromUserActionPayload as xd, RuntimeLicenseStatus$1 as xf, ɵclampSlashIndex as xi, Store as xl, ɵMessageFeedbackControls as xn, ɵparseToolCallArguments as xo, ɵPOPUP_DEFAULT_HEIGHT as xr, diagnoseUnresolvedRoot as xs, ɵHoverMenuController as xt, ɵpublicKeyHeaderDefaults as xu, SubscribeToAgentOptions as y, ɵConnectionWaitResult as ya, NewMemory as yc, ɵRecordAnnotationArgs as yd, InspectorMetadataV1$1 as yf, ɵSlashMenuState as yi, Reducer as yl, ɵMESSAGE_FEEDBACK_MAX_COMMENT_LENGTH as yn, ɵgetToolCallStatus as yo, ɵExitPresenceState as yr, diagnoseMissingSurface as ys, OpenGenerativeUIContent as yt, ɵassembleProviderToolRenderers as yu, ɵselectThreadsIsLoading as z, ToolCallSegment as za, MemoryErrorCategory as zc, WebMCPModelContext as zd, ɵMessageViewModel as zi, completePartialMarkdown as zl, ɵtoDrawerThread as zn, ɵformatCountLabel as zo, ɵisContentScrolledToBottom as zr, extractStringField as zs, ɵflattenUserMessageContent as zt, CustomMessageRenderProps as zu };
10903
+ //# sourceMappingURL=learning-bridge-DsyYU_tn.d.mts.map