@oddkin/ai 0.0.0-stage → 1.0.0-beta.1

package/dist/prod/conversation/conversation.js

@@ -0,0 +1,236 @@
+import { LiveAnnouncer } from "@oddkin/core/controllers/announce";
+import { ResizeController } from "@oddkin/core/controllers/observe";
+import { OddkinElement, prop } from "@oddkin/core/element";
+import { signal } from "@oddkin/core/reactive";
+import { can } from "../contracts/normalize.js";
+import { DEFAULT_ANNOUNCEMENTS, describeConversationChange } from "../controllers/announcer.js";
+import { isActive } from "../controllers/transitions.js";
+import { historyRequestEvent } from "../events.js";
+import { format, strings } from "../internal/strings.js";
+const CONVERSATION_STRINGS = {
+  label: "Conversation",
+  empty: "No messages yet.",
+  loadEarlier: "Load earlier messages",
+  loading: "Loading earlier messages\u2026",
+  historyError: "Earlier messages could not be loaded.",
+  retry: "Try again",
+  jump: "Jump to latest",
+  jumpNew: "Jump to latest ({count} new)",
+  messageLabel: "{role}, message {index} of {count}",
+  user: "You",
+  assistant: "Assistant",
+  system: "System",
+  tool: "Tool"
+}, FOLLOW_THRESHOLD = 48;
+class OddkinConversation extends OddkinElement.with({
+  store: prop.object({
+    description: "Authoritative state (a controller or an external store)."
+  }),
+  state: prop.object({
+    description: "Controlled snapshot, used when no `store` is set."
+  }),
+  label: prop.string({ default: "", description: "Accessible name of the feed." }),
+  announce: prop.enum(["none", "important", "all"], {
+    default: "important",
+    empty: "important",
+    description: "How much the surface announces."
+  }),
+  markdown: prop.object({ description: "Markdown options for every message." }),
+  renderers: prop.object({
+    description: "Validated renderers for `data` parts."
+  }),
+  artifactRenderers: prop.object({
+    description: "Artifact renderers by kind."
+  }),
+  renderTool: prop.object({
+    description: "Renderer for tool results."
+  }),
+  feedbackReasons: prop.array({ description: "Reasons offered for negative feedback." }),
+  strings: prop.object({
+    description: "Localized string overrides (including announcements)."
+  })
+}) {
+  static events = { "odd-history-request": historyRequestEvent };
+  /** @internal Snapshot read from `store` (mirrors it; never edited). */
+  _snapshot = signal(void 0);
+  /** @internal Follow-latest policy (presentation state). */
+  _following = signal(!0);
+  /** @internal Messages added while reading earlier content. */
+  _unseen = signal(0);
+  /** @internal Roving tab stop among articles. */
+  _current = signal(void 0);
+  #anchor;
+  #programmatic = !1;
+  #positions = /* @__PURE__ */ new Map();
+  /** @internal */
+  get _strings() {
+    return strings(CONVERSATION_STRINGS, this.strings);
+  }
+  /** The snapshot being rendered. */
+  get snapshot() {
+    return this.store ? this._snapshot.value : this.state;
+  }
+  /** @internal Tools of the active attempt (for the status bar). */
+  _activeTools(state) {
+    const id = state.activeAttemptId;
+    return id ? Object.values(state.tools).filter((t) => t.attemptId === id) : [];
+  }
+  /** @internal */
+  _busy(state) {
+    if (!state)
+      return !1;
+    const attempt = state.activeAttemptId ? state.attempts[state.activeAttemptId] : void 0;
+    return state.history === "loading" || !!attempt && isActive(attempt.status);
+  }
+  /** @internal */
+  _messageLabel(role, index, count) {
+    const t = this._strings;
+    return format(t.messageLabel, { role: t[role] ?? role, index, count });
+  }
+  /** @internal */
+  _requestHistory = () => {
+    const state = this.snapshot;
+    !state || state.history === "loading" || !can(state.capabilities, "history") || this.emit(historyRequestEvent, {
+      conversationId: state.conversationId,
+      beforeMessageId: state.messages[0]?.id
+    });
+  };
+  /** Resume following the latest content and move focus to the newest message. */
+  jumpToLatest(focus = !0) {
+    if (this._following.value = !0, this._unseen.value = 0, this.#scrollToEnd(), focus) {
+      const last = [...this.#articles()].pop();
+      last && (this._current.value = last.dataset.id, last.focus({ preventScroll: !0 }));
+    }
+  }
+  /** @internal */
+  _jump = () => this.jumpToLatest(!0);
+  /** The current reading position (to restore later, e.g. per conversation or branch). */
+  getScrollPosition() {
+    const scroller = this.#scroller();
+    if (!scroller)
+      return;
+    const anchor = this.#findAnchor(scroller);
+    return anchor ? { messageId: anchor.id, offset: anchor.offset, following: this._following.peek() } : void 0;
+  }
+  /** Restore a position from `getScrollPosition()`. Unknown messages fall back to the latest. */
+  restoreScrollPosition(position) {
+    const scroller = this.#scroller();
+    if (!scroller)
+      return;
+    if (!position || position.following)
+      return this.jumpToLatest(!1);
+    if (!this.#article(position.messageId))
+      return this.jumpToLatest(!1);
+    this._following.value = !1, this.#anchor = { id: position.messageId, offset: position.offset }, this.#restoreAnchor(scroller);
+  }
+  // ---- Lifecycle ----
+  connected(scope) {
+    scope.effect((run) => {
+      const source = this.store;
+      if (!source) {
+        this._snapshot.value = void 0;
+        return;
+      }
+      this._snapshot.value = source.getSnapshot();
+      const unsubscribe = source.subscribe(() => {
+        this._snapshot.value = source.getSnapshot();
+      });
+      run.add(unsubscribe, "conversation store");
+    }, { name: "<odd-conversation> store" });
+  }
+  mounted(scope) {
+    const root = this.shadowRoot, scroller = this.#scroller(), feed = root?.querySelector('[part="feed"]'), polite = root?.querySelector("#polite"), assertive = root?.querySelector("#assertive");
+    if (!root || !scroller || !feed || !polite || !assertive)
+      return;
+    const announcer = scope.use(new LiveAnnouncer({
+      regions: () => ({ polite, assertive }),
+      event: "odd-announce",
+      target: () => this
+    }));
+    let previous, previousIds = [];
+    scope.effect(() => {
+      const state = this.snapshot, level = this.announce, t = {
+        ...DEFAULT_ANNOUNCEMENTS,
+        ...this.strings
+      };
+      if (state && previous && previous.conversationId !== state.conversationId) {
+        const position = this.getScrollPosition();
+        position && this.#positions.set(previous.conversationId, position), announcer.reset(), previousIds = [], queueMicrotask(() => this.restoreScrollPosition(this.#positions.get(state.conversationId)));
+      }
+      if (state)
+        for (const detail of describeConversationChange(previous, state, level, t))
+          announcer.announce(detail);
+      const ids = state?.messages.map((m) => m.id) ?? [], grew = ids.length - previousIds.length;
+      !this._following.peek() && grew > 0 && previousIds.length && ids[0] === previousIds[0] && (this._unseen.value = this._unseen.peek() + grew), previous = state, previousIds = ids;
+    }, { phase: "post", name: "<odd-conversation> announce" }), scope.listen(scroller, "scroll", () => {
+      if (this.#programmatic)
+        return;
+      const following = scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight <= FOLLOW_THRESHOLD;
+      following !== this._following.peek() && (this._following.value = following), following && (this._unseen.value = 0), this.#anchor = following ? void 0 : this.#findAnchor(scroller);
+    }, { passive: !0 }), scope.use(new ResizeController(() => {
+      this._following.peek() ? this.#scrollToEnd() : this.#restoreAnchor(scroller);
+    }, { targets: () => [feed] })), scope.listen(feed, "keydown", (event) => this.#onFeedKey(event)), scope.listen(feed, "focusin", (event) => {
+      const article = event.composedPath().find((el) => el instanceof HTMLElement && el.dataset?.id && el.parentElement === feed);
+      article && (this._current.value = article.dataset.id);
+    }), queueMicrotask(() => this.#scrollToEnd());
+  }
+  // ---- Scrolling ----
+  #scroller() {
+    return this.shadowRoot?.querySelector('[part="scroller"]');
+  }
+  #articles() {
+    return [
+      ...this.shadowRoot?.querySelectorAll('[part="feed"] > odd-message') ?? []
+    ];
+  }
+  #article(id) {
+    return this.#articles().find((a) => a.dataset.id === id);
+  }
+  #findAnchor(scroller) {
+    const top = scroller.getBoundingClientRect().top;
+    for (const article of this.#articles()) {
+      const rect = article.getBoundingClientRect();
+      if (rect.bottom > top + 1)
+        return { id: article.dataset.id, offset: rect.top - top };
+    }
+  }
+  #restoreAnchor(scroller) {
+    const anchor = this.#anchor, article = anchor ? this.#article(anchor.id) : void 0;
+    if (!anchor || !article)
+      return;
+    const delta = article.getBoundingClientRect().top - scroller.getBoundingClientRect().top - anchor.offset;
+    Math.abs(delta) < 0.5 || this.#setScrollTop(scroller, scroller.scrollTop + delta);
+  }
+  #scrollToEnd() {
+    const scroller = this.#scroller();
+    scroller && this.#setScrollTop(scroller, scroller.scrollHeight);
+  }
+  #setScrollTop(scroller, top) {
+    this.#programmatic = !0, scroller.scrollTop = top, requestAnimationFrame(() => this.#programmatic = !1);
+  }
+  // ---- Feed keyboard (WAI-ARIA feed pattern) ----
+  #onFeedKey(event) {
+    const articles = this.#articles();
+    if (!articles.length)
+      return;
+    const index = articles.findIndex((a) => a.dataset.id === this._current.peek());
+    let target;
+    if (event.key === "PageDown")
+      target = articles[Math.min(articles.length - 1, index + 1)];
+    else if (event.key === "PageUp")
+      target = articles[Math.max(0, index - 1)];
+    else if (event.key === "End" && event.ctrlKey) {
+      event.preventDefault(), this.querySelector('[slot="composer"]')?.focus();
+      return;
+    } else if (event.key === "Home" && event.ctrlKey) {
+      event.preventDefault(), this.shadowRoot?.querySelector(".history button:not([hidden])")?.focus() ?? this.#scroller()?.focus();
+      return;
+    } else
+      return;
+    event.preventDefault(), target && (this._current.value = target.dataset.id, target.focus());
+  }
+}
+export {
+  CONVERSATION_STRINGS,
+  OddkinConversation
+};

package/dist/prod/conversation/conversation.recipe.js

@@ -0,0 +1,14 @@
+import { defineLayoutRecipe, row, stack } from "@oddkin/components/layout";
+import { token } from "@oddkin/tokens/refs";
+const conversationRecipe = defineLayoutRecipe({
+  name: "conversation",
+  regions: {
+    base: stack({ gap: token("space.xs") }),
+    feed: stack({ gap: token("space.lg") }),
+    history: row({ gap: token("space.xs"), align: "stretch", wrap: !0, justify: "center" }),
+    empty: row({ gap: token("space.xs"), align: "stretch", wrap: !0, justify: "center" })
+  }
+});
+export {
+  conversationRecipe
+};

package/dist/prod/conversation/conversation.recipe.styles.js

@@ -0,0 +1,37 @@
+import { unsafeCSS } from "@oddkin/core/styles";
+const conversationRecipeStyles = unsafeCSS(`@layer odd.layout.base {
+  .base {
+    display: flex;
+    flex-direction: column;
+    gap: var(--odd-space-xs);
+    min-inline-size: 0;
+  }
+  .feed {
+    display: flex;
+    flex-direction: column;
+    gap: var(--odd-space-lg);
+    min-inline-size: 0;
+  }
+  .history {
+    display: flex;
+    flex-direction: row;
+    align-items: stretch;
+    gap: var(--odd-space-xs);
+    flex-wrap: wrap;
+    min-inline-size: 0;
+    justify-content: center;
+  }
+  .empty {
+    display: flex;
+    flex-direction: row;
+    align-items: stretch;
+    gap: var(--odd-space-xs);
+    flex-wrap: wrap;
+    min-inline-size: 0;
+    justify-content: center;
+  }
+}
+`);
+export {
+  conversationRecipeStyles
+};

package/dist/prod/conversation/conversation.styles.js

@@ -0,0 +1,67 @@
+import { css } from "@oddkin/core/styles";
+import { token } from "@oddkin/tokens/refs";
+import { conversationRecipeStyles } from "./conversation.recipe.styles.js";
+const conversationStyles = css`
+  ${conversationRecipeStyles}
+  :host {
+    display: block;
+    block-size: 100%;
+    min-block-size: 12rem;
+  }
+  .base {
+    position: relative;
+    block-size: 100%;
+    min-block-size: 0;
+  }
+  .scroller {
+    flex: 1 1 auto;
+    min-block-size: 8rem;
+    overflow-y: auto;
+    padding-block: ${token("space.sm")};
+    padding-inline: ${token("space.xs")};
+  }
+  .scroller:focus-visible {
+    outline-offset: -2px;
+  }
+  .feed {
+    max-inline-size: var(--odd-conversation-max-width, 48rem);
+    margin-inline: auto;
+  }
+  .feed > odd-message {
+    border-radius: ${token("radius.md")};
+  }
+  .feed > odd-message:focus-visible {
+    outline: ${token("focus.width")} solid ${token("color.focus.ring")};
+    outline-offset: ${token("space.2xs")};
+  }
+  .history,
+  .empty {
+    margin-block-end: ${token("space.sm")};
+  }
+  .jump {
+    position: absolute;
+    inset-inline-end: ${token("space.sm")};
+    inset-block-end: 6rem;
+    min-block-size: ${token("target.min")};
+    padding-inline: ${token("space.sm")};
+    border: ${token("border.width.default")} solid ${token("color.border.strong")};
+    border-radius: ${token("radius.full")};
+    background: ${token("color.surface.raised")};
+    color: inherit;
+    font: inherit;
+    font-size: ${token("font.size.sm")};
+    box-shadow: ${token("elevation.md")};
+    cursor: pointer;
+  }
+  odd-activity {
+    padding-inline: ${token("space.xs")};
+  }
+  @media (forced-colors: active) {
+    .jump {
+      border-color: ButtonText;
+    }
+  }
+`;
+export {
+  conversationStyles
+};

package/dist/prod/conversation/conversation.template.js

@@ -0,0 +1,91 @@
+import { html, repeat } from "@oddkin/core/template";
+import { can } from "../contracts/normalize.js";
+import { format } from "../internal/strings.js";
+const conversationTemplate = (host) => {
+  const t = host._strings, state = host.snapshot, messages = state?.messages ?? [], count = messages.length, current = host._current.value ?? messages[count - 1]?.id, attempt = state?.activeAttemptId ? state.attempts[state.activeAttemptId] : void 0, history = state?.history ?? "complete", showHistory = !!state && state.hasMoreHistory && can(state.capabilities, "history"), unseen = host._unseen.value, showActivity = !!attempt && (attempt.status !== "completed" || attempt.stop === "too-late" || attempt.stop === "unknown") && !(attempt.status === "cancelled" && attempt.stop !== "unknown"), { markdown, renderers, artifactRenderers, renderTool, feedbackReasons } = host;
+  return html`<div class="base" part="base">
+    <div part="scroller" class="scroller" tabindex="-1">
+      <div class="history" ?hidden=${!showHistory && history !== "error"}>
+        <button
+          class="text-button"
+          type="button"
+          ?hidden=${history !== "idle"}
+          @click=${host._requestHistory}
+        >
+          ${t.loadEarlier}
+        </button>
+        <span class="muted" ?hidden=${history !== "loading"}>${t.loading}</span>
+        <span class="error" ?hidden=${history !== "error"}>${t.historyError}</span>
+        <button
+          class="text-button"
+          type="button"
+          ?hidden=${history !== "error"}
+          @click=${host._requestHistory}
+        >
+          ${t.retry}
+        </button>
+      </div>
+      <div class="empty" ?hidden=${count > 0}>
+        <slot name="empty"><p class="muted">${t.empty}</p></slot>
+      </div>
+      <div
+        part="feed"
+        class="feed"
+        role="feed"
+        aria-label=${host.label || t.label}
+        aria-busy=${host._busy(state) ? "true" : "false"}
+      >
+        ${repeat(messages, (m) => m.id, (m, i) => html`<odd-message
+              role="article"
+              data-id=${m.id}
+              tabindex=${m.id === current ? "0" : "-1"}
+              aria-posinset=${String(i + 1)}
+              aria-setsize=${String(count)}
+              aria-label=${host._messageLabel(m.role, i + 1, count)}
+              .message=${m}
+              .attempt=${m.attemptId ? state?.attempts[m.attemptId] : void 0}
+              .tools=${state?.tools}
+              .approvals=${state?.approvals}
+              .artifacts=${state?.artifacts}
+              .branch=${state?.branches[m.id]}
+              .feedback=${state?.feedback[m.id]}
+              .capabilities=${state?.capabilities}
+              .markdown=${markdown}
+              .renderers=${renderers}
+              .artifactRenderers=${artifactRenderers}
+              .renderTool=${renderTool}
+              .feedbackReasons=${feedbackReasons}
+            ></odd-message>`)}
+      </div>
+    </div>
+    <button
+      part="jump"
+      class="jump"
+      type="button"
+      ?hidden=${host._following.value || !count}
+      @click=${host._jump}
+    >
+      ${unseen ? format(t.jumpNew, { count: unseen }) : t.jump}
+    </button>
+    <odd-activity
+      part="activity"
+      ?hidden=${!showActivity}
+      .attempt=${attempt}
+      .tools=${state ? host._activeTools(state) : []}
+      .capabilities=${state?.capabilities}
+    ></odd-activity>
+    <slot name="status"></slot>
+    <slot name="composer"></slot>
+    <div
+      id="polite"
+      class="visually-hidden"
+      role="status"
+      aria-live="polite"
+      aria-atomic="true"
+    ></div>
+    <div id="assertive" class="visually-hidden" aria-live="assertive" aria-atomic="true"></div>
+  </div>`;
+};
+export {
+  conversationTemplate
+};

package/dist/prod/conversation/index.js

@@ -0,0 +1,11 @@
+import { OddkinConversation, CONVERSATION_STRINGS } from "./conversation.js";
+import { conversationTemplate } from "./conversation.template.js";
+import { conversationStyles } from "./conversation.styles.js";
+import { conversationDefinition } from "./conversation.definition.js";
+export {
+  CONVERSATION_STRINGS,
+  OddkinConversation,
+  conversationDefinition,
+  conversationStyles,
+  conversationTemplate
+};

package/dist/prod/events.js

@@ -0,0 +1,235 @@
+import { event } from "@oddkin/core/element";
+const promptSubmitEvent = event("odd-prompt-submit", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !0,
+  intent: "user",
+  description: "Request to send the draft. Acknowledge or fail it with the submission id."
+}), promptStopEvent = event("odd-prompt-stop", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to stop the underlying work of the identified attempt (not a disconnect)."
+}), attachmentAddEvent = event("odd-attachment-add", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Attachments were validated and added to the draft (local; uploading is host-owned)."
+}), attachmentRemoveEvent = event("odd-attachment-remove", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "An attachment was removed from the draft (local)."
+}), historyRequestEvent = event("odd-history-request", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to load earlier messages."
+}), messageEditEvent = event("odd-message-edit", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to edit a user message as a new branch."
+}), messageRegenerateEvent = event("odd-message-regenerate", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request an alternative answer as a new branch."
+}), attemptRetryEvent = event("odd-attempt-retry", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request a new attempt linked to a failed, interrupted, or cancelled one."
+}), attemptResumeEvent = event("odd-attempt-resume", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to reattach to an existing attempt (never starts new work)."
+}), branchSwitchEvent = event("odd-branch-switch", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to show another branch."
+}), approvalDecideEvent = event("odd-approval-decide", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to decide one approval revision. Pending until the record changes."
+}), approvalEditEvent = event("odd-approval-edit", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to edit the proposed action before deciding."
+}), toolRetryEvent = event("odd-tool-retry", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to retry a failed tool call."
+}), citationOpenEvent = event("odd-citation-open", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !0,
+  intent: "user",
+  description: "A citation was activated. The default reveals the source; cancel to navigate yourself."
+}), artifactExportEvent = event("odd-artifact-export", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !0,
+  intent: "user",
+  description: "Export requested. The default downloads the canonical source; cancel to export yourself."
+}), artifactRevisionEvent = event("odd-artifact-revision-change", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "The viewed revision changed (presentation state)."
+}), suggestionSelectEvent = event("odd-suggestion-select", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Insert the suggestion into the composer without sending."
+}), suggestionSubmitEvent = event("odd-suggestion-submit", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Send the suggestion as a prompt."
+}), feedbackSubmitEvent = event("odd-feedback-submit", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to submit feedback; confirmed through the feedback record."
+}), modelChangeEvent = event("odd-model-change", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !0,
+  intent: "user",
+  description: "The user selected another model. Cancel to keep the previous one."
+}), checkpointRestoreEvent = event("odd-checkpoint-restore", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to restore a checkpoint. Success is shown only after the record says restored."
+}), questionAnswerEvent = event("odd-question-answer", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to submit an answer for one question revision."
+}), questionSkipEvent = event("odd-question-skip", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to skip a question."
+}), changeAcceptEvent = event("odd-change-accept", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to apply a proposed change to its base revision."
+}), changeRejectEvent = event("odd-change-reject", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to discard a proposed change."
+}), changeUndoEvent = event("odd-change-undo", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to undo an applied change."
+}), assistRequestEvent = event("odd-assist-request", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request assistance for the captured selection."
+}), contextAddEvent = event("odd-context-add", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to add context; the item appears once the host adds its record."
+}), contextRemoveEvent = event("odd-context-remove", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "Request to remove a context item."
+}), planInputEvent = event("odd-plan-input-request", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "The user wants to answer a step that needs input."
+}), voiceTranscriptEvent = event("odd-voice-transcript", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "A final transcript is ready to use (completed locally)."
+}), transcriptChangeEvent = event("odd-transcript-change", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !1,
+  intent: "user",
+  description: "The user edited a final transcript segment."
+}), announceEvent = event("odd-announce", {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !0,
+  intent: "notification",
+  description: "A status message for the nearest announcer, which cancels it so outer announcers stay silent."
+});
+export {
+  announceEvent,
+  approvalDecideEvent,
+  approvalEditEvent,
+  artifactExportEvent,
+  artifactRevisionEvent,
+  assistRequestEvent,
+  attachmentAddEvent,
+  attachmentRemoveEvent,
+  attemptResumeEvent,
+  attemptRetryEvent,
+  branchSwitchEvent,
+  changeAcceptEvent,
+  changeRejectEvent,
+  changeUndoEvent,
+  checkpointRestoreEvent,
+  citationOpenEvent,
+  contextAddEvent,
+  contextRemoveEvent,
+  feedbackSubmitEvent,
+  historyRequestEvent,
+  messageEditEvent,
+  messageRegenerateEvent,
+  modelChangeEvent,
+  planInputEvent,
+  promptStopEvent,
+  promptSubmitEvent,
+  questionAnswerEvent,
+  questionSkipEvent,
+  suggestionSelectEvent,
+  suggestionSubmitEvent,
+  toolRetryEvent,
+  transcriptChangeEvent,
+  voiceTranscriptEvent
+};