@geoscene/ai-components 0.0.0-stage → 5.1.13

package/dist/components/geoscene-assistant/types.d.ts

@@ -0,0 +1,147 @@
+import type { UXSuggestion } from "../../utils/index.js";
+
+/** An interrupt is a UI mechanism used by an agent to prompt the user for additional input or clarification. */
+export interface Interrupt {
+  /**
+   * The unique identifier of the message associated with the interrupt. This is used to associate the interrupt
+   * with specific messages.
+   */
+  id?: string;
+  /**
+   * The type of interrupt, which determines how the assistant will prompt the user for input. The available types are:
+   *
+   * - `boolean-choice`: Presents the user with a yes/no question.
+   * - `multi-select`: Allows the user to select multiple options from a list using a checkbox interface.
+   * - `single-select`: Allows the user to select a single option from a list using a radio button interface.
+   * - `text-input`: Prompts the user to enter free-form text input.
+   *
+   * The assistant will use the specified type to determine how to display the prompt and collect the user's response.
+   * For example, a `boolean-choice` interrupt might be used to confirm an action, while a `text-input`
+   * interrupt could be used to ask for more details about a request.
+   */
+  type: "boolean-choice" | "multi-select" | "single-select" | "text-input";
+  /**
+   * The message to display to the user when prompting for input. This should provide clear instructions or questions
+   * related to the interrupt, guiding the user on what information is needed or what action they should take in response
+   * to the prompt.
+   *
+   * For example, if the interrupt type is `boolean-choice`, the message might be "Do you want to proceed with this
+   * action?" If the type is `text-input`, the message could be "Please provide more details about your request."
+   */
+  message?: string;
+  /**
+   * The options to present to the user for selection when the interrupt type is `multi-select` or `single-select`.
+   * This should be an array of strings representing the available choices. For `boolean-choice`,
+   * the options are implicitly "Yes" and "No" and do not need to be provided.
+   * For `text-input`, options are not applicable and should be omitted.
+   *
+   * For example, if the interrupt type is `multi-select`, the options might be ["Option 1", "Option 2", "Option 3"].
+   * If the type is `single-select`, the options could be ["Choice A", "Choice B", "Choice C"].
+   */
+  options?: string[];
+}
+
+/** A chat message sent by the assistant. */
+export interface AssistantMessage extends ChatMessageBase {
+  role: "assistant";
+  /** The content of the assistant's message. This can include text generated by the assistant in response to the user's message. The content is displayed in the chat interface for the user to read and interact with. */
+  content?: string;
+  /**
+   * Structured response UI blocks associated with the assistant message. These blocks are rendered as interactive
+   * UI elements separate from the plain text transcript and can be used to display actions, follow-up prompts,
+   * or app-registered custom content.
+   */
+  blocks?: (UXSuggestion & { isPending?: boolean; })[];
+  /**
+   * Log messages related to the assistant's processing of the user's request. This can include information about
+   * the agents or tools it invoked, the parameters generated by the LLM, and any relevant details about how it
+   * arrived at its response. Log messages are primarily intended for debugging and transparency purposes, allowing
+   * developers and users to understand the assistant's behavior and decision-making process.
+   */
+  log?: string[];
+  /**
+   * An error message indicating any issues that occurred while the assistant was processing the user's request.
+   * The error message may be displayed in the chat interface to inform the user of the issue and can also be used for
+   * debugging and improving the assistant's performance.
+   */
+  error?: string;
+  /**
+   * Feedback provided by the user for this specific assistant message. This allows users to indicate whether the
+   * assistant's response was helpful or not, which the app developer can capture and use to improve the assistant's
+   * performance over time.
+   */
+  feedback?: Feedback;
+  /**
+   * Indicates whether the message content is still being streamed from the assistant. This can be used to show loading
+   * indicators or placeholders in the UI until the full content is received.
+   */
+  isStreaming?: boolean;
+  /**
+   * An array of interrupts emitted by the assistant during the processing of the user's request. Each interrupt includes
+   * details about the type of interrupt, the message to display to the user, and any options for user input.
+   */
+  interrupts?: {
+      interrupt: Interrupt;
+      response?: string[] | boolean | string;
+  }[];
+}
+
+/**
+ * A chat message from the user or the assistant. Messages include all relevant information such as content,
+ * logs, errors, and feedback.
+ */
+export type ChatMessage = AssistantMessage | UserMessage;
+
+/** Detail payload emitted when a suggested prompt is selected. */
+export type AssistantPromptSelectDetail = {
+  /** The selected suggested prompt value. */
+  prompt: string;
+};
+
+/** Detail payload emitted by the assistant slottable request event. */
+export type AssistantSlottableRequestDetail = {
+  /** The request name describing the slot being requested. */
+  name: AssistantSlottableRequestName;
+  /** The slot name consumers should target when appending light DOM content. */
+  slotName: string;
+  /** Data describing the current slot request. */
+  data?: AssistantSlottableRequestData;
+};
+
+/** The base interface for chat messages exchanged between the user and the assistant. */
+export interface ChatMessageBase {
+  /**
+   * The unique identifier for the message. This is used to associate messages with interrupts and feedback.
+   * If not provided, a unique ID will be generated automatically.
+   */
+  id: string;
+}
+
+/** A chat message sent by the user. */
+export interface UserMessage extends ChatMessageBase {
+  role: "user";
+  /**
+   * The content of the user's message. This is the text input provided by the user in the chat interface.
+   * This content is sent to the assistant and its agents for processing and generating responses.
+   */
+  content: string;
+}
+
+/** Feedback provided by the user for a specific message. */
+export interface Feedback {
+  /** Indicates whether the feedback is positive or negative. */
+  positive: boolean;
+}
+
+/** Data emitted with an assistant slottable request. */
+export type AssistantSlottableRequestData = {
+  /** The assistant message associated with the slot request. */
+  message: AssistantMessage;
+  /** The block associated with the slot request, when requesting block content. */
+  block?: UXSuggestion;
+  /** Zero-based index of the block associated with the slot request. */
+  index?: number;
+};
+
+/** Supported assistant slottable request names. */
+export type AssistantSlottableRequestName = "block" | "message";

package/dist/components/geoscene-assistant-agent/customElement.d.ts

@@ -0,0 +1,141 @@
+/// <reference path="../../index.d.ts" />
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { AgentRegistration } from "../../utils/index.js";
+
+/**
+ * The Assistant Agent component is a generic wrapper for registering custom agents to the [geoscene-assistant](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/) component. To define
+ * a custom agent, you must be familiar with [LangGraph](https://docs.langchain.com/oss/javascript/langgraph/overview). Custom agents must
+ * include a StateGraph that defines the agent's graph and subgraphs.
+ *
+ * Building custom agents can only be done using modern JavaScript/TypeScript tooling and cannot be done directly in HTML using
+ * CDN imports. Therefore, you must use a package manager like npm or yarn to install the required dependencies. Please refer to the
+ * [Custom Agents guide](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-custom-agents/) for more instructions on how to create a custom agent.
+ *
+ * Use the [utils](https://doc.geoscene.cn/javascript/5.1/references/ai-components/utils/index/) module for helper functions and types related to building custom agents, including the `AgentRegistration`
+ * type and functions for making LLM calls, managing agent state, and setting up human-in-the-loop workflows.
+ *
+ * > We recommend that developers building custom agents have experience working with LLMs and generative AI, and have a good
+ * understanding of the limitations of these technologies when building applications for end users.
+ *
+ * This is an unrendered component that must be added as a child of the `geoscene-assistant` component in either HTML or JavaScript.
+ *
+ * ```html
+ * <geoscene-assistant></geoscene-assistant>
+ * ```
+ *
+ * ```js
+ * const myCustomAgent = {
+ *   id: "my-custom-agent",
+ *   name: "My Custom Agent",
+ *   description: "An agent that does custom things. Use this agent when users want to do custom things.",
+ *   createGraph: {
+ *    // StateGraph definition using LangGraph
+ *   },
+ *   workspace: {
+ *     // AnnotationRoot definition using LangGraph
+ *     // relevant variables and context required by the agent
+ *   },
+ * };
+ *
+ * const assistant = document.querySelector("geoscene-assistant");
+ * const assistantAgent = document.createElement("geoscene-assistant-agent");
+ *
+ * assistantAgent.agent = myCustomAgent;
+ * assistant.appendChild(assistantAgent);
+ * ```
+ *
+ * @since 5.0
+ * @beta
+ * @see [geoscene-assistant](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/)
+ * @see [LangGraph documentation](https://docs.langchain.com/oss/javascript/langgraph/overview)
+ * @see [Custom agents guide](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-custom-agents/)
+ * @see [AI Assistant component sample](https://doc.geoscene.cn/javascript/5.1/sample-code/ai-assistant/)
+ * @see [AgentRegistration](https://doc.geoscene.cn/javascript/5.1/references/ai-components/utils/index/#AgentRegistration)
+ * @see [invokeStructuredPrompt](https://doc.geoscene.cn/javascript/5.1/references/ai-components/utils/index/#invokeStructuredPrompt)
+ * @see [invokeToolPrompt](https://doc.geoscene.cn/javascript/5.1/references/ai-components/utils/index/#invokeToolPrompt)
+ * @see [invokeTextPrompt](https://doc.geoscene.cn/javascript/5.1/references/ai-components/utils/index/#invokeTextPrompt)
+ */
+export abstract class GeosceneAssistantAgent<TContext = Record<string, unknown>> extends LitElement {
+  /**
+   * The agent registration object that defines the AI agent's behavior and capabilities.
+   * This must include a StateGraph definition (defined using
+   * [LangGraph](https://docs.langchain.com/oss/javascript/langgraph/overview)).
+   *
+   * This is an agent defined in the client and can be invoked by the assistant from the browser to perform specific tasks
+   * using functions defined in the client.
+   *
+   * See the [Custom Agents guide](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-custom-agents/) for more instructions
+   * and links to samples demonstrating how to create custom agents.
+   *
+   * @required
+   * @see [LangGraph documentation](https://docs.langchain.com/oss/javascript/langgraph/overview)
+   * @see [Custom agents guide](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-custom-agents/)
+   * @example
+   * ```js
+   * // An example graph that updates a component property and replies with a confirmation message
+   * const myCustomGraph = () => {
+   *   const graph = new StateGraph(myCustomState)
+   *    .addNode("updateComponentProperty", updateComponentProperty)
+   *    .addNode("replyComponentPropertyUpdate", replyComponentPropertyUpdate)
+   *    .addEdge(START, "updateComponentProperty")
+   *    .addEdge("updateComponentProperty", "replyComponentPropertyUpdate")
+   *    .addEdge("replyComponentPropertyUpdate", END);
+   *
+   *   return graph;
+   * };
+   *
+   * const myCustomAgentState = Annotation.Root({
+   *   // This is required to keep track of chat messages between the user and the agent
+   *   messages: Annotation<ChatHistory>({
+   *     reducer: messagesStateReducer,
+   *     default: () => [],
+   *   }),
+   *   // Accumulates user-visible output across graph nodes
+   *   outputMessage: Annotation<string>({
+   *     reducer: (current = "", update) =>
+   *       typeof update === "string" && update.trim()
+   *         ? current
+   *           ? `${current}\n\n${update}`
+   *           : update
+   *         : current,
+   *     default: () => "",
+   *   }),
+   *   // Result of the UI action performed by the agent
+   *   // This is a custom type defined by the application
+   *   result: Annotation<UIActionResult | null>({
+   *     reducer: (_current, update) => update ?? null,
+   *     default: () => null,
+   *   }),
+   * });
+   *
+   * const myCustomAgent = {
+   *   id: "my-custom-agent",
+   *   name: "My Custom Agent",
+   *   description: "An agent that does custom things. Use this agent when users want to do custom things.",
+   *   createGraph: myCustomGraph,
+   *   workspace: myCustomAgentState,
+   * };
+   *
+   * const assistant = document.querySelector("geoscene-assistant");
+   * const assistantAgent = document.createElement("geoscene-assistant-agent");
+   *
+   * assistantAgent.agent = myCustomAgent;
+   * assistant.appendChild(assistantAgent);
+   * ```
+   */
+  accessor agent: AgentRegistration;
+  /**
+   * If the agent requires context provided by the application or user, it can be provided via this property and accessed in the
+   * agent's graph nodes.
+   *
+   * @example
+   * ```js
+   * assistantAgent.context = {
+   *   myData: {
+   *    // data required for the custom agent
+   *   },
+   * };
+   * ```
+   */
+  accessor context: TContext | (() => Promise<TContext | undefined> | TContext | undefined) | undefined;
+}

package/dist/components/geoscene-assistant-agent/customElement.js

@@ -0,0 +1,23 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { c as t } from "../../chunks/runtime.js";
+import { LitElement as s } from "@geoscene/lumina";
+import { i as e, a as i } from "../../chunks/utils2.js";
+class n extends s {
+  static {
+    this.properties = { agent: 0, context: 0 };
+  }
+  #t;
+  async getContext() {
+    return e(this.context) ? await this.context() : this.context;
+  }
+  load() {
+    this.#t = i(this);
+  }
+  disconnectedCallback() {
+    this.#t?.unregister(this.agent.id), super.disconnectedCallback();
+  }
+}
+t("geoscene-assistant-agent", n);
+export {
+  n as GeosceneAssistantAgent
+};

package/dist/components/geoscene-assistant-agent/index.d.ts

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/geoscene-assistant-agent/index.js

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/geoscene-assistant-chat/customElement.d.ts

@@ -0,0 +1,17 @@
+/// <reference path="../../index.d.ts" />
+import type Collection from "@geoscene/core/core/Collection.js";
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { ChatMessage, Interrupt } from "../geoscene-assistant/types.js";
+
+/**
+ * Wraps and renders the conversation area. Use it as the container for message list content.
+ * Offers chat-level layout structure for message starter, message list, and loading regions.
+ *
+ * @internal
+ */
+export abstract class GeosceneAssistantChat extends LitElement {
+  accessor interrupt: Interrupt | null;
+  /** @default false */
+  accessor loading: boolean;
+  accessor messages: Collection<ChatMessage>;
+}

package/dist/components/geoscene-assistant-chat/customElement.js

@@ -0,0 +1,50 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { c as s } from "../../chunks/runtime.js";
+import { css as e, html as t } from "lit";
+import { LitElement as i } from "@geoscene/lumina";
+import { createRef as a, ref as l } from "lit/directives/ref.js";
+import n from "@geoscene/core/core/Collection.js";
+import { when as r, watch as o } from "@geoscene/core/core/reactiveUtils.js";
+const c = e`.messages-container{display:flex;flex:1;flex-direction:column;line-height:var(--calcite-font-line-height-relative-snug)}.messages-list{padding:var(--calcite-spacing-lg);display:flex;flex-direction:column;gap:var(--calcite-spacing-xxl);flex:1 1 auto;min-height:0;justify-content:flex-end;overflow:auto}.end-ref{margin-top:var(--calcite-spacing-lg)}`;
+class m extends i {
+  constructor() {
+    super(...arguments), this.#e = a(), this.#s = !1, this.loading = !1, this.messages = new n([]), this.interrupt = null;
+  }
+  static {
+    this.properties = { loading: 5, messages: 0, interrupt: 0 };
+  }
+  static {
+    this.styles = c;
+  }
+  #e;
+  #s;
+  firstUpdated() {
+    this.#t();
+  }
+  loaded() {
+    this.manager.onLifecycle(() => [
+      this.messages.on("change", () => {
+        this.#t();
+      }),
+      r(() => !this.loading, () => {
+        this.#s = !1;
+      }),
+      o(() => [this.loading, this.interrupt], () => this.#t())
+    ]);
+  }
+  #t() {
+    requestAnimationFrame(() => {
+      this.#s || this.#e.value?.scrollIntoView({ behavior: "smooth", block: "end" });
+    });
+  }
+  #i() {
+    this.#s = !0;
+  }
+  render() {
+    return t`<div class="messages-container" @wheel=${this.#i}><div class="messages-list"><slot name=message-starter></slot><slot name=messages></slot><slot name=message-loading></slot></div><div class="end-ref" ${l(this.#e)}></div></div>`;
+  }
+}
+s("geoscene-assistant-chat", m);
+export {
+  m as GeosceneAssistantChat
+};

package/dist/components/geoscene-assistant-chat/index.d.ts

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/geoscene-assistant-chat/index.js

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/geoscene-assistant-chat-entry/customElement.d.ts

@@ -0,0 +1,37 @@
+/// <reference path="../../index.d.ts" />
+import type Collection from "@geoscene/core/core/Collection.js";
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { ChatMessage } from "../geoscene-assistant/types.js";
+import type { T9nMeta } from "@geoscene/lumina/controllers";
+
+/**
+ * Provides the input bar and submit or cancel behavior. Use it to collect prompts and emit submit events.
+ * Offers keyboard submit/history behavior, entry action slots, and optional voice-input integration.
+ *
+ * @slot [entry-actions-start] - Slot for adding actions to the start of the entry area.
+ * @slot [entry-actions-end] - Slot for adding actions to the end of the entry area.
+ */
+export abstract class GeosceneAssistantChatEntry extends LitElement {
+  /** @internal */
+  protected _messages: { entryPlaceholder: string; } & T9nMeta<{ entryPlaceholder: string; }>;
+  /** @default false */
+  accessor awaitingResponse: boolean;
+  /** @default false */
+  accessor disabled: boolean;
+  accessor entryPlaceholder: string | undefined;
+  /** @default "" */
+  accessor inputValue: string;
+  /** @default false */
+  accessor keyboardShortcutsDisabled: boolean;
+  accessor messages: Collection<ChatMessage>;
+  accessor status: "error" | "ready" | "working" | undefined;
+  /** @default false */
+  accessor voiceInputEnabled: boolean;
+  submitMessage(): Promise<void>;
+  readonly geosceneCancel: import("@geoscene/lumina").TargetedEvent<this, void>;
+  readonly geosceneSubmit: import("@geoscene/lumina").TargetedEvent<this, string>;
+  readonly "@eventTypes": {
+    geosceneCancel: GeosceneAssistantChatEntry["geosceneCancel"]["detail"];
+    geosceneSubmit: GeosceneAssistantChatEntry["geosceneSubmit"]["detail"];
+  };
+}

package/dist/components/geoscene-assistant-chat-entry/customElement.js

@@ -0,0 +1,85 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { c as d } from "../../chunks/runtime.js";
+import { css as p, html as c } from "lit";
+import { LitElement as f, createEvent as l, safeClassMap as g } from "@geoscene/lumina";
+import { createRef as u, ref as h } from "lit/directives/ref.js";
+import { u as m } from "../../chunks/useT9n.js";
+import y from "@geoscene/core/core/Collection.js";
+import { classes as v } from "@geoscene/toolkit/dom";
+const b = p`:host{--calcite-text-area-border-color: var(--calcite-color-border-1);--calcite-text-area-divider-color: var(--calcite-color-border-1);--calcite-text-area-corner-radius: var(--calcite-border-radius)}.input-container{display:flex;flex-direction:column}.footer-start{display:flex;gap:var(--calcite-spacing-md);flex-wrap:wrap;align-items:center}.footer-end{display:flex;gap:var(--calcite-spacing-md);align-items:center}.status-indicator{width:9px;height:9px;border-radius:100%;background-color:var(--calcite-color-status-success)}.status-indicator[data-status=working]{background-color:var(--calcite-color-status-warning)}.status-indicator[data-status=error]{background-color:var(--calcite-color-status-danger)}.status-text{text-transform:capitalize}.focused{--calcite-text-area-shadow: var(--calcite-shadow-sm)}`;
+class w extends f {
+  constructor() {
+    super(...arguments), this.#s = u(), this.#i = u(), this.#t = -1, this.#e = "", this.#a = (t) => {
+      t.stopPropagation();
+      const s = t.detail;
+      this._setDraftValue(s.value), s.focusInput && this.#s.value && this.#s.value.setFocus();
+    }, this.#r = (t) => {
+      const s = t.target.value ?? "";
+      this.inputValue = s, this.#e = s;
+    }, this._messages = m({ blocking: !0 }), this._inFocus = !1, this.keyboardShortcutsDisabled = !1, this.awaitingResponse = !1, this.inputValue = "", this.voiceInputEnabled = !1, this.messages = new y([]), this.disabled = !1, this.geosceneCancel = l(), this.geosceneSubmit = l();
+  }
+  static {
+    this.properties = { _inFocus: 16, _userMessages: 16, keyboardShortcutsDisabled: 5, entryPlaceholder: 1, awaitingResponse: 5, inputValue: 1, status: 1, voiceInputEnabled: 5, messages: 0, disabled: 5 };
+  }
+  static {
+    this.styles = b;
+  }
+  #s;
+  #i;
+  #t;
+  #e;
+  #a;
+  #r;
+  get _userMessages() {
+    return this.messages.toArray().filter((t) => t.role === "user").map(({ content: t }) => t);
+  }
+  async submitMessage() {
+    if (this.awaitingResponse) {
+      this.geosceneCancel.emit();
+      return;
+    }
+    const t = this.inputValue.trim();
+    t && (this.geosceneSubmit.emit(t), this.inputValue = "", this.#t = -1, this.#e = "", this.#i.value?.clearDraftSession(), this.#s.value && await this.#s.value.setFocus());
+  }
+  loaded() {
+    this.manager.onLifecycle(() => (this.el.addEventListener("geosceneVoiceInputDraftChange", this.#a), {
+      remove: () => {
+        this.el.removeEventListener("geosceneVoiceInputDraftChange", this.#a);
+      }
+    }));
+  }
+  async _navigateHistory(t, s) {
+    const a = this.#s.value;
+    if (!a)
+      return;
+    const e = this._userMessages;
+    if (e.length === 0)
+      return;
+    const r = a.value ?? "", o = a.shadowRoot?.querySelector("textarea"), i = o?.selectionStart, n = o?.selectionEnd;
+    if (!(i == null || n == null) && !(i !== n || t === "up" && i !== 0 || t === "down" && i !== r.length)) {
+      if (t === "up") {
+        this.#t === -1 ? (this.#e = r, this.#t = e.length - 1) : this.#t = Math.max(0, this.#t - 1), this.inputValue = e[this.#t] ?? "", s.preventDefault();
+        return;
+      }
+      this.#t !== -1 && (this.#t < e.length - 1 ? (this.#t += 1, this.inputValue = e[this.#t] ?? "") : (this.#t = -1, this.inputValue = this.#e), s.preventDefault());
+    }
+  }
+  _setDraftValue(t) {
+    this.inputValue = t, this.#t = -1, this.#e = t;
+  }
+  _onFocusIn() {
+    this._inFocus = !0;
+  }
+  _onFocusOut() {
+    this._inFocus = !1;
+  }
+  render() {
+    return c`<div class="input-container"><calcite-text-area class=${g(v({ focused: this._inFocus }))} .value=${this.inputValue} .placeholder=${this.entryPlaceholder ?? this._messages.entryPlaceholder} resize=vertical @calciteTextAreaInput=${this.#r} .disabled=${this.disabled} @keydown=${async (t) => {
+      t.altKey || t.ctrlKey || t.metaKey || t.shiftKey || this.keyboardShortcutsDisabled || (t.key === "Enter" ? (t.preventDefault(), await this.submitMessage()) : t.key === "ArrowUp" ? await this._navigateHistory("up", t) : t.key === "ArrowDown" && await this._navigateHistory("down", t));
+    }} @focusin=${this._onFocusIn} @focusout=${this._onFocusOut} ${h(this.#s)}><div slot=footer-start class="footer-start"><slot name=entry-actions-start></slot></div><div slot=footer-end class="footer-end">${this.voiceInputEnabled ? c`<geoscene-assistant-speech-input .awaitingResponse=${this.awaitingResponse} .inputValue=${this.inputValue} ${h(this.#i)}></geoscene-assistant-speech-input>` : null}<slot name=entry-actions-end></slot></div></calcite-text-area></div>`;
+  }
+}
+d("geoscene-assistant-chat-entry", w);
+export {
+  w as GeosceneAssistantChatEntry
+};

package/dist/components/geoscene-assistant-chat-entry/index.d.ts

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/geoscene-assistant-chat-entry/index.js

@@ -0,0 +1,3 @@
+import "@geoscene/calcite-components/components/calcite-text-area";
+import "../geoscene-assistant-speech-input/index.js";
+export * from "./customElement.js";

package/dist/components/geoscene-assistant-data-exploration-agent/customElement.d.ts

@@ -0,0 +1,101 @@
+/// <reference path="../../index.d.ts" />
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { GeosceneMap as GeosceneMap } from "@geoscene/map-components/components/geoscene-map";
+
+/**
+ * The Data Exploration Agent enables the end user to query features, statistics, and spatial proximity
+ * to features in a layer within a web map. Currently, this is only scoped to querying feature layers within
+ * a 2D web map. See the list of capabilities below for more details.
+ *
+ * The data exploration agent is designed to answer questions about the data in the map, and does not have
+ * access to external data sources or the user's location. It also cannot create visualizations in the form of charts,
+ * layer renderers, new maps, or other visual outputs. It can currently only provide answers in text form based on the
+ * data in the map.
+ *
+ * This agent can change the state of the map by filtering features in a layer, but it cannot change the symbology of
+ * features or create new layers or export results of a query to a file or external source.
+ *
+ * This is an unrendered component that must be added as a child of the `geoscene-assistant` component in either HTML or JavaScript.
+ *
+ * ```html
+ * <geoscene-map id="my-map"></geoscene-map>
+ * <geoscene-assistant reference-element="my-map">
+ *   <geoscene-assistant-data-exploration-agent></geoscene-assistant-data-exploration-agent>
+ * </geoscene-assistant>
+ * ```
+ *
+ * ```js
+ * const assistant = document.querySelector("geoscene-assistant");
+ * const dataExplorationAgent = document.createElement("geoscene-assistant-data-exploration-agent");
+ * assistant.appendChild(dataExplorationAgent);
+ * ```
+ *
+ * Once added to the assistant, the agent is loaded and ready to receive user messages related to data exploration.
+ *
+ * ### Capabilities
+ *
+ * The data exploration agent provides the following capabilities related to exploring data in the map:
+ *
+ * - **Query features** - Ask about the attributes of features in a layer, including a single feature or a set
+ *   of features.
+ * - **Query statistics** - Ask about statistics related to features in a layer. Statistics that can be queried
+ *   include count, average, minimum, maximum, and sum. This includes asking about the top number of features based on a
+ *   particular attribute.
+ * - **Query spatial proximity** - Ask about the spatial proximity of features in a layer, such as
+ *   the number of features that intersect a polygon, or information about features within a distance of a specified location or feature.
+ *   This currently does not include questions about the closest feature, but this is planned to be included in a future release.
+ * - **Filter features** - Users can ask the agent to show a subset of features that filter by attributes, or spatial
+ *   proximity to other features. This includes asking the agent to show features that intersect a particular area,
+ *   or are within a certain distance of a location or feature.
+ *
+ * ### Example questions
+ *
+ * The following are example questions a user can ask within the bounds of the data exploration agent.
+ * These questions assume a map with layers that include cities, states, and rivers.
+ *
+ * - "What is the city with the largest population?"
+ * - "How does that population compare to the average population of the cities in this map?"
+ * - "How many cities are within 30 miles of the Colorado River?"
+ * - "Show all cities in the state of California."
+ * - "List the top 5 rivers by length."
+ * - "Emphasize the largest river on the map."
+ *
+ * The following are examples of the types of questions that fall outside the bounds of the
+ * data exploration agent and should therefore be avoided:
+ *
+ * - "What is the closest restaurant to me?" (the data exploration agent does not have access to the user's location,
+ * nor can it find the nearest feature from a location)
+ * - "What is the projected growth of Phoenix in the next 10 years?" (the data exploration agent can
+ * only answer questions about the data in the map, not external data or projections)
+ * - "Show me the population of cities in this map on a graph." (the data exploration agent can only
+ * provide answers in text form, not visualizations)
+ *
+ * > Due to the non-deterministic nature of generative AI, there may be inaccuracies or unexpected behavior when using the
+ * out-of-the-box agents.
+ *
+ * @since 5.0
+ * @beta
+ * @see [geoscene-assistant](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/)
+ * @see [Intro to building agentic mapping applications](https://doc.geoscene.cn/javascript/5.1/agentic-apps/ai-introduction/)
+ * @see [AI Assistant component sample](https://doc.geoscene.cn/javascript/5.1/sample-code/ai-assistant/)
+ */
+export abstract class GeosceneAssistantDataExplorationAgent extends LitElement {
+  /**
+   * The reference element to the map that provides context for the data exploration agent. Currently,
+   * this is only scoped to `geoscene-map` elements. This provides the data exploration agent with the layers
+   * needed for answering user questions about the data in the map.
+   *
+   * Setting this property is not necessary if you set the reference element on the parent
+   * `geoscene-assistant` component.
+   *
+   * @see [geoscene-assistant.referenceElement](https://doc.geoscene.cn/javascript/5.1/references/ai-components/components/geoscene-assistant/#referenceElement)
+   * @example
+   * ```html
+   * <geoscene-map id="my-map"></geoscene-map>
+   * <geoscene-assistant>
+   *   <geoscene-assistant-data-exploration-agent reference-element="my-map"></geoscene-assistant-data-exploration-agent>
+   * </geoscene-assistant>
+   * ```
+   */
+  accessor referenceElement: GeosceneMap | string | undefined;
+}