@praecise/conversation 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

package/README.md

@@ -0,0 +1,72 @@
+# @praecise/conversation
+
+What an agent is doing, while it does it.
+
+A run already tells the whole story on the wire: which self was asked, what it
+drew on, which model answered, whether a verifier agreed, what was checked, what
+it cost. Most interfaces throw that away and show a spinner — so a person can't
+tell thinking from broken, or an answer that was checked from one that was
+guessed.
+
+This renders those frames as they arrive: one line per step, openable for the
+detail underneath, collapsing to a summary when the answer lands. **Nothing here
+invents a step.** Every line is a frame the server actually sent.
+
+```sh
+npm i @praecise/conversation
+```
+
+## Use
+
+```js
+import { mountRun, readRun } from "@praecise/conversation";
+import "@praecise/conversation/conversation.css";
+
+const run = mountRun(document.querySelector("#trail"), { self: "economist" });
+
+const res = await fetch("/chat/fast", { method: "POST", body: JSON.stringify({ message }) });
+const text = await readRun(res.body, run, (sofar) => {
+  answerEl.innerHTML = renderMarkdown(sofar);   // your renderer, your markup
+});
+run.settle(Boolean(text));
+```
+
+`readRun` is optional — if you already read the stream, hand each frame to
+`run.frame(evt)` and call `run.settle(ok)` at the end.
+
+## What it shows
+
+| Step | Line |
+|---|---|
+| `selves` | context from economist · drew on 3 things |
+| `routing` | routed to fleet/qwen3.8-27b · verified · difficulty 0.40 |
+| `grounding` | grounding with live data |
+| `checking` | a second pass is checking the answer |
+| `checked` | checked and kept · agreement 1.00 |
+| `done` | answered · 3,640 in · 2 out · fleet/qwen3.8-27b |
+
+A step it does not know still appears, named as it came: a newer server never
+breaks an older page. Any step with detail opens to the raw frame.
+
+## Styling
+
+No framework, no build step: it makes DOM nodes and reads the host page's own
+CSS variables, so it looks like the product it is in rather than like itself.
+
+```css
+.pc-run { --pc-ink: #1a1a1a; --pc-quiet: #6b6b6b; --pc-rule: #e3e4e5; --pc-signal: #4b6a00; }
+```
+
+It also falls back to `--ink`, `--quiet`, `--rule`, `--signal-deep` and
+`--paper-dim` if a product already defines those, and to plain greys if it
+defines nothing. Every class is yours to restyle: `.pc-run`, `.pc-run-head`,
+`.pc-run-steps`, `.pc-run-step`, `.pc-run-line`, `.pc-run-title`,
+`.pc-run-note`, `.pc-run-detail`.
+
+## Frames
+
+The shapes are the [Praecise harness](https://www.npmjs.com/package/@praecise/harness)'s:
+`RunStarted`, `StepStarted`, `StepFinished`, `TextMessageContent`, `RunFinished`,
+`RunError`. Anything else is ignored rather than thrown on.
+
+Apache-2.0.

package/conversation.css

@@ -0,0 +1,90 @@
+/* @praecise/conversation — the minimum, in the host page's own colours.
+ *
+ * Every colour and radius comes from a CSS variable with a plain fallback, so a
+ * product that defines --pc-ink or --ink gets its own palette without touching
+ * this file, and a product that defines nothing still reads. Flat by default:
+ * hairlines, no shadow, no gradient.
+ */
+
+.pc-run {
+  --_ink: var(--pc-ink, var(--ink, #1a1a1a));
+  --_quiet: var(--pc-quiet, var(--quiet, #6b6b6b));
+  --_rule: var(--pc-rule, var(--rule, #e3e4e5));
+  --_panel: var(--pc-panel, var(--paper-dim, #f5f5f4));
+  --_signal: var(--pc-signal, var(--signal-deep, #4b6a00));
+  --_bad: var(--pc-bad, var(--danger, #c1272d));
+  --_mono: var(--pc-mono, var(--mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace));
+
+  margin: 0 0 0.75rem;
+  border-left: 2px solid var(--_rule);
+  padding-left: 0.75rem;
+  font-size: 0.8125rem;
+  color: var(--_quiet);
+}
+
+.pc-run-head {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  border: 0;
+  background: none;
+  padding: 0.15rem 0;
+  margin: 0;
+  color: inherit;
+  font: inherit;
+  font-family: var(--_mono);
+  cursor: pointer;
+  text-align: left;
+}
+.pc-run-head:hover .pc-run-label { color: var(--_ink); }
+
+/* A mark that moves while the run does, and stops when it stops. */
+.pc-run-dot {
+  width: 6px; height: 6px; flex: none;
+  background: var(--_signal);
+  border-radius: 50%;
+  animation: pc-run-pulse 1.1s ease-in-out infinite;
+}
+.pc-run-ok .pc-run-dot { background: var(--_signal); animation: none; }
+.pc-run-bad .pc-run-dot { background: var(--_bad); animation: none; }
+@keyframes pc-run-pulse { 0%, 100% { opacity: 0.25; } 50% { opacity: 1; } }
+@media (prefers-reduced-motion: reduce) { .pc-run-dot { animation: none; } }
+
+.pc-run-steps { list-style: none; margin: 0.35rem 0 0; padding: 0; display: grid; gap: 0.15rem; }
+.pc-run-closed .pc-run-steps { display: none; }
+
+.pc-run-line {
+  display: flex; gap: 0.5rem; align-items: baseline; flex-wrap: wrap;
+  width: 100%; text-align: left;
+  border: 0; background: none; padding: 0.1rem 0; margin: 0;
+  color: inherit; font: inherit; cursor: pointer;
+}
+.pc-run-line:disabled, .pc-run-bare { cursor: default; }
+.pc-run-line:not(:disabled):hover .pc-run-title { color: var(--_ink); }
+
+.pc-run-title::before {
+  content: "·";
+  color: var(--_rule);
+  margin-right: 0.4rem;
+}
+.pc-run-live .pc-run-title::before { content: "›"; color: var(--_signal); }
+
+.pc-run-note { font-family: var(--_mono); font-size: 0.75rem; color: var(--_quiet); }
+
+.pc-run-detail {
+  margin: 0.2rem 0 0.35rem 0.9rem;
+  padding: 0.5rem 0.6rem;
+  background: var(--_panel);
+  border: 1px solid var(--_rule);
+  border-radius: var(--pc-radius, 4px);
+  font-family: var(--_mono);
+  font-size: 0.7rem;
+  line-height: 1.5;
+  color: var(--_ink);
+  overflow-x: auto;
+  max-height: 16rem;
+}
+
+@media (max-width: 480px) {
+  .pc-run-note { width: 100%; }
+}

package/index.js

@@ -0,0 +1,235 @@
+/**
+ * @praecise/conversation — what an agent is doing, while it does it.
+ *
+ * A run already tells the whole story on the wire: which self was asked, what it
+ * drew on, which model answered, whether a verifier agreed, what was checked,
+ * what it cost. Most interfaces throw all of that away and show a spinner, so a
+ * person cannot tell thinking from broken, or an answer that was checked from
+ * one that was guessed.
+ *
+ * This renders those frames as they arrive: one line per step, openable for the
+ * detail underneath, collapsing to a single summary when the answer lands.
+ * Nothing here invents a step — every line is a frame the server sent.
+ *
+ * No framework and no build step: it makes DOM nodes and takes the host page's
+ * own CSS variables, so it looks like the product it is in rather than like
+ * itself. The stylesheet beside it is the minimum; a product may restyle every
+ * class.
+ *
+ *   import { mountRun } from "@praecise/conversation";
+ *
+ *   const run = mountRun(container);          // returns a handle
+ *   for await (const frame of frames) run.frame(frame);
+ *   run.settle(true);
+ */
+
+/** Frame kinds this understands. Anything else still shows, named as it came. */
+const KNOWN = new Set(["selves", "routing", "grounding", "checking", "checked", "done"]);
+
+const number = (n) => (typeof n === "number" ? n.toLocaleString() : null);
+
+/**
+ * One readable line for a step.
+ *
+ * The wording says what happened to the work, not what the system did to
+ * itself: "checked and kept" rather than "verifier returned agreement=1".
+ */
+function describe(kind, raw, opts) {
+  const d = raw || {};
+  switch (kind) {
+    case "selves":
+      return {
+        title: `context from ${d.self || opts.self || "the self"}`,
+        note: drewOn(d.drewOn),
+      };
+    case "routing":
+      return {
+        title: `routed to ${d.entry || "a model"}`,
+        note: [
+          d.verify ? "verified" : null,
+          typeof d.difficulty === "number" ? `difficulty ${d.difficulty.toFixed(2)}` : null,
+          d.rungs ? `${d.rungs} rungs` : null,
+        ].filter(Boolean).join(" · "),
+      };
+    case "grounding":
+      return { title: "grounding with live data", note: d.source || "" };
+    case "checking":
+      return { title: "a second pass is checking the answer", note: "" };
+    case "checked":
+      return {
+        title: d.kept === false ? "the check disagreed, and it was rewritten" : "checked and kept",
+        note: typeof d.agreement === "number" ? `agreement ${d.agreement.toFixed(2)}` : "",
+      };
+    case "done":
+      return { title: "answered", note: usage(d.answer) };
+    default:
+      return { title: kind.replace(/[-_]/g, " "), note: "" };
+  }
+}
+
+function drewOn(list) {
+  if (!Array.isArray(list) || !list.length) return "nothing held yet";
+  return `drew on ${list.length} ${list.length === 1 ? "thing" : "things"}`;
+}
+
+function usage(answer) {
+  const u = answer && answer.usage;
+  if (!u) return "";
+  const bits = [];
+  if (number(u.inputTokens)) bits.push(`${number(u.inputTokens)} in`);
+  if (number(u.outputTokens)) bits.push(`${number(u.outputTokens)} out`);
+  const path = answer.path;
+  if (Array.isArray(path) && path.length) bits.push(path[path.length - 1]);
+  return bits.join(" · ");
+}
+
+const el = (tag, cls, text) => {
+  const n = document.createElement(tag);
+  if (cls) n.className = cls;
+  if (text !== undefined) n.textContent = text;
+  return n;
+};
+
+/**
+ * Put a run's trail in `container` and return a handle.
+ *
+ * `opts.self` names the self when a frame does not. `opts.open` starts it
+ * expanded (the default while a run is live). `opts.labels` replaces any
+ * wording — a product that calls its selves something else says so here.
+ */
+export function mountRun(container, opts = {}) {
+  const box = el("div", "pc-run");
+  const head = el("button", "pc-run-head");
+  head.type = "button";
+  head.setAttribute("aria-expanded", "true");
+  const dot = el("span", "pc-run-dot");
+  const label = el("span", "pc-run-label", opts.labels?.working ?? "working");
+  head.append(dot, label);
+
+  const list = el("ol", "pc-run-steps");
+  head.addEventListener("click", () => {
+    const closed = box.classList.toggle("pc-run-closed");
+    head.setAttribute("aria-expanded", closed ? "false" : "true");
+  });
+  box.append(head, list);
+  if (opts.open === false) box.classList.add("pc-run-closed");
+  container.appendChild(box);
+
+  const rows = new Map();
+  const startedAt = Date.now();
+  let count = 0;
+
+  function line(kind, raw) {
+    const said = describe(kind, raw, opts);
+    const li = el("li", "pc-run-step pc-run-live");
+    const button = el("button", "pc-run-line");
+    button.type = "button";
+    const title = el("span", "pc-run-title", said.title);
+    const note = el("span", "pc-run-note", said.note);
+    button.append(title, note);
+
+    const detail = el("pre", "pc-run-detail");
+    detail.hidden = true;
+    const hasDetail = raw && Object.keys(raw).length > 0;
+    if (hasDetail) {
+      detail.textContent = JSON.stringify(raw, null, 2);
+      button.addEventListener("click", () => { detail.hidden = !detail.hidden; });
+    } else {
+      button.classList.add("pc-run-bare");
+      button.disabled = true;
+    }
+
+    li.append(button, detail);
+    list.appendChild(li);
+    rows.set(kind, { li, title, note, detail, button });
+    count += 1;
+    label.textContent = said.title;
+    return rows.get(kind);
+  }
+
+  const handle = {
+    /** A step began, or was seen for the first time. */
+    step(kind, raw) {
+      if (!rows.has(kind)) line(kind, raw);
+    },
+
+    /** The same step finished: the line stays, the mark stops moving. */
+    finish(kind, raw) {
+      const row = rows.get(kind) ?? line(kind, raw);
+      row.li.className = "pc-run-step";
+      if (raw && Object.keys(raw).length) {
+        const said = describe(kind, raw, opts);
+        row.title.textContent = said.title;
+        row.note.textContent = said.note;
+        row.detail.textContent = JSON.stringify(raw, null, 2);
+        row.button.disabled = false;
+        row.button.classList.remove("pc-run-bare");
+      }
+    },
+
+    /**
+     * One frame off the wire, in the shape the Praecise harness sends. Unknown
+     * types are ignored rather than thrown on: a newer server must not break an
+     * older page.
+     */
+    frame(evt) {
+      if (!evt || typeof evt !== "object") return;
+      const kind = evt.stepName || (evt.rawEvent && evt.rawEvent.kind) || "step";
+      switch (evt.type) {
+        case "StepStarted": return handle.step(kind, evt.rawEvent);
+        case "StepFinished": return handle.finish(kind, evt.rawEvent);
+        case "RunFinished": return evt.rawEvent ? handle.finish("done", evt.rawEvent) : undefined;
+        case "RunError": return handle.settle(false, evt.message);
+        default: return undefined;
+      }
+    },
+
+    /** The run ended. One line a person can leave closed. */
+    settle(ok, why) {
+      const seconds = ((Date.now() - startedAt) / 1000).toFixed(1);
+      box.classList.add("pc-run-closed", ok ? "pc-run-ok" : "pc-run-bad");
+      head.setAttribute("aria-expanded", "false");
+      for (const row of rows.values()) row.li.classList.remove("pc-run-live");
+      label.textContent = ok
+        ? `${count} ${count === 1 ? "step" : "steps"} · ${seconds}s`
+        : `${why || "did not finish"} · ${seconds}s`;
+    },
+
+    /** The element, for a product that wants to move or remove it. */
+    element: box,
+  };
+  return handle;
+}
+
+/**
+ * Read an SSE body and hand every frame to a run. Returns the text that was
+ * streamed, so a caller can keep rendering the answer itself.
+ */
+export async function readRun(body, run, onText) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let text = "";
+  for (;;) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    buffer += decoder.decode(chunk.value, { stream: true });
+    const frames = buffer.split("\n\n");
+    buffer = frames.pop() ?? "";
+    for (const frame of frames) {
+      const dataLine = frame.split("\n").find((l) => l.startsWith("data: "));
+      if (!dataLine) continue;
+      let evt;
+      try { evt = JSON.parse(dataLine.slice(6)); } catch { continue; }
+      if (evt.type === "TextMessageContent") {
+        text += evt.delta ?? evt.content ?? evt.text ?? "";
+        if (onText) onText(text, evt);
+      } else {
+        run.frame(evt);
+      }
+    }
+  }
+  return text;
+}
+
+export const KNOWN_STEPS = KNOWN;

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@praecise/conversation",
+  "version": "0.1.0",
+  "description": "What an agent is doing, while it does it: a live run trail from Praecise harness frames. No framework, no build step.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": "./index.js",
+    "./conversation.css": "./conversation.css"
+  },
+  "files": ["index.js", "conversation.css", "README.md", "LICENSE"],
+  "keywords": ["agents", "sse", "ag-ui", "praecise", "ui"],
+  "homepage": "https://platform.recursiveselves.com",
+  "publishConfig": { "access": "public" },
+  "sideEffects": ["*.css"]
+}