@xpert-ai/chatkit-types 0.0.4 → 0.0.5

package/dist/index.js

@@ -1,10 +1,17 @@
 var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var _a;
-var __defProp2 = Object.defineProperty;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _a, _collection, _storages, _SignalArray_instances, readStorageFor_fn, dirtyStorageFor_fn;
+var __defProp$1 = Object.defineProperty;
 var __export = (target, all) => {
-  for (var name in all) __defProp2(target, name, {
+  for (var name in all) __defProp$1(target, name, {
     get: all[name],
     enumerable: true
   });
@@ -793,6 +800,1325 @@ function isToolMessageChunk(x) {
 function isClientToolRequest(value) {
   return value && Array.isArray(value.clientToolCalls);
 }
+const eventInit = {
+  bubbles: true,
+  cancelable: true,
+  composed: true
+};
+const _StateEvent = class _StateEvent extends CustomEvent {
+  constructor(payload) {
+    super(_StateEvent.eventName, { detail: payload, ...eventInit });
+    this.payload = payload;
+  }
+};
+_StateEvent.eventName = "a2uiaction";
+let StateEvent = _StateEvent;
+const opacityBehavior = `
+  &:not([disabled]) {
+    cursor: pointer;
+    opacity: var(--opacity, 0);
+    transition: opacity var(--speed, 0.2s) cubic-bezier(0, 0, 0.3, 1);
+
+    &:hover,
+    &:focus {
+      opacity: 1;
+    }
+  }`;
+`
+  ${new Array(21).fill(0).map((_, idx) => {
+  return `.behavior-ho-${idx * 5} {
+          --opacity: ${idx / 20};
+          ${opacityBehavior}
+        }`;
+}).join("\n")}
+
+  .behavior-o-s {
+    overflow: scroll;
+  }
+
+  .behavior-o-a {
+    overflow: auto;
+  }
+
+  .behavior-o-h {
+    overflow: hidden;
+  }
+
+  .behavior-sw-n {
+    scrollbar-width: none;
+  }
+`;
+const grid = 4;
+`
+  ${new Array(25).fill(0).map((_, idx) => {
+  return `
+        .border-bw-${idx} { border-width: ${idx}px; }
+        .border-btw-${idx} { border-top-width: ${idx}px; }
+        .border-bbw-${idx} { border-bottom-width: ${idx}px; }
+        .border-blw-${idx} { border-left-width: ${idx}px; }
+        .border-brw-${idx} { border-right-width: ${idx}px; }
+
+        .border-ow-${idx} { outline-width: ${idx}px; }
+        .border-br-${idx} { border-radius: ${idx * grid}px; overflow: hidden;}`;
+}).join("\n")}
+
+  .border-br-50pc {
+    border-radius: 50%;
+  }
+
+  .border-bs-s {
+    border-style: solid;
+  }
+`;
+const shades = [
+  0,
+  5,
+  10,
+  15,
+  20,
+  25,
+  30,
+  35,
+  40,
+  50,
+  60,
+  70,
+  80,
+  90,
+  95,
+  98,
+  99,
+  100
+];
+function toProp(key) {
+  if (key.startsWith("nv")) {
+    return `--nv-${key.slice(2)}`;
+  }
+  return `--${key[0]}-${key.slice(1)}`;
+}
+const color = (src) => `
+    ${src.map((key) => {
+  const inverseKey = getInverseKey(key);
+  return `.color-bc-${key} { border-color: light-dark(var(${toProp(key)}), var(${toProp(inverseKey)})); }`;
+}).join("\n")}
+
+    ${src.map((key) => {
+  const inverseKey = getInverseKey(key);
+  const vals = [
+    `.color-bgc-${key} { background-color: light-dark(var(${toProp(key)}), var(${toProp(inverseKey)})); }`,
+    `.color-bbgc-${key}::backdrop { background-color: light-dark(var(${toProp(key)}), var(${toProp(inverseKey)})); }`
+  ];
+  for (let o = 0.1; o < 1; o += 0.1) {
+    vals.push(`.color-bbgc-${key}_${(o * 100).toFixed(0)}::backdrop {
+            background-color: light-dark(oklch(from var(${toProp(key)}) l c h / calc(alpha * ${o.toFixed(1)})), oklch(from var(${toProp(inverseKey)}) l c h / calc(alpha * ${o.toFixed(1)})) );
+          }
+        `);
+  }
+  return vals.join("\n");
+}).join("\n")}
+
+  ${src.map((key) => {
+  const inverseKey = getInverseKey(key);
+  return `.color-c-${key} { color: light-dark(var(${toProp(key)}), var(${toProp(inverseKey)})); }`;
+}).join("\n")}
+  `;
+const getInverseKey = (key) => {
+  const match = key.match(/^([a-z]+)(\d+)$/);
+  if (!match)
+    return key;
+  const [, prefix, shadeStr] = match;
+  const shade = parseInt(shadeStr, 10);
+  const target = 100 - shade;
+  const inverseShade = shades.reduce((prev, curr) => Math.abs(curr - target) < Math.abs(prev - target) ? curr : prev);
+  return `${prefix}${inverseShade}`;
+};
+const keyFactory = (prefix) => {
+  return shades.map((v) => `${prefix}${v}`);
+};
+[
+  color(keyFactory("p")),
+  color(keyFactory("s")),
+  color(keyFactory("t")),
+  color(keyFactory("n")),
+  color(keyFactory("nv")),
+  color(keyFactory("e")),
+  `
+    .color-bgc-transparent {
+      background-color: transparent;
+    }
+
+    :host {
+      color-scheme: var(--color-scheme);
+    }
+  `
+];
+`
+  :host {
+    ${new Array(16).fill(0).map((_, idx) => {
+  return `--g-${idx + 1}: ${(idx + 1) * grid}px;`;
+}).join("\n")}
+  }
+
+  ${new Array(49).fill(0).map((_, index) => {
+  const idx = index - 24;
+  const lbl = idx < 0 ? `n${Math.abs(idx)}` : idx.toString();
+  return `
+        .layout-p-${lbl} { --padding: ${idx * grid}px; padding: var(--padding); }
+        .layout-pt-${lbl} { padding-top: ${idx * grid}px; }
+        .layout-pr-${lbl} { padding-right: ${idx * grid}px; }
+        .layout-pb-${lbl} { padding-bottom: ${idx * grid}px; }
+        .layout-pl-${lbl} { padding-left: ${idx * grid}px; }
+
+        .layout-m-${lbl} { --margin: ${idx * grid}px; margin: var(--margin); }
+        .layout-mt-${lbl} { margin-top: ${idx * grid}px; }
+        .layout-mr-${lbl} { margin-right: ${idx * grid}px; }
+        .layout-mb-${lbl} { margin-bottom: ${idx * grid}px; }
+        .layout-ml-${lbl} { margin-left: ${idx * grid}px; }
+
+        .layout-t-${lbl} { top: ${idx * grid}px; }
+        .layout-r-${lbl} { right: ${idx * grid}px; }
+        .layout-b-${lbl} { bottom: ${idx * grid}px; }
+        .layout-l-${lbl} { left: ${idx * grid}px; }`;
+}).join("\n")}
+
+  ${new Array(25).fill(0).map((_, idx) => {
+  return `
+        .layout-g-${idx} { gap: ${idx * grid}px; }`;
+}).join("\n")}
+
+  ${new Array(8).fill(0).map((_, idx) => {
+  return `
+        .layout-grd-col${idx + 1} { grid-template-columns: ${"1fr ".repeat(idx + 1).trim()}; }`;
+}).join("\n")}
+
+  .layout-pos-a {
+    position: absolute;
+  }
+
+  .layout-pos-rel {
+    position: relative;
+  }
+
+  .layout-dsp-none {
+    display: none;
+  }
+
+  .layout-dsp-block {
+    display: block;
+  }
+
+  .layout-dsp-grid {
+    display: grid;
+  }
+
+  .layout-dsp-iflex {
+    display: inline-flex;
+  }
+
+  .layout-dsp-flexvert {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .layout-dsp-flexhor {
+    display: flex;
+    flex-direction: row;
+  }
+
+  .layout-fw-w {
+    flex-wrap: wrap;
+  }
+
+  .layout-al-fs {
+    align-items: start;
+  }
+
+  .layout-al-fe {
+    align-items: end;
+  }
+
+  .layout-al-c {
+    align-items: center;
+  }
+
+  .layout-as-n {
+    align-self: normal;
+  }
+
+  .layout-js-c {
+    justify-self: center;
+  }
+
+  .layout-sp-c {
+    justify-content: center;
+  }
+
+  .layout-sp-ev {
+    justify-content: space-evenly;
+  }
+
+  .layout-sp-bt {
+    justify-content: space-between;
+  }
+
+  .layout-sp-s {
+    justify-content: start;
+  }
+
+  .layout-sp-e {
+    justify-content: end;
+  }
+
+  .layout-ji-e {
+    justify-items: end;
+  }
+
+  .layout-r-none {
+    resize: none;
+  }
+
+  .layout-fs-c {
+    field-sizing: content;
+  }
+
+  .layout-fs-n {
+    field-sizing: none;
+  }
+
+  .layout-flx-0 {
+    flex: 0 0 auto;
+  }
+
+  .layout-flx-1 {
+    flex: 1 0 auto;
+  }
+
+  .layout-c-s {
+    contain: strict;
+  }
+
+  /** Widths **/
+
+  ${new Array(10).fill(0).map((_, idx) => {
+  const weight = (idx + 1) * 10;
+  return `.layout-w-${weight} { width: ${weight}%; max-width: ${weight}%; }`;
+}).join("\n")}
+
+  ${new Array(16).fill(0).map((_, idx) => {
+  const weight = idx * grid;
+  return `.layout-wp-${idx} { width: ${weight}px; }`;
+}).join("\n")}
+
+  /** Heights **/
+
+  ${new Array(10).fill(0).map((_, idx) => {
+  const height = (idx + 1) * 10;
+  return `.layout-h-${height} { height: ${height}%; }`;
+}).join("\n")}
+
+  ${new Array(16).fill(0).map((_, idx) => {
+  const height = idx * grid;
+  return `.layout-hp-${idx} { height: ${height}px; }`;
+}).join("\n")}
+
+  .layout-el-cv {
+    & img,
+    & video {
+      width: 100%;
+      height: 100%;
+      object-fit: cover;
+      margin: 0;
+    }
+  }
+
+  .layout-ar-sq {
+    aspect-ratio: 1 / 1;
+  }
+
+  .layout-ex-fb {
+    margin: calc(var(--padding) * -1) 0 0 calc(var(--padding) * -1);
+    width: calc(100% + var(--padding) * 2);
+    height: calc(100% + var(--padding) * 2);
+  }
+`;
+`
+  ${new Array(21).fill(0).map((_, idx) => {
+  return `.opacity-el-${idx * 5} { opacity: ${idx / 20}; }`;
+}).join("\n")}
+`;
+`
+  :host {
+    --default-font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    --default-font-family-mono: "Courier New", Courier, monospace;
+  }
+
+  .typography-f-s {
+    font-family: var(--font-family, var(--default-font-family));
+    font-optical-sizing: auto;
+    font-variation-settings: "slnt" 0, "wdth" 100, "GRAD" 0;
+  }
+
+  .typography-f-sf {
+    font-family: var(--font-family-flex, var(--default-font-family));
+    font-optical-sizing: auto;
+  }
+
+  .typography-f-c {
+    font-family: var(--font-family-mono, var(--default-font-family));
+    font-optical-sizing: auto;
+    font-variation-settings: "slnt" 0, "wdth" 100, "GRAD" 0;
+  }
+
+  .typography-v-r {
+    font-variation-settings: "slnt" 0, "wdth" 100, "GRAD" 0, "ROND" 100;
+  }
+
+  .typography-ta-s {
+    text-align: start;
+  }
+
+  .typography-ta-c {
+    text-align: center;
+  }
+
+  .typography-fs-n {
+    font-style: normal;
+  }
+
+  .typography-fs-i {
+    font-style: italic;
+  }
+
+  .typography-sz-ls {
+    font-size: 11px;
+    line-height: 16px;
+  }
+
+  .typography-sz-lm {
+    font-size: 12px;
+    line-height: 16px;
+  }
+
+  .typography-sz-ll {
+    font-size: 14px;
+    line-height: 20px;
+  }
+
+  .typography-sz-bs {
+    font-size: 12px;
+    line-height: 16px;
+  }
+
+  .typography-sz-bm {
+    font-size: 14px;
+    line-height: 20px;
+  }
+
+  .typography-sz-bl {
+    font-size: 16px;
+    line-height: 24px;
+  }
+
+  .typography-sz-ts {
+    font-size: 14px;
+    line-height: 20px;
+  }
+
+  .typography-sz-tm {
+    font-size: 16px;
+    line-height: 24px;
+  }
+
+  .typography-sz-tl {
+    font-size: 22px;
+    line-height: 28px;
+  }
+
+  .typography-sz-hs {
+    font-size: 24px;
+    line-height: 32px;
+  }
+
+  .typography-sz-hm {
+    font-size: 28px;
+    line-height: 36px;
+  }
+
+  .typography-sz-hl {
+    font-size: 32px;
+    line-height: 40px;
+  }
+
+  .typography-sz-ds {
+    font-size: 36px;
+    line-height: 44px;
+  }
+
+  .typography-sz-dm {
+    font-size: 45px;
+    line-height: 52px;
+  }
+
+  .typography-sz-dl {
+    font-size: 57px;
+    line-height: 64px;
+  }
+
+  .typography-ws-p {
+    white-space: pre-line;
+  }
+
+  .typography-ws-nw {
+    white-space: nowrap;
+  }
+
+  .typography-td-none {
+    text-decoration: none;
+  }
+
+  /** Weights **/
+
+  ${new Array(9).fill(0).map((_, idx) => {
+  const weight = (idx + 1) * 100;
+  return `.typography-w-${weight} { font-weight: ${weight}; }`;
+}).join("\n")}
+`;
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => {
+  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateIn = (member, obj) => {
+  if (Object(obj) !== obj)
+    throw TypeError('Cannot use the "in" operator on this value');
+  return member.has(obj);
+};
+var __privateAdd2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod2 = (obj, member, method) => {
+  __accessCheck2(obj, member, "access private method");
+  return method;
+};
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function defaultEquals(a, b) {
+  return Object.is(a, b);
+}
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+let activeConsumer = null;
+let inNotificationPhase = false;
+let epoch = 1;
+const SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
+function setActiveConsumer(consumer) {
+  const prev = activeConsumer;
+  activeConsumer = consumer;
+  return prev;
+}
+function getActiveConsumer() {
+  return activeConsumer;
+}
+function isInNotificationPhase() {
+  return inNotificationPhase;
+}
+const REACTIVE_NODE = {
+  version: 0,
+  lastCleanEpoch: 0,
+  dirty: false,
+  producerNode: void 0,
+  producerLastReadVersion: void 0,
+  producerIndexOfThis: void 0,
+  nextProducerIndex: 0,
+  liveConsumerNode: void 0,
+  liveConsumerIndexOfThis: void 0,
+  consumerAllowSignalWrites: false,
+  consumerIsAlwaysLive: false,
+  producerMustRecompute: () => false,
+  producerRecomputeValue: () => {
+  },
+  consumerMarkedDirty: () => {
+  },
+  consumerOnSignalRead: () => {
+  }
+};
+function producerAccessed(node) {
+  if (inNotificationPhase) {
+    throw new Error(
+      typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : ""
+    );
+  }
+  if (activeConsumer === null) {
+    return;
+  }
+  activeConsumer.consumerOnSignalRead(node);
+  const idx = activeConsumer.nextProducerIndex++;
+  assertConsumerNode(activeConsumer);
+  if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
+    if (consumerIsLive(activeConsumer)) {
+      const staleProducer = activeConsumer.producerNode[idx];
+      producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
+    }
+  }
+  if (activeConsumer.producerNode[idx] !== node) {
+    activeConsumer.producerNode[idx] = node;
+    activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+  }
+  activeConsumer.producerLastReadVersion[idx] = node.version;
+}
+function producerIncrementEpoch() {
+  epoch++;
+}
+function producerUpdateValueVersion(node) {
+  if (!node.dirty && node.lastCleanEpoch === epoch) {
+    return;
+  }
+  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+    node.dirty = false;
+    node.lastCleanEpoch = epoch;
+    return;
+  }
+  node.producerRecomputeValue(node);
+  node.dirty = false;
+  node.lastCleanEpoch = epoch;
+}
+function producerNotifyConsumers(node) {
+  if (node.liveConsumerNode === void 0) {
+    return;
+  }
+  const prev = inNotificationPhase;
+  inNotificationPhase = true;
+  try {
+    for (const consumer of node.liveConsumerNode) {
+      if (!consumer.dirty) {
+        consumerMarkDirty(consumer);
+      }
+    }
+  } finally {
+    inNotificationPhase = prev;
+  }
+}
+function producerUpdatesAllowed() {
+  return (activeConsumer == null ? void 0 : activeConsumer.consumerAllowSignalWrites) !== false;
+}
+function consumerMarkDirty(node) {
+  var _a2;
+  node.dirty = true;
+  producerNotifyConsumers(node);
+  (_a2 = node.consumerMarkedDirty) == null ? void 0 : _a2.call(node.wrapper ?? node);
+}
+function consumerBeforeComputation(node) {
+  node && (node.nextProducerIndex = 0);
+  return setActiveConsumer(node);
+}
+function consumerAfterComputation(node, prevConsumer) {
+  setActiveConsumer(prevConsumer);
+  if (!node || node.producerNode === void 0 || node.producerIndexOfThis === void 0 || node.producerLastReadVersion === void 0) {
+    return;
+  }
+  if (consumerIsLive(node)) {
+    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+    }
+  }
+  while (node.producerNode.length > node.nextProducerIndex) {
+    node.producerNode.pop();
+    node.producerLastReadVersion.pop();
+    node.producerIndexOfThis.pop();
+  }
+}
+function consumerPollProducersForChange(node) {
+  assertConsumerNode(node);
+  for (let i = 0; i < node.producerNode.length; i++) {
+    const producer = node.producerNode[i];
+    const seenVersion = node.producerLastReadVersion[i];
+    if (seenVersion !== producer.version) {
+      return true;
+    }
+    producerUpdateValueVersion(producer);
+    if (seenVersion !== producer.version) {
+      return true;
+    }
+  }
+  return false;
+}
+function producerAddLiveConsumer(node, consumer, indexOfThis) {
+  var _a2;
+  assertProducerNode(node);
+  assertConsumerNode(node);
+  if (node.liveConsumerNode.length === 0) {
+    (_a2 = node.watched) == null ? void 0 : _a2.call(node.wrapper);
+    for (let i = 0; i < node.producerNode.length; i++) {
+      node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
+    }
+  }
+  node.liveConsumerIndexOfThis.push(indexOfThis);
+  return node.liveConsumerNode.push(consumer) - 1;
+}
+function producerRemoveLiveConsumerAtIndex(node, idx) {
+  var _a2;
+  assertProducerNode(node);
+  assertConsumerNode(node);
+  if (typeof ngDevMode !== "undefined" && ngDevMode && idx >= node.liveConsumerNode.length) {
+    throw new Error(
+      `Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`
+    );
+  }
+  if (node.liveConsumerNode.length === 1) {
+    (_a2 = node.unwatched) == null ? void 0 : _a2.call(node.wrapper);
+    for (let i = 0; i < node.producerNode.length; i++) {
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+    }
+  }
+  const lastIdx = node.liveConsumerNode.length - 1;
+  node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
+  node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
+  node.liveConsumerNode.length--;
+  node.liveConsumerIndexOfThis.length--;
+  if (idx < node.liveConsumerNode.length) {
+    const idxProducer = node.liveConsumerIndexOfThis[idx];
+    const consumer = node.liveConsumerNode[idx];
+    assertConsumerNode(consumer);
+    consumer.producerIndexOfThis[idxProducer] = idx;
+  }
+}
+function consumerIsLive(node) {
+  var _a2;
+  return node.consumerIsAlwaysLive || (((_a2 = node == null ? void 0 : node.liveConsumerNode) == null ? void 0 : _a2.length) ?? 0) > 0;
+}
+function assertConsumerNode(node) {
+  node.producerNode ?? (node.producerNode = []);
+  node.producerIndexOfThis ?? (node.producerIndexOfThis = []);
+  node.producerLastReadVersion ?? (node.producerLastReadVersion = []);
+}
+function assertProducerNode(node) {
+  node.liveConsumerNode ?? (node.liveConsumerNode = []);
+  node.liveConsumerIndexOfThis ?? (node.liveConsumerIndexOfThis = []);
+}
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function computedGet(node) {
+  producerUpdateValueVersion(node);
+  producerAccessed(node);
+  if (node.value === ERRORED) {
+    throw node.error;
+  }
+  return node.value;
+}
+function createComputed(computation) {
+  const node = Object.create(COMPUTED_NODE);
+  node.computation = computation;
+  const computed = () => computedGet(node);
+  computed[SIGNAL] = node;
+  return computed;
+}
+const UNSET = /* @__PURE__ */ Symbol("UNSET");
+const COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
+const ERRORED = /* @__PURE__ */ Symbol("ERRORED");
+const COMPUTED_NODE = /* @__PURE__ */ (() => {
+  return {
+    ...REACTIVE_NODE,
+    value: UNSET,
+    dirty: true,
+    error: null,
+    equal: defaultEquals,
+    producerMustRecompute(node) {
+      return node.value === UNSET || node.value === COMPUTING;
+    },
+    producerRecomputeValue(node) {
+      if (node.value === COMPUTING) {
+        throw new Error("Detected cycle in computations.");
+      }
+      const oldValue = node.value;
+      node.value = COMPUTING;
+      const prevConsumer = consumerBeforeComputation(node);
+      let newValue;
+      let wasEqual = false;
+      try {
+        newValue = node.computation.call(node.wrapper);
+        const oldOk = oldValue !== UNSET && oldValue !== ERRORED;
+        wasEqual = oldOk && node.equal.call(node.wrapper, oldValue, newValue);
+      } catch (err) {
+        newValue = ERRORED;
+        node.error = err;
+      } finally {
+        consumerAfterComputation(node, prevConsumer);
+      }
+      if (wasEqual) {
+        node.value = oldValue;
+        return;
+      }
+      node.value = newValue;
+      node.version++;
+    }
+  };
+})();
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function defaultThrowError() {
+  throw new Error();
+}
+let throwInvalidWriteToSignalErrorFn = defaultThrowError;
+function throwInvalidWriteToSignalError() {
+  throwInvalidWriteToSignalErrorFn();
+}
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function createSignal(initialValue) {
+  const node = Object.create(SIGNAL_NODE);
+  node.value = initialValue;
+  const getter = () => {
+    producerAccessed(node);
+    return node.value;
+  };
+  getter[SIGNAL] = node;
+  return getter;
+}
+function signalGetFn() {
+  producerAccessed(this);
+  return this.value;
+}
+function signalSetFn(node, newValue) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError();
+  }
+  if (!node.equal.call(node.wrapper, node.value, newValue)) {
+    node.value = newValue;
+    signalValueChanged(node);
+  }
+}
+const SIGNAL_NODE = /* @__PURE__ */ (() => {
+  return {
+    ...REACTIVE_NODE,
+    equal: defaultEquals,
+    value: void 0
+  };
+})();
+function signalValueChanged(node) {
+  node.version++;
+  producerIncrementEpoch();
+  producerNotifyConsumers(node);
+}
+/**
+ * @license
+ * Copyright 2024 Bloomberg Finance L.P.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const NODE = Symbol("node");
+var Signal;
+((Signal2) => {
+  var _a2, _brand, _b, _brand2;
+  class State {
+    constructor(initialValue, options = {}) {
+      __privateAdd2(this, _brand);
+      __publicField2(this, _a2);
+      const ref = createSignal(initialValue);
+      const node = ref[SIGNAL];
+      this[NODE] = node;
+      node.wrapper = this;
+      if (options) {
+        const equals = options.equals;
+        if (equals) {
+          node.equal = equals;
+        }
+        node.watched = options[Signal2.subtle.watched];
+        node.unwatched = options[Signal2.subtle.unwatched];
+      }
+    }
+    get() {
+      if (!(0, Signal2.isState)(this))
+        throw new TypeError("Wrong receiver type for Signal.State.prototype.get");
+      return signalGetFn.call(this[NODE]);
+    }
+    set(newValue) {
+      if (!(0, Signal2.isState)(this))
+        throw new TypeError("Wrong receiver type for Signal.State.prototype.set");
+      if (isInNotificationPhase()) {
+        throw new Error("Writes to signals not permitted during Watcher callback");
+      }
+      const ref = this[NODE];
+      signalSetFn(ref, newValue);
+    }
+  }
+  _a2 = NODE;
+  _brand = /* @__PURE__ */ new WeakSet();
+  Signal2.isState = (s) => typeof s === "object" && __privateIn(_brand, s);
+  Signal2.State = State;
+  class Computed {
+    // Create a Signal which evaluates to the value returned by the callback.
+    // Callback is called with this signal as the parameter.
+    constructor(computation, options) {
+      __privateAdd2(this, _brand2);
+      __publicField2(this, _b);
+      const ref = createComputed(computation);
+      const node = ref[SIGNAL];
+      node.consumerAllowSignalWrites = true;
+      this[NODE] = node;
+      node.wrapper = this;
+      if (options) {
+        const equals = options.equals;
+        if (equals) {
+          node.equal = equals;
+        }
+        node.watched = options[Signal2.subtle.watched];
+        node.unwatched = options[Signal2.subtle.unwatched];
+      }
+    }
+    get() {
+      if (!(0, Signal2.isComputed)(this))
+        throw new TypeError("Wrong receiver type for Signal.Computed.prototype.get");
+      return computedGet(this[NODE]);
+    }
+  }
+  _b = NODE;
+  _brand2 = /* @__PURE__ */ new WeakSet();
+  Signal2.isComputed = (c) => typeof c === "object" && __privateIn(_brand2, c);
+  Signal2.Computed = Computed;
+  ((subtle2) => {
+    var _a22, _brand3, _assertSignals, assertSignals_fn;
+    function untrack(cb) {
+      let output;
+      let prevActiveConsumer = null;
+      try {
+        prevActiveConsumer = setActiveConsumer(null);
+        output = cb();
+      } finally {
+        setActiveConsumer(prevActiveConsumer);
+      }
+      return output;
+    }
+    subtle2.untrack = untrack;
+    function introspectSources(sink) {
+      var _a3;
+      if (!(0, Signal2.isComputed)(sink) && !(0, Signal2.isWatcher)(sink)) {
+        throw new TypeError("Called introspectSources without a Computed or Watcher argument");
+      }
+      return ((_a3 = sink[NODE].producerNode) == null ? void 0 : _a3.map((n) => n.wrapper)) ?? [];
+    }
+    subtle2.introspectSources = introspectSources;
+    function introspectSinks(signal) {
+      var _a3;
+      if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isState)(signal)) {
+        throw new TypeError("Called introspectSinks without a Signal argument");
+      }
+      return ((_a3 = signal[NODE].liveConsumerNode) == null ? void 0 : _a3.map((n) => n.wrapper)) ?? [];
+    }
+    subtle2.introspectSinks = introspectSinks;
+    function hasSinks(signal) {
+      if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isState)(signal)) {
+        throw new TypeError("Called hasSinks without a Signal argument");
+      }
+      const liveConsumerNode = signal[NODE].liveConsumerNode;
+      if (!liveConsumerNode)
+        return false;
+      return liveConsumerNode.length > 0;
+    }
+    subtle2.hasSinks = hasSinks;
+    function hasSources(signal) {
+      if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isWatcher)(signal)) {
+        throw new TypeError("Called hasSources without a Computed or Watcher argument");
+      }
+      const producerNode = signal[NODE].producerNode;
+      if (!producerNode)
+        return false;
+      return producerNode.length > 0;
+    }
+    subtle2.hasSources = hasSources;
+    class Watcher {
+      // When a (recursive) source of Watcher is written to, call this callback,
+      // if it hasn't already been called since the last `watch` call.
+      // No signals may be read or written during the notify.
+      constructor(notify) {
+        __privateAdd2(this, _brand3);
+        __privateAdd2(this, _assertSignals);
+        __publicField2(this, _a22);
+        let node = Object.create(REACTIVE_NODE);
+        node.wrapper = this;
+        node.consumerMarkedDirty = notify;
+        node.consumerIsAlwaysLive = true;
+        node.consumerAllowSignalWrites = false;
+        node.producerNode = [];
+        this[NODE] = node;
+      }
+      // Add these signals to the Watcher's set, and set the watcher to run its
+      // notify callback next time any signal in the set (or one of its dependencies) changes.
+      // Can be called with no arguments just to reset the "notified" state, so that
+      // the notify callback will be invoked again.
+      watch(...signals) {
+        if (!(0, Signal2.isWatcher)(this)) {
+          throw new TypeError("Called unwatch without Watcher receiver");
+        }
+        __privateMethod2(this, _assertSignals, assertSignals_fn).call(this, signals);
+        const node = this[NODE];
+        node.dirty = false;
+        const prev = setActiveConsumer(node);
+        for (const signal of signals) {
+          producerAccessed(signal[NODE]);
+        }
+        setActiveConsumer(prev);
+      }
+      // Remove these signals from the watched set (e.g., for an effect which is disposed)
+      unwatch(...signals) {
+        if (!(0, Signal2.isWatcher)(this)) {
+          throw new TypeError("Called unwatch without Watcher receiver");
+        }
+        __privateMethod2(this, _assertSignals, assertSignals_fn).call(this, signals);
+        const node = this[NODE];
+        assertConsumerNode(node);
+        for (let i = node.producerNode.length - 1; i >= 0; i--) {
+          if (signals.includes(node.producerNode[i].wrapper)) {
+            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+            const lastIdx = node.producerNode.length - 1;
+            node.producerNode[i] = node.producerNode[lastIdx];
+            node.producerIndexOfThis[i] = node.producerIndexOfThis[lastIdx];
+            node.producerNode.length--;
+            node.producerIndexOfThis.length--;
+            node.nextProducerIndex--;
+            if (i < node.producerNode.length) {
+              const idxConsumer = node.producerIndexOfThis[i];
+              const producer = node.producerNode[i];
+              assertProducerNode(producer);
+              producer.liveConsumerIndexOfThis[idxConsumer] = i;
+            }
+          }
+        }
+      }
+      // Returns the set of computeds in the Watcher's set which are still yet
+      // to be re-evaluated
+      getPending() {
+        if (!(0, Signal2.isWatcher)(this)) {
+          throw new TypeError("Called getPending without Watcher receiver");
+        }
+        const node = this[NODE];
+        return node.producerNode.filter((n) => n.dirty).map((n) => n.wrapper);
+      }
+    }
+    _a22 = NODE;
+    _brand3 = /* @__PURE__ */ new WeakSet();
+    _assertSignals = /* @__PURE__ */ new WeakSet();
+    assertSignals_fn = function(signals) {
+      for (const signal of signals) {
+        if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isState)(signal)) {
+          throw new TypeError("Called watch/unwatch without a Computed or State argument");
+        }
+      }
+    };
+    Signal2.isWatcher = (w) => __privateIn(_brand3, w);
+    subtle2.Watcher = Watcher;
+    function currentComputed() {
+      var _a3;
+      return (_a3 = getActiveConsumer()) == null ? void 0 : _a3.wrapper;
+    }
+    subtle2.currentComputed = currentComputed;
+    subtle2.watched = Symbol("watched");
+    subtle2.unwatched = Symbol("unwatched");
+  })(Signal2.subtle || (Signal2.subtle = {}));
+})(Signal || (Signal = {}));
+const createStorage = (initial = null) => new Signal.State(initial, {
+  equals: () => false
+});
+const ARRAY_GETTER_METHODS = /* @__PURE__ */ new Set([Symbol.iterator, "concat", "entries", "every", "filter", "find", "findIndex", "flat", "flatMap", "forEach", "includes", "indexOf", "join", "keys", "lastIndexOf", "map", "reduce", "reduceRight", "slice", "some", "values"]);
+const ARRAY_WRITE_THEN_READ_METHODS = /* @__PURE__ */ new Set(["fill", "push", "unshift"]);
+function convertToInt(prop) {
+  if (typeof prop === "symbol") return null;
+  const num = Number(prop);
+  if (isNaN(num)) return null;
+  return num % 1 === 0 ? num : null;
+}
+const _SignalArray = class _SignalArray {
+  constructor(arr = []) {
+    __privateAdd(this, _SignalArray_instances);
+    __privateAdd(this, _collection, createStorage());
+    __privateAdd(this, _storages, /* @__PURE__ */ new Map());
+    let clone = arr.slice();
+    let self = this;
+    let boundFns = /* @__PURE__ */ new Map();
+    let nativelyAccessingLengthFromPushOrUnshift = false;
+    return new Proxy(clone, {
+      get(target, prop) {
+        var _a2;
+        let index = convertToInt(prop);
+        if (index !== null) {
+          __privateMethod(_a2 = self, _SignalArray_instances, readStorageFor_fn).call(_a2, index);
+          __privateGet(self, _collection).get();
+          return target[index];
+        }
+        if (prop === "length") {
+          if (nativelyAccessingLengthFromPushOrUnshift) {
+            nativelyAccessingLengthFromPushOrUnshift = false;
+          } else {
+            __privateGet(self, _collection).get();
+          }
+          return target[prop];
+        }
+        if (ARRAY_WRITE_THEN_READ_METHODS.has(prop)) {
+          nativelyAccessingLengthFromPushOrUnshift = true;
+        }
+        if (ARRAY_GETTER_METHODS.has(prop)) {
+          let fn = boundFns.get(prop);
+          if (fn === void 0) {
+            fn = (...args) => {
+              __privateGet(self, _collection).get();
+              return target[prop](...args);
+            };
+            boundFns.set(prop, fn);
+          }
+          return fn;
+        }
+        return target[prop];
+      },
+      set(target, prop, value) {
+        var _a2;
+        target[prop] = value;
+        let index = convertToInt(prop);
+        if (index !== null) {
+          __privateMethod(_a2 = self, _SignalArray_instances, dirtyStorageFor_fn).call(_a2, index);
+          __privateGet(self, _collection).set(null);
+        } else if (prop === "length") {
+          __privateGet(self, _collection).set(null);
+        }
+        return true;
+      },
+      getPrototypeOf() {
+        return _SignalArray.prototype;
+      }
+    });
+  }
+  /**
+   * Creates an array from an iterable object.
+   * @param iterable An iterable object to convert to an array.
+   */
+  /**
+   * Creates an array from an iterable object.
+   * @param iterable An iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  static from(iterable, mapfn, thisArg) {
+    return mapfn ? new _SignalArray(Array.from(iterable, mapfn, thisArg)) : new _SignalArray(Array.from(iterable));
+  }
+  static of(...arr) {
+    return new _SignalArray(arr);
+  }
+};
+_collection = new WeakMap();
+_storages = new WeakMap();
+_SignalArray_instances = new WeakSet();
+readStorageFor_fn = function(index) {
+  let storage = __privateGet(this, _storages).get(index);
+  if (storage === void 0) {
+    storage = createStorage();
+    __privateGet(this, _storages).set(index, storage);
+  }
+  storage.get();
+};
+dirtyStorageFor_fn = function(index) {
+  const storage = __privateGet(this, _storages).get(index);
+  if (storage) {
+    storage.set(null);
+  }
+};
+let SignalArray = _SignalArray;
+Object.setPrototypeOf(SignalArray.prototype, Array.prototype);
+class SignalMap {
+  constructor(existing) {
+    __publicField(this, "collection", createStorage());
+    __publicField(this, "storages", /* @__PURE__ */ new Map());
+    __publicField(this, "vals");
+    this.vals = existing ? new Map(existing) : /* @__PURE__ */ new Map();
+  }
+  readStorageFor(key) {
+    const {
+      storages
+    } = this;
+    let storage = storages.get(key);
+    if (storage === void 0) {
+      storage = createStorage();
+      storages.set(key, storage);
+    }
+    storage.get();
+  }
+  dirtyStorageFor(key) {
+    const storage = this.storages.get(key);
+    if (storage) {
+      storage.set(null);
+    }
+  }
+  // **** KEY GETTERS ****
+  get(key) {
+    this.readStorageFor(key);
+    return this.vals.get(key);
+  }
+  has(key) {
+    this.readStorageFor(key);
+    return this.vals.has(key);
+  }
+  // **** ALL GETTERS ****
+  entries() {
+    this.collection.get();
+    return this.vals.entries();
+  }
+  keys() {
+    this.collection.get();
+    return this.vals.keys();
+  }
+  values() {
+    this.collection.get();
+    return this.vals.values();
+  }
+  forEach(fn) {
+    this.collection.get();
+    this.vals.forEach(fn);
+  }
+  get size() {
+    this.collection.get();
+    return this.vals.size;
+  }
+  [Symbol.iterator]() {
+    this.collection.get();
+    return this.vals[Symbol.iterator]();
+  }
+  get [Symbol.toStringTag]() {
+    return this.vals[Symbol.toStringTag];
+  }
+  // **** KEY SETTERS ****
+  set(key, value) {
+    this.dirtyStorageFor(key);
+    this.collection.set(null);
+    this.vals.set(key, value);
+    return this;
+  }
+  delete(key) {
+    this.dirtyStorageFor(key);
+    this.collection.set(null);
+    return this.vals.delete(key);
+  }
+  // **** ALL SETTERS ****
+  clear() {
+    this.storages.forEach((s) => s.set(null));
+    this.collection.set(null);
+    this.vals.clear();
+  }
+}
+Object.setPrototypeOf(SignalMap.prototype, Map.prototype);
+class SignalSet {
+  constructor(existing) {
+    __publicField(this, "collection", createStorage());
+    __publicField(this, "storages", /* @__PURE__ */ new Map());
+    __publicField(this, "vals");
+    this.vals = new Set(existing);
+  }
+  storageFor(key) {
+    const storages = this.storages;
+    let storage = storages.get(key);
+    if (storage === void 0) {
+      storage = createStorage();
+      storages.set(key, storage);
+    }
+    return storage;
+  }
+  dirtyStorageFor(key) {
+    const storage = this.storages.get(key);
+    if (storage) {
+      storage.set(null);
+    }
+  }
+  // **** KEY GETTERS ****
+  has(value) {
+    this.storageFor(value).get();
+    return this.vals.has(value);
+  }
+  // **** ALL GETTERS ****
+  entries() {
+    this.collection.get();
+    return this.vals.entries();
+  }
+  keys() {
+    this.collection.get();
+    return this.vals.keys();
+  }
+  values() {
+    this.collection.get();
+    return this.vals.values();
+  }
+  forEach(fn) {
+    this.collection.get();
+    this.vals.forEach(fn);
+  }
+  get size() {
+    this.collection.get();
+    return this.vals.size;
+  }
+  [Symbol.iterator]() {
+    this.collection.get();
+    return this.vals[Symbol.iterator]();
+  }
+  get [Symbol.toStringTag]() {
+    return this.vals[Symbol.toStringTag];
+  }
+  // **** KEY SETTERS ****
+  add(value) {
+    this.dirtyStorageFor(value);
+    this.collection.set(null);
+    this.vals.add(value);
+    return this;
+  }
+  delete(value) {
+    this.dirtyStorageFor(value);
+    this.collection.set(null);
+    return this.vals.delete(value);
+  }
+  // **** ALL SETTERS ****
+  clear() {
+    this.storages.forEach((s) => s.set(null));
+    this.collection.set(null);
+    this.vals.clear();
+  }
+}
+Object.setPrototypeOf(SignalSet.prototype, Set.prototype);
 var ChatMessageTypeEnum = /* @__PURE__ */ ((ChatMessageTypeEnum2) => {
   ChatMessageTypeEnum2["MESSAGE"] = "message";
   ChatMessageTypeEnum2["EVENT"] = "event";
@@ -815,6 +2141,7 @@ var ChatMessageEventTypeEnum = /* @__PURE__ */ ((ChatMessageEventTypeEnum2) => {
   ChatMessageEventTypeEnum2["ON_INTERRUPT"] = "on_interrupt";
   ChatMessageEventTypeEnum2["ON_ERROR"] = "on_error";
   ChatMessageEventTypeEnum2["ON_CHAT_EVENT"] = "on_chat_event";
+  ChatMessageEventTypeEnum2["ON_CLIENT_EFFECT"] = "on_client_effect";
   return ChatMessageEventTypeEnum2;
 })(ChatMessageEventTypeEnum || {});
 var ChatMessageStepCategory = /* @__PURE__ */ ((ChatMessageStepCategory2) => {
@@ -829,10 +2156,36 @@ var ChatMessageStepCategory = /* @__PURE__ */ ((ChatMessageStepCategory2) => {
   ChatMessageStepCategory2["Knowledges"] = "knowledges";
   return ChatMessageStepCategory2;
 })(ChatMessageStepCategory || {});
+const STATE_VARIABLE_HUMAN = "human";
+const ALLOWED_KEYS = [
+  "api",
+  "theme",
+  "composer",
+  "startScreen"
+];
+function filterPlaygroundOptions(options) {
+  const filtered = {};
+  for (const key of ALLOWED_KEYS) {
+    if (key in options && options[key] !== void 0) {
+      filtered[key] = options[key];
+    }
+  }
+  return filtered;
+}
+function mergeWithPlaygroundOptions(localOptions, playgroundOptions) {
+  const filteredPlayground = filterPlaygroundOptions(playgroundOptions);
+  return {
+    ...localOptions,
+    ...filteredPlayground
+  };
+}
 export {
   ChatMessageEventTypeEnum,
   ChatMessageStepCategory,
   ChatMessageTypeEnum,
-  isClientToolRequest
+  STATE_VARIABLE_HUMAN,
+  filterPlaygroundOptions,
+  isClientToolRequest,
+  mergeWithPlaygroundOptions
 };
 //# sourceMappingURL=index.js.map