@vellumai/assistant 0.12.0-staging.1 → 0.12.0

package/src/runtime/sync/activation-sidecar-publish.test.ts

@@ -0,0 +1,78 @@
+/**
+ * A scheduled or background turn working a checklist task runs in a sidecar
+ * worker, whose local hub has no SSE subscriber. The activation-progress
+ * invalidation has to be handed to the daemon there, or the checklist row
+ * keeps showing Working on every client until something else refetches it.
+ *
+ * The two branches are told apart by what reaches the local hub: the daemon
+ * publishes there, the worker publishes nothing and calls the daemon over
+ * IPC instead (that hand-off is covered in `worker-daemon-notify.test.ts`).
+ * No module is mocked here, so nothing this file does can reach a sibling
+ * file bun runs in the same process.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { AssistantEventEnvelope } from "../../api/index.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
+import {
+  _resetStreamStateForTesting,
+  disableStreamSeqStamping,
+} from "../assistant-stream-state.js";
+import { publishActivationProgressChanged } from "./resource-sync-events.js";
+
+async function settle(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+/** Run `publish`, then return the `sync_changed` events it put on the hub. */
+async function captureLocalPublishes(
+  publish: () => void,
+): Promise<AssistantEventEnvelope[]> {
+  await settle();
+  const received: AssistantEventEnvelope[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    callback: (event) => {
+      if (event.message.type === "sync_changed") {
+        received.push(event);
+      }
+    },
+  });
+  try {
+    publish();
+    await settle();
+    return received;
+  } finally {
+    subscription.dispose();
+  }
+}
+
+describe("publishActivationProgressChanged", () => {
+  beforeEach(async () => {
+    await settle();
+    _resetStreamStateForTesting();
+  });
+
+  test("publishes on the local hub in the daemon, where subscribers live", async () => {
+    const events = await captureLocalPublishes(() => {
+      publishActivationProgressChanged("client-a");
+    });
+
+    expect(events).toHaveLength(1);
+    expect(events[0].message).toMatchObject({
+      type: "sync_changed",
+      tags: ["activation:progress"],
+    });
+  });
+
+  test("publishes nothing locally in a sidecar worker", async () => {
+    disableStreamSeqStamping();
+
+    const events = await captureLocalPublishes(() => {
+      publishActivationProgressChanged();
+    });
+
+    expect(events).toEqual([]);
+  });
+});

package/src/runtime/sync/documents-sidecar-publish.test.ts

@@ -13,6 +13,9 @@ mock.module("./worker-daemon-notify.js", () => ({
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD:
     "notify_conversation_persisted_externally",
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD: "notify_documents_changed_externally",
+  NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD:
+    "notify_activation_progress_changed_externally",
+  notifyDaemonActivationProgressChanged: async () => {},
   notifyDaemonConversationPersisted: async () => {},
   notifyDaemonDocumentsChanged: async () => {
     notifyCount++;

package/src/runtime/sync/resource-sync-events.ts

@@ -10,6 +10,7 @@ import { broadcastMessage } from "../assistant-event-hub.js";
 import { isStreamSeqStampingDisabled } from "../assistant-stream-state.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 import {
+  notifyDaemonActivationProgressChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
@@ -150,6 +151,28 @@ export function publishPluginsChanged(originClientId?: string): void {
   void publishSyncInvalidation([SYNC_TAGS.pluginsList], originClientId);
 }
 
+/**
+ * Invalidate the activation-checklist progress resource on every client.
+ *
+ * Reached from the routes the client writes through and from the turn hooks
+ * that count a launched task's steps. Those hooks run inside whichever
+ * process is driving the turn, and a scheduled or background turn runs in a
+ * sidecar worker (seq stamping disabled) whose local hub has no SSE
+ * subscribers, so a local publish would reach nobody and the checklist row
+ * would sit on Working until the client refetched for another reason. Hand
+ * off to the daemon there, as the documents list does. A worker turn has no
+ * originating client, so no `originClientId` is forwarded.
+ */
+export function publishActivationProgressChanged(
+  originClientId?: string,
+): void {
+  if (isStreamSeqStampingDisabled()) {
+    void notifyDaemonActivationProgressChanged();
+    return;
+  }
+  void publishSyncInvalidation([SYNC_TAGS.activationProgress], originClientId);
+}
+
 /**
  * Reasons that change the *shape* of the conversation list — a row is
  * added, removed, or its position changes. These require web clients to

package/src/runtime/sync/worker-daemon-notify.test.ts

@@ -32,8 +32,10 @@ mock.module("../../ipc/cli-client.js", () => ({
 }));
 
 import {
+  NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD,
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD,
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD,
+  notifyDaemonActivationProgressChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
@@ -101,3 +103,37 @@ describe("notifyDaemonDocumentsChanged", () => {
     expect(calls).toHaveLength(1);
   });
 });
+
+describe("notifyDaemonActivationProgressChanged", () => {
+  beforeEach(() => {
+    calls.length = 0;
+    nextResult = { ok: true };
+    shouldThrow = false;
+  });
+
+  test("asks the daemon to republish over the shared IPC method", async () => {
+    await notifyDaemonActivationProgressChanged();
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.method).toBe(
+      NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD,
+    );
+    expect(calls[0]!.params).toEqual({ body: {} });
+  });
+
+  test("swallows a failed IPC result (best-effort, no throw)", async () => {
+    nextResult = { ok: false, error: "daemon unreachable" };
+
+    const result = await notifyDaemonActivationProgressChanged();
+    expect(result).toBeUndefined();
+    expect(calls).toHaveLength(1);
+  });
+
+  test("swallows a thrown IPC error (best-effort, no throw)", async () => {
+    shouldThrow = true;
+
+    const result = await notifyDaemonActivationProgressChanged();
+    expect(result).toBeUndefined();
+    expect(calls).toHaveLength(1);
+  });
+});

package/src/runtime/sync/worker-daemon-notify.ts

@@ -7,7 +7,8 @@
  * live in the daemon). A worker hands the notification here instead and the
  * daemon republishes it to real subscribers (see
  * `ipc/routes/conversation-sync-ipc-routes.ts`,
- * `ipc/routes/documents-sync-ipc-routes.ts`).
+ * `ipc/routes/documents-sync-ipc-routes.ts`,
+ * `ipc/routes/activation-sync-ipc-routes.ts`).
  */
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
@@ -30,6 +31,14 @@ export const NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD =
 export const NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD =
   "notify_documents_changed_externally";
 
+/**
+ * IPC method the daemon exposes for the activation-progress hand-off. Shared
+ * by the worker caller and the daemon route registration so the wire name
+ * cannot drift.
+ */
+export const NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD =
+  "notify_activation_progress_changed_externally";
+
 /**
  * Short timeout: this is a fire-and-forget invalidation, not a request whose
  * result the worker consumes. A busy or unreachable daemon simply leaves the
@@ -99,3 +108,32 @@ export async function notifyDaemonDocumentsChanged(): Promise<void> {
     log.debug({ err }, "daemon documents-changed notify failed");
   }
 }
+
+/**
+ * Ask the daemon to republish the activation-progress invalidation.
+ *
+ * A scheduled or background turn working a checklist task moves that task's
+ * step count and finishes it, but the worker's own broadcast reaches nobody.
+ * This is the path that lets the checklist row stop showing Working.
+ *
+ * Best-effort by design, like the other hand-offs: an unreachable daemon is
+ * logged at debug and swallowed, and the client picks the change up on its
+ * next progress fetch.
+ */
+export async function notifyDaemonActivationProgressChanged(): Promise<void> {
+  try {
+    const result = await cliIpcCall(
+      NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD,
+      { body: {} },
+      { timeoutMs: NOTIFY_TIMEOUT_MS },
+    );
+    if (!result.ok) {
+      log.debug(
+        { error: result.error },
+        "daemon activation-progress notify was not acknowledged",
+      );
+    }
+  } catch (err) {
+    log.debug({ err }, "daemon activation-progress notify failed");
+  }
+}

package/src/tools/apps/executors.ts

@@ -8,6 +8,8 @@
  * ToolDefinition or ToolContext types.
  */
 
+import { normalizeAppIcon } from "@vellumai/app-icons";
+
 import type { AppDefinition } from "../../apps/app-store.js";
 import { getAppDirPath } from "../../apps/app-store.js";
 import { compileApp } from "../../bundler/app-compiler.js";
@@ -208,14 +210,12 @@ export async function executeAppCreate(
     return sourceFilesError;
   }
 
-  // Extract icon from preview if provided - only persist emoji-like values,
-  // not URLs which would render as raw strings in UI and bundle manifests.
-  // Lenient alias: a top-level `icon` is folded in when preview.icon is absent.
-  const rawIcon = (preview?.icon ??
-    (typeof input.icon === "string" ? input.icon : undefined)) as
-    | string
-    | undefined;
-  const icon = rawIcon && !rawIcon.startsWith("http") ? rawIcon : undefined;
+  // The app's icon comes from preview.icon: a name from the app icon
+  // registry (`@vellumai/app-icons`), or an emoji the registry maps. URLs are
+  // dropped there; they would render as raw strings in UI and bundle
+  // manifests. Lenient alias: a top-level `icon` is folded in when
+  // preview.icon is absent.
+  const icon = normalizeAppIcon(preview?.icon ?? input.icon);
 
   const app = store.createApp({
     name,