@vellumai/assistant 0.8.1 → 0.8.2

package/src/runtime/routes/subagents-routes.ts

@@ -11,6 +11,7 @@ import {
   getMessages,
   type MessageRow,
 } from "../../memory/conversation-crud.js";
+import { getConversationUsageTotals } from "../../memory/llm-usage-store.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { getLogger } from "../../util/logger.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
@@ -29,6 +30,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 export interface SubagentDetailResult {
   subagentId: string;
   objective?: string;
+  usage?: { inputTokens: number; outputTokens: number; estimatedCost: number };
   events: Array<{
     type: string;
     content: string;
@@ -94,7 +96,11 @@ export function parseSubagentMessages(
         typeof block.text === "string"
       ) {
         events.push({ type: "text", content: block.text, messageId: m.id });
-      } else if (block.type === "tool_use") {
+      } else if (
+        block.type === "tool_use" ||
+        block.type === "server_tool_use" ||
+        block.type === "mcp_tool_use"
+      ) {
         const name = typeof block.name === "string" ? block.name : "unknown";
         const input = isRecord(block.input)
           ? (block.input as Record<string, unknown>)
@@ -106,7 +112,11 @@ export function parseSubagentMessages(
           toolName: name,
         });
         if (id) pendingTools.set(id, name);
-      } else if (block.type === "tool_result") {
+      } else if (
+        block.type === "tool_result" ||
+        block.type === "web_search_tool_result" ||
+        block.type === "mcp_tool_result"
+      ) {
         const toolUseId =
           typeof block.tool_use_id === "string" ? block.tool_use_id : "";
         const resultContent =
@@ -114,13 +124,18 @@ export function parseSubagentMessages(
             ? block.content
             : Array.isArray(block.content)
               ? (block.content as unknown[])
-                  .filter(
-                    (b): b is Record<string, unknown> =>
-                      isRecord(b) &&
-                      (b as Record<string, unknown>).type === "text" &&
-                      typeof (b as Record<string, unknown>).text === "string",
-                  )
-                  .map((b) => b.text as string)
+                  .filter((b): b is Record<string, unknown> => isRecord(b))
+                  .map((b) => {
+                    if (b.type === "text" && typeof b.text === "string")
+                      return b.text;
+                    if (
+                      b.type === "web_search_result" &&
+                      typeof b.title === "string"
+                    )
+                      return `${b.title}\n${typeof b.url === "string" ? b.url : ""}`;
+                    return null;
+                  })
+                  .filter((s): s is string => s != null)
                   .join("\n")
               : "";
         const isError = block.is_error === true;
@@ -142,7 +157,30 @@ function getSubagentDetail(
   subagentId: string,
   conversationId: string,
 ): SubagentDetailResult {
-  return parseSubagentMessages(subagentId, getMessages(conversationId));
+  const messages = getMessages(conversationId);
+  log.info(
+    {
+      subagentId,
+      conversationId,
+      messageCount: messages.length,
+      roles: messages.map((m) => m.role),
+    },
+    "getSubagentDetail: raw messages from DB",
+  );
+  const result = parseSubagentMessages(subagentId, messages);
+  log.info(
+    {
+      subagentId,
+      eventCount: result.events.length,
+      eventTypes: result.events.map((e) => `${e.type}:${e.toolName ?? ""}`),
+    },
+    "getSubagentDetail: parsed events",
+  );
+  const usage = getConversationUsageTotals(conversationId);
+  if (usage.inputTokens > 0 || usage.outputTokens > 0) {
+    result.usage = usage;
+  }
+  return result;
 }
 
 // ---------------------------------------------------------------------------
@@ -168,14 +206,19 @@ export const ROUTES: RouteDefinition[] = [
     responseBody: z.object({
       subagentId: z.string(),
       objective: z.string(),
+      usage: z
+        .object({
+          inputTokens: z.number(),
+          outputTokens: z.number(),
+          estimatedCost: z.number(),
+        })
+        .optional(),
       events: z.array(z.unknown()).describe("Subagent event objects"),
     }),
     handler: ({ pathParams, queryParams }) => {
       const conversationId = queryParams?.conversationId;
       if (!conversationId) {
-        throw new BadRequestError(
-          "conversationId query parameter is required",
-        );
+        throw new BadRequestError("conversationId query parameter is required");
       }
 
       const manager = getSubagentManager();
@@ -209,11 +252,7 @@ export const ROUTES: RouteDefinition[] = [
       }
 
       const manager = getSubagentManager();
-      const aborted = manager.abort(
-        pathParams!.id,
-        () => {},
-        conversationId,
-      );
+      const aborted = manager.abort(pathParams!.id, () => {}, conversationId);
 
       if (!aborted) {
         log.warn(

package/src/runtime/routes/telemetry-routes.ts

@@ -7,6 +7,7 @@
 import { z } from "zod";
 
 import { recordLifecycleEvent } from "../../memory/lifecycle-events-store.js";
+import { getUsageTelemetryReporter } from "../../telemetry/usage-telemetry-reporter.js";
 import { getLogger } from "../../util/logger.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -32,6 +33,15 @@ function handleRecordLifecycleEvent({ body }: RouteHandlerArgs) {
   return { id: event.id, event_name: event.eventName };
 }
 
+async function handleTelemetryFlush() {
+  const reporter = getUsageTelemetryReporter();
+  if (!reporter) {
+    return { flushed: false, reason: "disabled" };
+  }
+  await reporter.flush();
+  return { flushed: true };
+}
+
 export const ROUTES: RouteDefinition[] = [
   {
     operationId: "telemetry_lifecycle",
@@ -58,4 +68,21 @@ export const ROUTES: RouteDefinition[] = [
     ]),
     handler: handleRecordLifecycleEvent,
   },
+  {
+    operationId: "telemetry_flush",
+    endpoint: "telemetry/flush",
+    method: "POST",
+    summary: "Flush pending telemetry events",
+    description:
+      "Force-flush all pending usage, turn, and lifecycle telemetry events to the platform.",
+    tags: ["telemetry"],
+    responseBody: z.union([
+      z.object({ flushed: z.literal(true) }),
+      z.object({
+        flushed: z.literal(false),
+        reason: z.string(),
+      }),
+    ]),
+    handler: handleTelemetryFlush,
+  },
 ];

package/src/runtime/routes/tts-routes.ts

@@ -94,10 +94,35 @@ async function doSynthesize(
       throw new ServiceUnavailableError("TTS provider is not configured");
     }
 
-    throw new BadGatewayError("TTS synthesis failed");
+    throw new BadGatewayError(formatTtsFailureMessage(err));
   }
 }
 
+/**
+ * Build a user-facing error message for a failed TTS synthesis, embedding the
+ * upstream provider's message when available.
+ *
+ * The provider adapters surface a clean upstream message (e.g. "Free users
+ * cannot use library voices via the API…") and `synthesize-text` already
+ * prefixes those with `"TTS synthesis failed (provider: <id>): "`. We pass
+ * pre-prefixed messages through verbatim and only add the base prefix for
+ * raw provider errors, so users never see double- or triple-prefixed
+ * messages on the desktop / channels.
+ *
+ * Exported for unit testing.
+ */
+export function formatTtsFailureMessage(err: unknown): string {
+  const base = "TTS synthesis failed";
+  if (err instanceof Error && err.message && err.message.trim()) {
+    const trimmed = err.message.trim();
+    if (/^TTS synthesis failed\b/i.test(trimmed)) {
+      return trimmed;
+    }
+    return `${base}: ${trimmed}`;
+  }
+  return base;
+}
+
 // ---------------------------------------------------------------------------
 // Response headers — shared by both routes
 // ---------------------------------------------------------------------------
@@ -191,7 +216,7 @@ async function handleSynthesizeCliTts({ body }: RouteHandlerArgs) {
       throw new ServiceUnavailableError("TTS provider is not configured");
     }
 
-    throw new BadGatewayError("TTS synthesis failed");
+    throw new BadGatewayError(formatTtsFailureMessage(err));
   }
 }
 

package/src/runtime/routes/workspace-routes.test.ts

@@ -9,6 +9,10 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeAll, describe, expect, test } from "bun:test";
 
+import { SYNC_TAGS } from "../../daemon/message-types/sync.js";
+import type { AssistantEvent } from "../assistant-event.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
+
 // ---------------------------------------------------------------------------
 // Create a temp workspace directory for isolation
 // ---------------------------------------------------------------------------
@@ -59,6 +63,15 @@ function getRoute(operationId: string): RouteDefinition {
   return route;
 }
 
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for workspace route event");
+}
+
 // ===========================================================================
 // resolveWorkspacePath
 // ===========================================================================
@@ -492,6 +505,36 @@ describe("POST /v1/workspace/write", () => {
       handler({ body: { path: "subdir", content: "should fail" } }),
     ).toThrow(ConflictError);
   });
+
+  test("publishes sounds sync events when writing sounds config", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      handler({
+        body: {
+          path: "data/sounds/config.json",
+          content: "{}",
+        },
+      });
+      await waitFor(() => received.length === 2);
+      expect(received.map((event) => event.message.type)).toEqual([
+        "sounds_config_updated",
+        "sync_changed",
+      ]);
+      expect(received[1]!.message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantSounds],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
 });
 
 // ===========================================================================

package/src/runtime/routes/workspace-routes.ts

@@ -18,6 +18,7 @@ import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 
 import { getWorkspaceDir } from "../../util/platform.js";
+import { publishSoundsConfigUpdated } from "../sync/resource-sync-events.js";
 import {
   BadRequestError,
   ConflictError,
@@ -41,6 +42,29 @@ interface TreeEntry {
   modifiedAt: string;
 }
 
+const SOUNDS_WORKSPACE_PATH = "data/sounds";
+
+function normaliseWorkspacePathForSync(path: string): string {
+  return path
+    .split(/[\\/]+/)
+    .filter((part) => part.length > 0)
+    .join("/");
+}
+
+function isSoundsWorkspacePath(path: string): boolean {
+  const normalized = normaliseWorkspacePathForSync(path);
+  return (
+    normalized === SOUNDS_WORKSPACE_PATH ||
+    normalized.startsWith(`${SOUNDS_WORKSPACE_PATH}/`)
+  );
+}
+
+function publishSoundsConfigUpdatedForPaths(paths: string[]): void {
+  if (paths.some(isSoundsWorkspacePath)) {
+    publishSoundsConfigUpdated();
+  }
+}
+
 // ---------------------------------------------------------------------------
 // GET /v1/workspace/tree — list directory contents
 // ---------------------------------------------------------------------------
@@ -268,6 +292,7 @@ function handleWorkspaceWrite({ body }: RouteHandlerArgs) {
 
   mkdirSync(dirname(resolved), { recursive: true });
   writeFileSync(resolved, buffer);
+  publishSoundsConfigUpdatedForPaths([path]);
 
   return { path, size: buffer.byteLength };
 }
@@ -295,6 +320,7 @@ function handleWorkspaceMkdir({ body }: RouteHandlerArgs) {
   }
 
   mkdirSync(resolved, { recursive: true });
+  publishSoundsConfigUpdatedForPaths([path]);
   return { path };
 }
 
@@ -334,6 +360,7 @@ function handleWorkspaceRename({ body }: RouteHandlerArgs) {
 
   mkdirSync(dirname(resolvedNew), { recursive: true });
   renameSync(resolvedOld, resolvedNew);
+  publishSoundsConfigUpdatedForPaths([oldPath, newPath]);
   return { oldPath, newPath };
 }
 
@@ -361,6 +388,7 @@ function handleWorkspaceDelete({ body }: RouteHandlerArgs) {
   }
 
   rmSync(resolved, { recursive: true, force: true });
+  publishSoundsConfigUpdatedForPaths([path]);
   return { success: true };
 }
 

package/src/runtime/services/conversation-serializer.ts

@@ -8,6 +8,7 @@
  */
 
 import { parseChannelId } from "../../channels/types.js";
+import { getConfig } from "../../config/loader.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
   type AttentionState,
@@ -22,6 +23,7 @@ import {
 } from "../../memory/conversation-crud.js";
 import type { ExternalConversationBinding } from "../../memory/external-conversation-store.js";
 import { getBindingsForConversations } from "../../memory/external-conversation-store.js";
+import { buildSlackMessageDeepLinks } from "../../messaging/providers/slack/deep-link.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -88,6 +90,42 @@ function buildForkParent(
   };
 }
 
+function buildChannelBinding(binding: ExternalConversationBinding) {
+  const slackConfig =
+    binding.sourceChannel === "slack" && binding.externalThreadId
+      ? getConfig().slack
+      : undefined;
+  const slackThreadLink =
+    slackConfig && binding.externalThreadId
+      ? buildSlackMessageDeepLinks({
+          teamId: slackConfig.teamId,
+          teamUrl: slackConfig.teamUrl,
+          channelId: binding.externalChatId,
+          messageTs: binding.externalThreadId,
+        })
+      : undefined;
+  const slackThread =
+    binding.sourceChannel === "slack" && binding.externalThreadId
+      ? {
+          channelId: binding.externalChatId,
+          threadTs: binding.externalThreadId,
+          ...(slackThreadLink ? { link: slackThreadLink } : {}),
+        }
+      : undefined;
+
+  return {
+    sourceChannel: binding.sourceChannel,
+    externalChatId: binding.externalChatId,
+    ...(binding.externalThreadId
+      ? { externalThreadId: binding.externalThreadId }
+      : {}),
+    externalUserId: binding.externalUserId,
+    displayName: binding.displayName,
+    username: binding.username,
+    ...(slackThread ? { slackThread } : {}),
+  };
+}
+
 export function serializeConversationSummary(params: {
   conversation: ConversationRow;
   binding?: ExternalConversationBinding | null;
@@ -118,13 +156,7 @@ export function serializeConversationSummary(params: {
       : {}),
     ...(binding
       ? {
-          channelBinding: {
-            sourceChannel: binding.sourceChannel,
-            externalChatId: binding.externalChatId,
-            externalUserId: binding.externalUserId,
-            displayName: binding.displayName,
-            username: binding.username,
-          },
+          channelBinding: buildChannelBinding(binding),
         }
       : {}),
     ...(originChannel ? { conversationOriginChannel: originChannel } : {}),

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

@@ -1,5 +1,10 @@
 import type { IdentityFields } from "../../daemon/handlers/identity.js";
-import { SYNC_TAGS } from "../../daemon/message-types/sync.js";
+import type { ConversationListInvalidatedReason } from "../../daemon/message-types/conversations.js";
+import {
+  conversationMessagesSyncTag,
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../../daemon/message-types/sync.js";
 import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
@@ -23,3 +28,90 @@ export function publishIdentityChanged(fields: IdentityFields): void {
   });
   void publishSyncInvalidation([SYNC_TAGS.assistantIdentity]);
 }
+
+export function publishConfigChanged(): void {
+  broadcastMessage({ type: "config_changed" });
+  void publishSyncInvalidation([SYNC_TAGS.assistantConfig]);
+}
+
+export function publishSoundsConfigUpdated(): void {
+  broadcastMessage({ type: "sounds_config_updated" });
+  void publishSyncInvalidation([SYNC_TAGS.assistantSounds]);
+}
+
+export function publishSchedulesChanged(): void {
+  void publishSyncInvalidation([SYNC_TAGS.assistantSchedules]);
+}
+
+export function publishConversationListChanged(
+  reason: ConversationListInvalidatedReason,
+): void {
+  broadcastMessage({
+    type: "conversation_list_invalidated",
+    reason,
+  });
+  void publishSyncInvalidation([SYNC_TAGS.conversationsList]);
+}
+
+export function publishConversationMessagesChanged(
+  conversationId: string,
+): void {
+  void publishSyncInvalidation([conversationMessagesSyncTag(conversationId)]);
+}
+
+export function publishConversationListAndMetadataChanged(
+  reason: ConversationListInvalidatedReason,
+  conversationIds: string | string[],
+): void {
+  const ids = Array.isArray(conversationIds)
+    ? conversationIds
+    : [conversationIds];
+  broadcastMessage({
+    type: "conversation_list_invalidated",
+    reason,
+  });
+  void publishSyncInvalidation([
+    SYNC_TAGS.conversationsList,
+    ...ids.map((conversationId) => conversationMetadataSyncTag(conversationId)),
+  ]);
+}
+
+export function publishConversationTitleChanged(
+  conversationId: string,
+  title: string,
+): void {
+  broadcastMessage(
+    {
+      type: "conversation_title_updated",
+      conversationId,
+      title,
+    },
+    conversationId,
+  );
+  void publishSyncInvalidation([
+    SYNC_TAGS.conversationsList,
+    conversationMetadataSyncTag(conversationId),
+  ]);
+}
+
+export function publishConversationInferenceProfileChanged(params: {
+  conversationId: string;
+  profile: string | null;
+  sessionId?: string | null;
+  expiresAt?: number | null;
+}): void {
+  broadcastMessage(
+    {
+      type: "conversation_inference_profile_updated",
+      conversationId: params.conversationId,
+      profile: params.profile,
+      sessionId: params.sessionId,
+      expiresAt: params.expiresAt,
+    },
+    params.conversationId,
+  );
+  void publishSyncInvalidation([
+    SYNC_TAGS.conversationsList,
+    conversationMetadataSyncTag(params.conversationId),
+  ]);
+}

package/src/schedule/schedule-store.ts

@@ -5,6 +5,7 @@ import { v4 as uuid } from "uuid";
 import { getDb } from "../memory/db-connection.js";
 import { rawChanges } from "../memory/raw-query.js";
 import { scheduleJobs, scheduleRuns } from "../memory/schema.js";
+import { publishSchedulesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import {
   computeNextRunAt as computeNextRunAtEngine,
@@ -14,6 +15,10 @@ import type { ScheduleSyntax } from "./recurrence-types.js";
 
 const logger = getLogger("schedule-store");
 
+function notifySchedulesChanged(): void {
+  publishSchedulesChanged();
+}
+
 export type ScheduleMode = "notify" | "execute" | "script" | "wake";
 export type RoutingIntent = "single_channel" | "multi_channel" | "all_channels";
 export type ScheduleStatus = "active" | "firing" | "fired" | "cancelled";
@@ -160,6 +165,7 @@ export function createSchedule(params: {
   };
 
   db.insert(scheduleJobs).values(row).run();
+  notifySchedulesChanged();
   return parseJobRow(row);
 }
 
@@ -328,6 +334,7 @@ export function updateSchedule(
   }
 
   db.update(scheduleJobs).set(set).where(eq(scheduleJobs.id, id)).run();
+  notifySchedulesChanged();
 
   return getSchedule(id);
 }
@@ -335,7 +342,9 @@ export function updateSchedule(
 export function deleteSchedule(id: string): boolean {
   const db = getDb();
   db.delete(scheduleJobs).where(eq(scheduleJobs.id, id)).run();
-  return rawChanges() > 0;
+  const deleted = rawChanges() > 0;
+  if (deleted) notifySchedulesChanged();
+  return deleted;
 }
 
 /**
@@ -466,6 +475,7 @@ export function claimDueSchedules(now: number): ScheduleJob[] {
     );
   }
 
+  if (claimed.length > 0) notifySchedulesChanged();
   return claimed;
 }
 
@@ -484,6 +494,7 @@ export function completeOneShot(id: string): void {
     })
     .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "firing")))
     .run();
+  if (rawChanges() > 0) notifySchedulesChanged();
 }
 
 /**
@@ -500,6 +511,7 @@ export function failOneShot(id: string): void {
     })
     .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "firing")))
     .run();
+  if (rawChanges() > 0) notifySchedulesChanged();
 }
 
 /**
@@ -510,6 +522,7 @@ export function failOneShot(id: string): void {
 export function retryOneShot(id: string): void {
   const db = getDb();
   const now = Date.now();
+  let changed = false;
   db.update(scheduleJobs)
     .set({
       status: "active",
@@ -518,6 +531,8 @@ export function retryOneShot(id: string): void {
     })
     .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "firing")))
     .run();
+  changed = rawChanges() > 0;
+  if (changed) notifySchedulesChanged();
 }
 
 /**
@@ -537,6 +552,7 @@ export function failOneShotPermanently(id: string): void {
     })
     .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "firing")))
     .run();
+  if (rawChanges() > 0) notifySchedulesChanged();
 }
 
 /**
@@ -554,7 +570,9 @@ export function cancelSchedule(id: string): boolean {
     })
     .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "active")))
     .run();
-  return rawChanges() > 0;
+  const cancelled = rawChanges() > 0;
+  if (cancelled) notifySchedulesChanged();
+  return cancelled;
 }
 
 export function createScheduleRun(
@@ -625,12 +643,14 @@ export function completeScheduleRun(
         })
         .where(eq(scheduleJobs.id, run.jobId))
         .run();
+      if (rawChanges() > 0) notifySchedulesChanged();
     }
   } else {
     db.update(scheduleJobs)
       .set({ lastStatus: "ok", retryCount: 0, updatedAt: now })
       .where(eq(scheduleJobs.id, run.jobId))
       .run();
+    if (rawChanges() > 0) notifySchedulesChanged();
   }
 }
 
@@ -839,16 +859,20 @@ export function describeCronExpression(expr: string | null): string {
 export function scheduleRetry(id: string, nextRetryAt: number): void {
   const db = getDb();
   const now = Date.now();
+  let changed = false;
   db.update(scheduleJobs)
     .set({ nextRunAt: nextRetryAt, updatedAt: now })
     .where(eq(scheduleJobs.id, id))
     .run();
+  changed = rawChanges() > 0;
   // Revert one-shot status from "firing" to "active" so the scheduler
   // will claim it again when nextRetryAt arrives. No-op for recurring.
   db.update(scheduleJobs)
     .set({ status: "active", updatedAt: now })
     .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "firing")))
     .run();
+  changed = rawChanges() > 0 || changed;
+  if (changed) notifySchedulesChanged();
 }
 
 /**
@@ -860,6 +884,7 @@ export function resetRetryCount(id: string): void {
     .set({ retryCount: 0, updatedAt: Date.now() })
     .where(eq(scheduleJobs.id, id))
     .run();
+  if (rawChanges() > 0) notifySchedulesChanged();
 }
 
 /**

package/src/schedule/scheduler.ts

@@ -549,7 +549,15 @@ export async function runScheduleOnce(
           });
         },
       });
-      conversationId = result.conversationId;
+      // Bootstrap-failure path returns `{ ok: false, conversationId: "" }`.
+      // Substitute a sentinel only for failures so the schedule-run DB row
+      // carries a recognizable marker. Successful skips (e.g.
+      // `pre_first_user_message`) also return `conversationId: ""` but with
+      // `ok: true` — keep the empty ID to preserve their skip contract.
+      conversationId =
+        !result.ok && result.conversationId === ""
+          ? `bootstrap-error:${job.id}`
+          : result.conversationId;
       ok = result.ok;
       errorMsg = result.error?.message;
     }