@haikit/client 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haikit/client",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "The haikit browser runtime: streams tool payloads into interactive UI surfaces. Plain ESM, no build step, no dependencies.",
   "keywords": [
     "haikit",

package/src/app.d.ts

@@ -17,7 +17,9 @@ export interface MountChatOptions {
 
 /**
  * Builds the shell, wires the composer, renders the transcript and mounts your
- * surfaces. The ten-line path to a running app.
+ * surfaces. The ten-line path to a running app. It starts the conversation as
+ * soon as it opens, and again after `reset()`, so a server with an init tool
+ * runs it before the user types.
  *
  * It is a convenience, not the API — everything it does is built on `createChat`
  * and `renderTranscript`. Dropping to those when this shell stops fitting is the

package/src/app.js

@@ -96,7 +96,7 @@ export function mountChat({
     });
   };
 
-  function renderEmpty() {
+  function emptyState() {
     const empty = h("div", "hai-empty");
     if (emptyText) empty.append(h("p", null, emptyText));
     if (suggestions.length) {
@@ -108,13 +108,27 @@ export function mountChat({
       }
       empty.append(row);
     }
-    transcript.replaceChildren(empty);
+    return empty;
   }
 
+  const renderEmpty = () => transcript.replaceChildren(emptyState());
+
   // ── wiring ─────────────────────────────────────────────────────────
-  chat.subscribe((state) => {
+  chat.subscribe((state, event) => {
+    // A new conversation starts at once, so the server's init tool — if it
+    // has one — runs before anything is typed.
+    if (event.type === "reset") chat.start();
+
     if (state.blocks.length === 0) renderEmpty();
-    else renderTranscript(transcript, chat);
+    else {
+      renderTranscript(transcript, chat);
+      // what the conversation opened with (an init tool's row, a welcome
+      // surface) doesn't replace the suggestions; the user engaging does —
+      // a first message, or an answer to something init showed
+      if (!state.blocks.some((b) => b.kind === "user" || b.kind === "interaction")) {
+        transcript.append(emptyState());
+      }
+    }
 
     modelEl.textContent = state.model;
     input.disabled = state.expired !== null;
@@ -141,6 +155,7 @@ export function mountChat({
   };
 
   renderEmpty();
+  chat.start();
   return chat;
 }
 

package/src/index.d.ts

@@ -111,6 +111,14 @@ export interface Chat {
    * cleared its input can then put the text back.
    */
   send(text: string): Promise<boolean>;
+  /**
+   * Start the conversation before the user types, so a server with an init
+   * tool runs it now and anything it shows is already there. Does nothing once
+   * the conversation has begun, and a server without an init tool creates
+   * nothing. If init throws, nothing is recorded, so calling it again tries
+   * again. `mountChat` calls it when it opens and after `reset()`.
+   */
+  start(): Promise<boolean>;
   interact(handle: string, action: string, value: unknown): Promise<void>;
   /** Mounts the surface for `handle` into `element`. Null if props have not arrived. */
   mount(handle: string, element: HTMLElement): SurfaceInstance | null;

package/src/index.js

@@ -332,6 +332,28 @@ export function createChat({ endpoint = "/hai", registry }) {
     return enqueue("/chat", { message: text });
   }
 
+  /**
+   * Whether the server has recorded this conversation's opening — init's call,
+   * or a first message — as its last `context` shows. Having a conversation id
+   * is not enough: `hello` arrives before init runs, and an init that throws
+   * leaves the id behind with an empty history.
+   */
+  const begun = () => state.context.messages.length > 0;
+
+  /**
+   * Start the conversation before the user types, so a server with an init
+   * tool runs it now and whatever it shows is there first. Does nothing once
+   * the conversation has begun. If init throws, the server records nothing,
+   * so calling this again tries again — as the first message would. A server
+   * without an init tool answers with an empty stream and creates nothing;
+   * the first message starts the conversation, as it always has. Resolves
+   * like send().
+   */
+  async function start() {
+    if (begun() || closed()) return false;
+    return enqueue("/start", {});
+  }
+
   // A click carries nothing the user authored, and stacking them is worse than
   // dropping them: a double-click on a picker row would resolve it and then
   // queue a second resolution into "component is frozen". The deadline is
@@ -365,6 +387,7 @@ export function createChat({ endpoint = "/hai", registry }) {
 
   return {
     state,
+    start,
     send,
     interact,
     mount,