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

package/dist/prod/stream/sse.js

@@ -0,0 +1,105 @@
+class SseParser {
+  #buffer = "";
+  #pendingCR = !1;
+  #data = "";
+  #hasData = !1;
+  #type = "";
+  #lastEventId = "";
+  #started = !1;
+  #emit;
+  #retry;
+  constructor(emit, onRetry) {
+    this.#emit = emit, this.#retry = onRetry;
+  }
+  /** Feed decoded text. */
+  feed(text) {
+    this.#started || (this.#started = text.length > 0, text.charCodeAt(0) === 65279 && (text = text.slice(1)));
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+      const code = text.charCodeAt(i);
+      if (this.#pendingCR && (this.#pendingCR = !1, code === 10 && i === start && this.#buffer === "")) {
+        start = i + 1;
+        continue;
+      }
+      (code === 10 || code === 13) && (this.#line(this.#buffer + text.slice(start, i)), this.#buffer = "", code === 13 && (i + 1 < text.length ? text.charCodeAt(i + 1) === 10 && i++ : this.#pendingCR = !0), start = i + 1);
+    }
+    this.#buffer += text.slice(start);
+  }
+  /** End of stream: a pending, unterminated event is discarded (as the specification requires). */
+  end() {
+    this.#buffer = "", this.#data = "", this.#hasData = !1, this.#type = "", this.#pendingCR = !1;
+  }
+  #line(line) {
+    if (line === "")
+      return this.#dispatch();
+    if (line.charCodeAt(0) === 58)
+      return;
+    const colon = line.indexOf(":");
+    let field = line, value = "";
+    switch (colon !== -1 && (field = line.slice(0, colon), value = line.slice(colon + 1), value.charCodeAt(0) === 32 && (value = value.slice(1))), field) {
+      case "event":
+        this.#type = value;
+        break;
+      case "data":
+        this.#data += `${value}
+`, this.#hasData = !0;
+        break;
+      case "id":
+        value.includes("\0") || (this.#lastEventId = value);
+        break;
+      case "retry":
+        /^[0-9]+$/.test(value) && this.#retry?.(Number(value));
+        break;
+    }
+  }
+  #dispatch() {
+    if (!this.#hasData) {
+      this.#type = "";
+      return;
+    }
+    const data = this.#data.endsWith(`
+`) ? this.#data.slice(0, -1) : this.#data, event = { type: this.#type || "message", data, lastEventId: this.#lastEventId };
+    this.#data = "", this.#hasData = !1, this.#type = "", this.#emit(event);
+  }
+}
+function createSseDecoder(onRetry) {
+  const decoder = new TextDecoder("utf-8");
+  let out = [];
+  const parser = new SseParser((event) => out.push(event), onRetry), take = () => {
+    const events = out;
+    return out = [], events;
+  };
+  return {
+    push(bytes) {
+      return parser.feed(decoder.decode(bytes, { stream: !0 })), take();
+    },
+    end() {
+      return parser.feed(decoder.decode()), parser.end(), take();
+    }
+  };
+}
+async function* readSse(stream, signal) {
+  const reader = stream.getReader(), decoder = createSseDecoder(), onAbort = () => {
+    reader.cancel(signal?.reason).catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", onAbort, { once: !0 });
+  try {
+    for (; ; ) {
+      if (signal?.aborted)
+        return;
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      yield* decoder.push(value);
+    }
+    signal?.aborted || (yield* decoder.end());
+  } finally {
+    signal?.removeEventListener("abort", onAbort), reader.releaseLock();
+  }
+}
+export {
+  SseParser,
+  createSseDecoder,
+  readSse
+};

package/dist/prod/stream/ui-message-stream.js

@@ -0,0 +1,371 @@
+import { toPublicError } from "../contracts/normalize.js";
+import { readSse } from "./sse.js";
+const UI_MESSAGE_STREAM_HEADER = "x-vercel-ai-ui-message-stream", UI_MESSAGE_STREAM_VERSION = "v1", str = (value) => typeof value == "string" ? value : void 0;
+function isJson(value, depth = 32) {
+  return value === null || typeof value == "string" || typeof value == "boolean" ? !0 : typeof value == "number" ? Number.isFinite(value) : typeof value != "object" || depth <= 0 ? !1 : Array.isArray(value) ? value.every((v) => isJson(v, depth - 1)) : Object.values(value).every((v) => isJson(v, depth - 1));
+}
+class UiMessageStreamReader {
+  #replay;
+  #diagnose;
+  #started = !1;
+  #done = !1;
+  #files = 0;
+  #data = 0;
+  #toolNames = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.#replay = options.replay ?? !1, this.#diagnose = options.onDiagnostic ?? (() => {
+    });
+  }
+  /** True after `[DONE]`. */
+  get done() {
+    return this.#done;
+  }
+  /** Translate one SSE event. */
+  read(event) {
+    if (this.#done)
+      return this.#diagnose({ code: "ui-stream.afterDone", message: "Ignored data after [DONE]." }), [];
+    if (event.data === "[DONE]")
+      return this.#done = !0, [];
+    let parsed;
+    try {
+      parsed = JSON.parse(event.data);
+    } catch {
+      return this.#diagnose({ code: "ui-stream.json", message: "Ignored a chunk that is not JSON." }), [];
+    }
+    return typeof parsed != "object" || parsed === null || typeof parsed.type != "string" ? (this.#diagnose({ code: "ui-stream.chunk", message: "Ignored a chunk without a type." }), []) : this.translate(parsed);
+  }
+  /** Translate one parsed chunk. Invalid fields drop the chunk with a diagnostic. */
+  translate(chunk) {
+    const invalid = (field) => (this.#diagnose({
+      code: "ui-stream.invalid",
+      message: `Ignored "${chunk.type}": invalid ${field}.`
+    }), []), id = str(chunk.id), toolCallId = str(chunk.toolCallId);
+    switch (chunk.type) {
+      case "start": {
+        const events = [];
+        return this.#replay && !this.#started && events.push({ type: "message-reset" }), this.#started = !0, events.push({ type: "message-start", messageId: str(chunk.messageId) }), chunk.messageMetadata !== void 0 && events.push(this.#metadata(chunk.messageMetadata)), events;
+      }
+      case "text-start":
+      case "reasoning-start":
+        return id ? [
+          {
+            type: "text-start",
+            partId: id,
+            kind: chunk.type === "text-start" ? "text" : "reasoning"
+          }
+        ] : invalid("id");
+      case "text-delta":
+      case "reasoning-delta": {
+        const delta = str(chunk.delta);
+        return id ? delta === void 0 ? invalid("delta") : [{ type: "text-delta", partId: id, delta }] : invalid("id");
+      }
+      case "text-end":
+      case "reasoning-end":
+        return id ? [{ type: "text-end", partId: id }] : invalid("id");
+      case "source-url": {
+        const sourceId = str(chunk.sourceId), url = str(chunk.url);
+        if (!sourceId || !url)
+          return invalid("sourceId or url");
+        const title = str(chunk.title);
+        return [
+          {
+            type: "part",
+            part: {
+              type: "source",
+              id: `source-${sourceId}`,
+              sourceId,
+              url,
+              kind: "web",
+              ...title ? { title } : {}
+            }
+          }
+        ];
+      }
+      case "source-document": {
+        const sourceId = str(chunk.sourceId);
+        if (!sourceId)
+          return invalid("sourceId");
+        const title = str(chunk.title) ?? str(chunk.filename);
+        return [
+          {
+            type: "part",
+            part: {
+              type: "source",
+              id: `source-${sourceId}`,
+              sourceId,
+              kind: "document",
+              ...title ? { title } : {}
+            }
+          }
+        ];
+      }
+      case "file": {
+        const url = str(chunk.url), mediaType = str(chunk.mediaType);
+        if (!url || !mediaType)
+          return invalid("url or mediaType");
+        const name = str(chunk.filename) ?? (url.startsWith("data:") ? "file" : url.split(/[?#]/)[0]?.split("/").pop() || "file");
+        return [
+          {
+            type: "part",
+            part: { type: "file", id: `file-${++this.#files}`, name, mediaType, url }
+          }
+        ];
+      }
+      case "error":
+        return [
+          {
+            type: "error",
+            error: { code: "ai.stream.error", message: str(chunk.errorText) ?? "The response failed." }
+          }
+        ];
+      case "tool-input-start": {
+        const toolName = str(chunk.toolName);
+        return !toolCallId || !toolName ? invalid("toolCallId or toolName") : (this.#toolNames.set(toolCallId, toolName), [{ type: "tool-input-start", toolCallId, toolName, title: str(chunk.title) }]);
+      }
+      case "tool-input-delta": {
+        const delta = str(chunk.inputTextDelta);
+        return !toolCallId || delta === void 0 ? invalid("toolCallId or inputTextDelta") : [
+          ...this.#ensureTool(toolCallId, chunk),
+          { type: "tool-input-delta", toolCallId, delta }
+        ];
+      }
+      case "tool-input-available": {
+        if (!toolCallId)
+          return invalid("toolCallId");
+        const input = chunk.input;
+        return isJson(input) ? [
+          ...this.#ensureTool(toolCallId, chunk),
+          { type: "tool-input-available", toolCallId, input }
+        ] : invalid("input");
+      }
+      case "tool-input-error":
+        return toolCallId ? [
+          ...this.#ensureTool(toolCallId, chunk),
+          {
+            type: "tool-error",
+            toolCallId,
+            error: {
+              code: "ai.tool.input",
+              message: str(chunk.errorText) ?? "Invalid tool input."
+            }
+          }
+        ] : invalid("toolCallId");
+      case "tool-approval-request": {
+        const approvalId = str(chunk.approvalId);
+        if (!toolCallId || !approvalId)
+          return invalid("toolCallId or approvalId");
+        const toolName = this.#toolNames.get(toolCallId) ?? "tool", reason = str(chunk.reason);
+        return [
+          ...this.#ensureTool(toolCallId, chunk),
+          {
+            type: "approval-request",
+            approval: {
+              approvalId,
+              toolCallId,
+              revision: 1,
+              title: toolName,
+              ...reason ? { summary: reason } : {},
+              status: "requested"
+            }
+          }
+        ];
+      }
+      case "tool-approval-response": {
+        const approvalId = str(chunk.approvalId), approved = chunk.approved;
+        return !approvalId || typeof approved != "boolean" ? invalid("approvalId or approved") : [
+          {
+            type: "approval-resolved",
+            approvalId,
+            revision: 1,
+            status: approved ? "approved" : "rejected"
+          }
+        ];
+      }
+      case "tool-output-available": {
+        if (!toolCallId)
+          return invalid("toolCallId");
+        const output = chunk.output;
+        return isJson(output) ? chunk.preliminary === !0 ? [{ type: "tool-executing", toolCallId }] : [
+          { type: "tool-executing", toolCallId },
+          { type: "tool-output", toolCallId, output }
+        ] : invalid("output");
+      }
+      case "tool-output-error":
+        return toolCallId ? [
+          { type: "tool-executing", toolCallId },
+          {
+            type: "tool-error",
+            toolCallId,
+            error: {
+              code: "ai.tool.failed",
+              message: str(chunk.errorText) ?? "The tool failed."
+            }
+          }
+        ] : invalid("toolCallId");
+      case "tool-output-denied":
+        return toolCallId ? [{ type: "tool-denied", toolCallId }] : invalid("toolCallId");
+      case "start-step":
+        return [{ type: "step-start" }];
+      case "reset-step":
+        return [{ type: "step-reset" }];
+      case "finish-step":
+        return [];
+      case "finish": {
+        const events = [];
+        return chunk.messageMetadata !== void 0 && events.push(this.#metadata(chunk.messageMetadata)), events.push({ type: "finish" }), events;
+      }
+      case "abort":
+        return [{ type: "abort", reason: str(chunk.reason) }];
+      case "message-metadata":
+        return [this.#metadata(chunk.messageMetadata)];
+      case "custom":
+        return [this.#metadata({ kind: str(chunk.kind) ?? "custom" })];
+      default:
+        if (chunk.type.startsWith("data-")) {
+          const data = chunk.data;
+          return isJson(data) ? chunk.transient === !0 ? [this.#metadata({ transient: chunk.type })] : [
+            {
+              type: "part",
+              part: {
+                type: "data",
+                id: id ?? `data-${++this.#data}`,
+                name: chunk.type.slice(5),
+                data
+              }
+            }
+          ] : invalid("data");
+        }
+        return this.#diagnose({
+          code: "ui-stream.unsupported",
+          message: `Ignored unsupported chunk "${chunk.type}".`
+        }), [];
+    }
+  }
+  #ensureTool(toolCallId, chunk) {
+    if (this.#toolNames.has(toolCallId))
+      return [];
+    const toolName = str(chunk.toolName) ?? "tool";
+    return this.#toolNames.set(toolCallId, toolName), [{ type: "tool-input-start", toolCallId, toolName }];
+  }
+  #metadata(value) {
+    return { type: "metadata", data: isJson(value) ? value : null };
+  }
+}
+function toUiMessage(message) {
+  return {
+    id: message.id,
+    role: message.role,
+    parts: message.parts.flatMap((part) => part.type === "text" ? [{ type: "text", text: part.text }] : part.type === "file" && part.url ? [{ type: "file", mediaType: part.mediaType, url: part.url, filename: part.name }] : [])
+  };
+}
+const HTTP_ERROR = (status) => ({
+  code: `ai.http.${status}`,
+  message: status === 429 ? "Too many requests. Try again shortly." : "The request failed.",
+  retryable: status === 429 || status >= 500
+});
+function createUiMessageStreamTransport(options) {
+  const doFetch = options.fetch ?? ((...args) => globalThis.fetch(...args)), connections = /* @__PURE__ */ new Map(), diagnose = options.onDiagnostic ?? (() => {
+  }), capabilities = {
+    send: { available: !0 },
+    disconnect: { available: !0 },
+    retry: { available: !0 },
+    regenerate: { available: !0 },
+    edit: { available: !0 },
+    switchBranch: { available: !0 },
+    stop: options.stopApi ? { available: !0 } : { available: !1, reason: "This service cannot stop responses." },
+    resume: options.resumeApi ? { available: !0 } : { available: !1, reason: "This service cannot resume responses." },
+    respondToApproval: options.decideApi ? { available: !0 } : { available: !1, reason: "Approvals are not supported." },
+    ...options.capabilities
+  }, pump = async (response, sink, replay, controller) => {
+    const reader = new UiMessageStreamReader({ replay, onDiagnostic: diagnose });
+    try {
+      if (!response.body)
+        throw new Error("no body");
+      for await (const event of readSse(response.body, controller.signal)) {
+        if (!sink.active)
+          break;
+        for (const aiEvent of reader.read(event))
+          sink.push(aiEvent);
+        if (reader.done)
+          break;
+      }
+    } catch {
+    } finally {
+      connections.get(sink.target.attemptId) === controller && connections.delete(sink.target.attemptId), controller.signal.aborted || sink.close();
+    }
+  }, open = async (url, init, sink, replay) => {
+    connections.get(sink.target.attemptId)?.abort();
+    const controller = new AbortController();
+    connections.set(sink.target.attemptId, controller);
+    const response = await doFetch(url, { ...init, signal: controller.signal });
+    if (!response.ok)
+      throw HTTP_ERROR(response.status);
+    if (response.status === 204) {
+      sink.close();
+      return;
+    }
+    response.headers.get(UI_MESSAGE_STREAM_HEADER) !== UI_MESSAGE_STREAM_VERSION && diagnose({
+      code: "ui-stream.header",
+      message: `Missing ${UI_MESSAGE_STREAM_HEADER}: ${UI_MESSAGE_STREAM_VERSION}.`
+    }), pump(response, sink, replay, controller);
+  }, json = (body) => ({
+    method: "POST",
+    headers: { "content-type": "application/json", ...options.headers?.() },
+    body: JSON.stringify(body)
+  });
+  return {
+    capabilities,
+    async send(request, sink) {
+      const body = options.body?.(request) ?? {
+        id: request.conversationId,
+        messageId: request.messageId,
+        trigger: request.relation === "regenerate" || request.relation === "retry" ? "regenerate-message" : "submit-message",
+        messages: [...request.history, request.prompt].map(toUiMessage)
+      };
+      await open(options.api, json(body), sink, !1);
+    },
+    disconnect(target) {
+      connections.get(target.attemptId)?.abort(), connections.delete(target.attemptId);
+    },
+    ...options.resumeApi ? {
+      async resume(target, sink) {
+        const url = options.resumeApi(target);
+        await open(url, { method: "GET", headers: { ...options.headers?.() } }, sink, !0);
+      }
+    } : {},
+    ...options.stopApi ? {
+      async stop(target) {
+        const url = options.stopApi(target), response = await doFetch(url, json({
+          conversationId: target.conversationId,
+          runId: target.runId,
+          attemptId: target.attemptId
+        }));
+        if (!response.ok)
+          throw HTTP_ERROR(response.status);
+        const result = await response.json().catch(() => ({}));
+        return result.status === "cancelled" || result.status === "already-finished" || result.status === "not-found" ? result.status : "unknown";
+      }
+    } : {},
+    ...options.decideApi ? {
+      async decide(decision) {
+        const url = options.decideApi(decision), response = await doFetch(url, json({ ...decision }));
+        if (!response.ok)
+          throw HTTP_ERROR(response.status);
+        const result = await response.json().catch(() => ({}));
+        if (result.status === "accepted" || result.status === "stale" || result.status === "expired")
+          return result.status;
+        throw toPublicError(void 0, {
+          code: "ai.approval.response",
+          message: "The decision response was not understood."
+        });
+      }
+    } : {}
+  };
+}
+export {
+  UI_MESSAGE_STREAM_HEADER,
+  UI_MESSAGE_STREAM_VERSION,
+  UiMessageStreamReader,
+  createUiMessageStreamTransport,
+  toUiMessage
+};

package/dist/prod/suggestions/index.js

@@ -0,0 +1,11 @@
+import { OddkinSuggestions, SUGGESTIONS_STRINGS } from "./suggestions.js";
+import { suggestionsTemplate } from "./suggestions.template.js";
+import { suggestionsStyles } from "./suggestions.styles.js";
+import { suggestionsDefinition } from "./suggestions.definition.js";
+export {
+  OddkinSuggestions,
+  SUGGESTIONS_STRINGS,
+  suggestionsDefinition,
+  suggestionsStyles,
+  suggestionsTemplate
+};

package/dist/prod/suggestions/suggestions.define.js

@@ -0,0 +1,3 @@
+import { define } from "@oddkin/core/element";
+import { suggestionsDefinition } from "./suggestions.definition.js";
+define(suggestionsDefinition);

package/dist/prod/suggestions/suggestions.definition.js

@@ -0,0 +1,14 @@
+import { compose } from "@oddkin/core/element";
+import { aiBaseStyles } from "../internal/base.styles.js";
+import { OddkinSuggestions } from "./suggestions.js";
+import { suggestionsStyles } from "./suggestions.styles.js";
+import { suggestionsTemplate } from "./suggestions.template.js";
+const suggestionsDefinition = compose({
+  name: "odd-suggestions",
+  element: OddkinSuggestions,
+  template: suggestionsTemplate,
+  styles: [aiBaseStyles, suggestionsStyles]
+});
+export {
+  suggestionsDefinition
+};

package/dist/prod/suggestions/suggestions.js

@@ -0,0 +1,48 @@
+import { OddkinElement, prop } from "@oddkin/core/element";
+import { suggestionSelectEvent, suggestionSubmitEvent } from "../events.js";
+import { strings } from "../internal/strings.js";
+const SUGGESTIONS_STRINGS = {
+  label: "Suggested follow-ups",
+  send: "Send: {label}"
+};
+class OddkinSuggestions extends OddkinElement.with({
+  suggestions: prop.array({ description: "Suggestions (replace to update)." }),
+  disabled: prop.boolean({
+    reflect: !0,
+    description: "Disable both actions (e.g. while sending is unavailable)."
+  }),
+  insertOnly: prop.boolean({
+    attribute: "insert-only",
+    description: "Hide the direct send action."
+  }),
+  strings: prop.object({
+    description: "Localized string overrides."
+  })
+}) {
+  static events = {
+    "odd-suggestion-select": suggestionSelectEvent,
+    "odd-suggestion-submit": suggestionSubmitEvent
+  };
+  /** @internal */
+  get _strings() {
+    return strings(SUGGESTIONS_STRINGS, this.strings);
+  }
+  #find(event) {
+    const id = event.currentTarget.dataset.id;
+    return this.suggestions.find((s) => s.id === id);
+  }
+  /** @internal */
+  _select = (event) => {
+    const s = this.#find(event);
+    s && !this.disabled && this.emit(suggestionSelectEvent, { suggestionId: s.id, prompt: s.prompt });
+  };
+  /** @internal */
+  _submit = (event) => {
+    const s = this.#find(event);
+    s && !this.disabled && this.emit(suggestionSubmitEvent, { suggestionId: s.id, prompt: s.prompt });
+  };
+}
+export {
+  OddkinSuggestions,
+  SUGGESTIONS_STRINGS
+};

package/dist/prod/suggestions/suggestions.recipe.js

@@ -0,0 +1,9 @@
+import { defineLayoutRecipe, row } from "@oddkin/components/layout";
+import { token } from "@oddkin/tokens/refs";
+const suggestionsRecipe = defineLayoutRecipe({
+  name: "suggestions",
+  regions: { list: row({ gap: token("space.xs"), align: "stretch", wrap: !0 }) }
+});
+export {
+  suggestionsRecipe
+};

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

@@ -0,0 +1,15 @@
+import { unsafeCSS } from "@oddkin/core/styles";
+const suggestionsRecipeStyles = unsafeCSS(`@layer odd.layout.base {
+  .list {
+    display: flex;
+    flex-direction: row;
+    align-items: stretch;
+    gap: var(--odd-space-xs);
+    flex-wrap: wrap;
+    min-inline-size: 0;
+  }
+}
+`);
+export {
+  suggestionsRecipeStyles
+};

package/dist/prod/suggestions/suggestions.styles.js

@@ -0,0 +1,52 @@
+import { css } from "@oddkin/core/styles";
+import { token } from "@oddkin/tokens/refs";
+import { suggestionsRecipeStyles } from "./suggestions.recipe.styles.js";
+const suggestionsStyles = css`
+  ${suggestionsRecipeStyles}
+  .list {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+  .item {
+    display: inline-flex;
+    border: ${token("border.width.default")} solid ${token("color.border.default")};
+    border-radius: ${token("radius.full")};
+    background: ${token("color.surface.default")};
+  }
+  button {
+    min-block-size: ${token("target.min")};
+    min-inline-size: ${token("target.min")};
+    padding-inline: ${token("space.sm")};
+    border: 0;
+    border-radius: ${token("radius.full")};
+    background: transparent;
+    color: inherit;
+    font: inherit;
+    font-size: ${token("font.size.sm")};
+    cursor: pointer;
+  }
+  .send {
+    padding-inline: ${token("space.xs")};
+    border-inline-start: ${token("border.width.default")} solid ${token("color.border.default")};
+    border-start-start-radius: 0;
+    border-end-start-radius: 0;
+  }
+  button:disabled {
+    color: ${token("color.text.disabled")};
+    cursor: not-allowed;
+  }
+  @media (hover: hover) {
+    button:not(:disabled):hover {
+      background: ${token("color.surface.hover")};
+    }
+  }
+  @media (forced-colors: active) {
+    .item {
+      border-color: ButtonText;
+    }
+  }
+`;
+export {
+  suggestionsStyles
+};

package/dist/prod/suggestions/suggestions.template.js

@@ -0,0 +1,38 @@
+import { html, repeat } from "@oddkin/core/template";
+import { format } from "../internal/strings.js";
+const suggestionsTemplate = (host) => {
+  const t = host._strings, { disabled, insertOnly } = host;
+  return html`<ul
+    part="list"
+    class="list"
+    aria-label=${t.label}
+    ?hidden=${!host.suggestions.length}
+  >
+    ${repeat(host.suggestions, (s) => s.id, (s) => html`<li class="item">
+          <button
+            part="suggestion"
+            class="suggestion"
+            type="button"
+            data-id=${s.id}
+            ?disabled=${disabled}
+            @click=${host._select}
+          >
+            ${s.label}
+          </button>
+          ${insertOnly ? null : html`<button
+                  part="send"
+                  class="send"
+                  type="button"
+                  data-id=${s.id}
+                  aria-label=${format(t.send, { label: s.label })}
+                  ?disabled=${disabled}
+                  @click=${host._submit}
+                >
+                  <span aria-hidden="true">↑</span>
+                </button>`}
+        </li>`)}
+  </ul>`;
+};
+export {
+  suggestionsTemplate
+};

package/dist/prod/task-plan/index.js

@@ -0,0 +1,11 @@
+import { OddkinTaskPlan, TASK_PLAN_STRINGS } from "./task-plan.js";
+import { taskPlanTemplate } from "./task-plan.template.js";
+import { taskPlanStyles } from "./task-plan.styles.js";
+import { taskPlanDefinition } from "./task-plan.definition.js";
+export {
+  OddkinTaskPlan,
+  TASK_PLAN_STRINGS,
+  taskPlanDefinition,
+  taskPlanStyles,
+  taskPlanTemplate
+};