@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/runtime/routes/trust-rules-routes.ts

@@ -43,9 +43,30 @@ const TrustRulesListParams = z
   })
   .strict();
 
+const TrustRuleSchema = z.object({
+  id: z.string(),
+  tool: z.string(),
+  pattern: z.string(),
+  risk: z.enum(["low", "medium", "high"]),
+  description: z.string(),
+  origin: z.enum(["default", "user_defined"]),
+  userModified: z.boolean(),
+  deleted: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const TrustRulesListResponseSchema = z.object({
+  rules: z.array(TrustRuleSchema),
+});
+type TrustRulesListResponse = z.infer<typeof TrustRulesListResponseSchema>;
+
 // ── Handlers ────────────────────────────────────────────────────────────
 
-async function handleList({ queryParams = {}, body = {} }: RouteHandlerArgs) {
+async function handleList({
+  queryParams = {},
+  body = {},
+}: RouteHandlerArgs): Promise<TrustRulesListResponse> {
   // HTTP GET delivers filters via queryParams; CLI IPC puts them in body.
   const source = Object.keys(queryParams).length > 0 ? queryParams : body;
   const p = TrustRulesListParams.parse(source);
@@ -54,7 +75,9 @@ async function handleList({ queryParams = {}, body = {} }: RouteHandlerArgs) {
   if (p.origin) qs.set("origin", p.origin);
   if (p.include_all) qs.set("include_all", "true");
   const query = qs.toString();
-  return gatewayFetch(`/v1/trust-rules${query ? `?${query}` : ""}`);
+  return gatewayFetch(
+    `/v1/trust-rules${query ? `?${query}` : ""}`,
+  ) as Promise<TrustRulesListResponse>;
 }
 
 // ── Route definitions ───────────────────────────────────────────────────
@@ -73,6 +96,7 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "List trust rules, optionally filtered by tool, origin, or include_all.",
     tags: ["trust-rules"],
+    responseBody: TrustRulesListResponseSchema,
     queryParams: [
       { name: "tool", description: "Filter by tool name" },
       { name: "origin", description: "Filter by origin" },

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

@@ -15,6 +15,7 @@ import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { getMessageContent } from "../../daemon/handlers/conversation-history.js";
+import { listCatalogProvidersForDisplay } from "../../tts/provider-catalog.js";
 import {
   synthesizeText,
   TtsSynthesisError,
@@ -136,6 +137,10 @@ const ttsResponseHeaders = () => ({
 // Handlers
 // ---------------------------------------------------------------------------
 
+function handleListTtsProviders() {
+  return { providers: listCatalogProvidersForDisplay() };
+}
+
 async function handleMessageTts({ pathParams, queryParams }: RouteHandlerArgs) {
   const config = getConfig();
 
@@ -226,6 +231,36 @@ async function handleSynthesizeCliTts({ body }: RouteHandlerArgs) {
 // ---------------------------------------------------------------------------
 
 export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "tts_providers",
+    endpoint: "tts/providers",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List TTS providers",
+    description:
+      "Return the catalog of available TTS providers with client-facing metadata.",
+    tags: ["tts"],
+    responseBody: z.object({
+      providers: z.array(
+        z.object({
+          id: z.string(),
+          displayName: z.string(),
+          subtitle: z.string(),
+          supportsVoiceSelection: z.boolean(),
+          apiKeyPlaceholder: z.string(),
+          credentialsGuide: z.object({
+            description: z.string(),
+            url: z.string(),
+            linkLabel: z.string(),
+          }),
+        }),
+      ),
+    }),
+    handler: handleListTtsProviders,
+  },
   {
     operationId: "messages_tts",
     endpoint: "messages/:messageId/tts",

package/src/runtime/routes/types.ts

@@ -31,6 +31,70 @@ export interface RoutePathParam {
   description?: string;
 }
 
+/**
+ * Content types a route can declare a request body for. `application/json`
+ * is the implicit default when `requestBody` is a bare Zod schema, so it is
+ * only spelled out here for the explicit `{ contentType, schema }` form.
+ */
+export type RouteRequestContentType =
+  | "application/json"
+  | "application/octet-stream"
+  | "multipart/form-data";
+
+/**
+ * A route's request body. Either:
+ * - a bare Zod schema, which is advertised as `application/json`, or
+ * - an explicit `{ contentType, schema }` pair for non-JSON bodies (e.g. a
+ *   raw `application/octet-stream` upload). `schema` may be a Zod schema or a
+ *   plain JSON Schema fragment (e.g. `{ type: "string", format: "binary" }`).
+ *
+ * The OpenAPI generator turns this into the operation's `requestBody`, so the
+ * generated client SDK describes a real body type instead of `never`. The HTTP
+ * adapter parses the body off the request `Content-Type` header, so this field
+ * is a codegen signal only and does not change runtime request handling.
+ */
+export type RouteRequestBody =
+  | z.ZodType
+  | {
+      contentType: RouteRequestContentType;
+      schema: z.ZodType | Record<string, unknown>;
+    };
+
+/**
+ * Content types a route can declare a success response body for.
+ * `application/json` is the implicit default when `responseBody` is a bare
+ * Zod schema, so it is only spelled out here for the explicit
+ * `{ contentType, schema }` form (e.g. a binary `application/octet-stream`
+ * download or an `application/gzip` archive).
+ */
+export type RouteResponseContentType =
+  | "application/json"
+  | "application/octet-stream"
+  | "application/gzip"
+  | "application/pdf"
+  | "application/zip";
+
+/**
+ * A route's success response body. Either:
+ * - a bare Zod schema, which is advertised as `application/json`, or
+ * - an explicit `{ contentType, schema }` pair for non-JSON responses (e.g. a
+ *   binary download). `schema` may be a Zod schema or a plain JSON Schema
+ *   fragment (e.g. `{ type: "string", format: "binary" }`, which is not
+ *   expressible as a bare Zod type).
+ *
+ * The OpenAPI generator turns this into the operation's success response, so
+ * the generated client SDK describes a real response type (e.g. `Blob`)
+ * instead of `unknown`. Handlers serialize their own bytes via `RouteResponse`,
+ * so this field is a codegen signal only and does not change runtime
+ * response handling.
+ */
+export type RouteResponseBody =
+  | z.ZodType
+  | {
+      contentType: RouteResponseContentType;
+      schema: z.ZodType | Record<string, unknown>;
+    };
+
 export interface RouteHandlerArgs {
   pathParams?: Record<string, string>;
   queryParams?: Record<string, string>;
@@ -102,8 +166,8 @@ export interface RouteDefinition {
   tags?: string[];
   pathParams?: RoutePathParam[];
   queryParams?: RouteQueryParam[];
-  requestBody?: z.ZodType;
-  responseBody?: z.ZodType;
+  requestBody?: RouteRequestBody;
+  responseBody?: RouteResponseBody;
   /**
    * HTTP status code for the success response. Defaults to "200".
    * Use "201" for resource creation, "204" for no-content responses.
@@ -145,12 +209,6 @@ export interface RouteDefinition {
    * RouteError subclasses rather than explicit Response objects.
    */
   additionalResponses?: Record<string, { description: string }>;
-  /**
-   * When true, the route expects a raw binary body (e.g. file uploads).
-   * The HTTP adapter already reads `rawBody` for non-JSON content types;
-   * this flag is a declarative signal for documentation and tooling.
-   */
-  rawBody?: boolean;
   /**
    * Per-route request-log control. Routes that opt in can suppress the
    * per-request INFO log line after a confirmed run of successful

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

@@ -1,10 +1,10 @@
 /**
  * Route handlers for usage and cost summary endpoints.
  *
- * GET /v1/usage/totals?from=&to=              — aggregate totals for a time range
- * GET /v1/usage/daily?from=&to=               — per-day buckets for a time range
- * GET /v1/usage/breakdown?from=&to=&groupBy=  — grouped breakdown
- * GET /v1/usage/series?from=&to=&granularity=&groupBy= — grouped time-series buckets
+ * GET /v1/usage/totals?from=&to=&scheduleId=  — aggregate totals for a time range
+ * GET /v1/usage/daily?from=&to=&scheduleId=   — per-day buckets for a time range
+ * GET /v1/usage/breakdown?from=&to=&groupBy=&scheduleId=  — grouped breakdown
+ * GET /v1/usage/series?from=&to=&granularity=&groupBy=&scheduleId= — grouped time-series buckets
  */
 
 import { z } from "zod";
@@ -18,10 +18,12 @@ import {
   type GroupByDimension,
   USAGE_GROUP_BY_DIMENSIONS,
   USAGE_SERIES_GROUP_BY_DIMENSIONS,
+  type UsageAggregationFilter,
   type UsageGranularity,
 } from "../../memory/llm-usage-store.js";
 import { validateTimezone } from "../../memory/usage-buckets.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import { parseEpochMillisRange } from "./epoch-millis-range.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -29,6 +31,8 @@ const VALID_GROUP_BY = new Set<string>(USAGE_GROUP_BY_DIMENSIONS);
 const VALID_SERIES_GROUP_BY = new Set<string>(USAGE_SERIES_GROUP_BY_DIMENSIONS);
 const GROUP_BY_DESCRIPTION = USAGE_GROUP_BY_DIMENSIONS.join(", ");
 const SERIES_GROUP_BY_DESCRIPTION = USAGE_SERIES_GROUP_BY_DIMENSIONS.join(", ");
+const SCHEDULE_ID_FILTER_DESCRIPTION =
+  "Optional schedule id. When set, usage is attributed by cron run windows for that schedule.";
 
 const usageTotalsSchema = z.object({
   totalInputTokens: z.number(),
@@ -86,43 +90,23 @@ function resolveTimezone(queryParams: Record<string, string>): string {
   return tz;
 }
 
-function parseTimeRange(queryParams: Record<string, string>): {
-  from: number;
-  to: number;
-} {
-  const fromRaw = queryParams.from;
-  const toRaw = queryParams.to;
-
-  if (!fromRaw || !toRaw) {
-    throw new BadRequestError(
-      'Missing required query parameters: "from" and "to" (epoch milliseconds)',
-    );
-  }
-
-  const from = Number(fromRaw);
-  const to = Number(toRaw);
-
-  if (!Number.isFinite(from) || !Number.isFinite(to)) {
-    throw new BadRequestError(
-      '"from" and "to" must be valid numbers (epoch milliseconds)',
-    );
-  }
-
-  if (from > to) {
-    throw new BadRequestError('"from" must be less than or equal to "to"');
-  }
-
-  return { from, to };
+function parseUsageAggregationFilter(
+  queryParams: Record<string, string>,
+): UsageAggregationFilter {
+  const scheduleId = queryParams.scheduleId?.trim();
+  return scheduleId ? { scheduleId } : {};
 }
 
 function handleUsageTotals({ queryParams }: RouteHandlerArgs) {
-  const range = parseTimeRange(queryParams ?? {});
-  return getUsageTotals(range);
+  const qp = queryParams ?? {};
+  const range = parseEpochMillisRange(qp);
+  const filter = parseUsageAggregationFilter(qp);
+  return getUsageTotals(range, filter);
 }
 
 function handleUsageDaily({ queryParams }: RouteHandlerArgs) {
   const qp = queryParams ?? {};
-  const range = parseTimeRange(qp);
+  const range = parseEpochMillisRange(qp);
   const granularity = qp.granularity ?? "daily";
   if (granularity !== "daily" && granularity !== "hourly") {
     throw new BadRequestError(
@@ -130,16 +114,17 @@ function handleUsageDaily({ queryParams }: RouteHandlerArgs) {
     );
   }
   const tz = resolveTimezone(qp);
+  const filter = parseUsageAggregationFilter(qp);
   const buckets =
     granularity === "hourly"
-      ? getUsageHourBuckets(range, tz, { fillEmpty: true })
-      : getUsageDayBuckets(range, tz, { fillEmpty: true });
+      ? getUsageHourBuckets(range, tz, { fillEmpty: true }, filter)
+      : getUsageDayBuckets(range, tz, { fillEmpty: true }, filter);
   return { buckets };
 }
 
 function handleUsageBreakdown({ queryParams }: RouteHandlerArgs) {
   const qp = queryParams ?? {};
-  const range = parseTimeRange(qp);
+  const range = parseEpochMillisRange(qp);
 
   const groupBy = qp.groupBy;
   if (!groupBy) {
@@ -153,13 +138,18 @@ function handleUsageBreakdown({ queryParams }: RouteHandlerArgs) {
     );
   }
 
-  const breakdown = getUsageGroupBreakdown(range, groupBy as GroupByDimension);
+  const filter = parseUsageAggregationFilter(qp);
+  const breakdown = getUsageGroupBreakdown(
+    range,
+    groupBy as GroupByDimension,
+    filter,
+  );
   return { breakdown };
 }
 
 function handleUsageSeries({ queryParams }: RouteHandlerArgs) {
   const qp = queryParams ?? {};
-  const range = parseTimeRange(qp);
+  const range = parseEpochMillisRange(qp);
   const granularity = qp.granularity ?? "daily";
   if (granularity !== "daily" && granularity !== "hourly") {
     throw new BadRequestError(
@@ -180,12 +170,14 @@ function handleUsageSeries({ queryParams }: RouteHandlerArgs) {
   }
 
   const tz = resolveTimezone(qp);
+  const filter = parseUsageAggregationFilter(qp);
   const buckets = getUsageGroupedSeries(
     range,
     groupBy as Exclude<GroupByDimension, "conversation">,
     granularity as UsageGranularity,
     tz,
     { fillEmpty: true },
+    filter,
   );
   return { buckets };
 }
@@ -213,6 +205,10 @@ export const ROUTES: RouteDefinition[] = [
         type: "integer",
         description: "End epoch millis (required)",
       },
+      {
+        name: "scheduleId",
+        description: SCHEDULE_ID_FILTER_DESCRIPTION,
+      },
     ],
     responseBody: usageTotalsSchema,
     handler: handleUsageTotals,
@@ -249,6 +245,10 @@ export const ROUTES: RouteDefinition[] = [
         description:
           'IANA timezone identifier (e.g. "America/Los_Angeles"). Bucket boundaries and display labels are computed in this timezone. Defaults to "UTC" for backwards compatibility.',
       },
+      {
+        name: "scheduleId",
+        description: SCHEDULE_ID_FILTER_DESCRIPTION,
+      },
     ],
     responseBody: z.object({
       buckets: z.array(usageDayBucketSchema).describe("Usage bucket objects"),
@@ -282,6 +282,10 @@ export const ROUTES: RouteDefinition[] = [
         name: "groupBy",
         description: `Group by: ${GROUP_BY_DESCRIPTION} (required)`,
       },
+      {
+        name: "scheduleId",
+        description: SCHEDULE_ID_FILTER_DESCRIPTION,
+      },
     ],
     responseBody: z.object({
       breakdown: z
@@ -327,6 +331,10 @@ export const ROUTES: RouteDefinition[] = [
         description:
           'IANA timezone identifier (e.g. "America/Los_Angeles"). Bucket boundaries and display labels are computed in this timezone. Defaults to "UTC".',
       },
+      {
+        name: "scheduleId",
+        description: SCHEDULE_ID_FILTER_DESCRIPTION,
+      },
     ],
     responseBody: z.object({
       buckets: z

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

@@ -10,6 +10,8 @@
  *     with the platform for this assistant.
  */
 
+import { z } from "zod";
+
 import { getIsPlatform } from "../../config/env-registry.js";
 import { getConfig } from "../../config/loader.js";
 import {
@@ -25,6 +27,38 @@ import {
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const WebhooksRegisterRequestSchema = z.object({
+  type: z.string(),
+  path: z.string().optional(),
+  source: z.string().optional(),
+});
+
+const WebhooksRegisterResponseSchema = z.object({
+  callbackUrl: z.string(),
+  type: z.string(),
+  path: z.string(),
+  mode: z.enum(["platform", "self-hosted"]),
+});
+type WebhooksRegisterResponse = z.infer<typeof WebhooksRegisterResponseSchema>;
+
+const WebhookCallbackRouteSchema = z.object({
+  id: z.string(),
+  assistant_id: z.string(),
+  type: z.string(),
+  callback_path: z.string(),
+  callback_url: z.string(),
+  source_identifier: z.string().nullable(),
+});
+
+const WebhooksListResponseSchema = z.object({
+  routes: z.array(WebhookCallbackRouteSchema),
+});
+type WebhooksListResponse = z.infer<typeof WebhooksListResponseSchema>;
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -49,7 +83,7 @@ function deriveWebhookPath(type: string): string {
 
 async function handleWebhooksRegister(
   args: RouteHandlerArgs,
-): Promise<unknown> {
+): Promise<WebhooksRegisterResponse> {
   const { type, path: pathOverride, source } = args.body ?? {};
 
   if (!type || typeof type !== "string") {
@@ -93,7 +127,9 @@ async function handleWebhooksRegister(
   };
 }
 
-async function handleWebhooksList(_args: RouteHandlerArgs): Promise<unknown> {
+async function handleWebhooksList(
+  _args: RouteHandlerArgs,
+): Promise<WebhooksListResponse> {
   const context = await resolvePlatformCallbackRegistrationContext();
 
   if (!context.platformBaseUrl || !context.authHeader) {
@@ -155,6 +191,8 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Resolves a stable callback URL for a webhook type. On platform-managed assistants, registers the route with the platform gateway. On self-hosted assistants, uses the configured ingress.publicBaseUrl.",
     tags: ["webhooks"],
+    requestBody: WebhooksRegisterRequestSchema,
+    responseBody: WebhooksRegisterResponseSchema,
     handler: handleWebhooksRegister,
   },
   {
@@ -169,6 +207,7 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Lists all webhook callback routes registered with the platform for this assistant.",
     tags: ["webhooks"],
+    responseBody: WebhooksListResponseSchema,
     handler: handleWebhooksList,
   },
 ];

package/src/runtime/routes/work-items-routes.ts

@@ -8,10 +8,8 @@
 import { z } from "zod";
 
 import type { Conversation } from "../../daemon/conversation.js";
-import {
-  findConversation,
-  getOrCreateConversation,
-} from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
+import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
 import { getMessages } from "../../memory/conversation-crud.js";
 import { check, classifyRisk } from "../../permissions/checker.js";

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

@@ -663,6 +663,10 @@ export const ROUTES: RouteDefinition[] = [
         description: "Allow hidden files (true/false)",
       },
     ],
+    responseBody: {
+      contentType: "application/octet-stream",
+      schema: { type: "string", format: "binary" },
+    },
     responseStatus: ({ headers }) => (headers?.["range"] ? "206" : "200"),
     additionalResponses: {
       "416": { description: "Range Not Satisfiable" },

package/src/runtime/services/__tests__/analyze-conversation.test.ts

@@ -61,6 +61,12 @@ function makeConversation() {
     setSubagentAllowedTools: mock(() => {}),
     updateClient: mock(() => {}),
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController: null as AbortController | null,
     currentRequestId: null as string | null,
     loadedHistoryTrustClass: undefined as string | undefined,

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

@@ -198,7 +198,7 @@ export async function analyzeConversation(
   // `currentRequestId` and let two loops mutate the same Conversation
   // state. Skip this run instead — the next upstream trigger will
   // re-enqueue once the in-flight loop finishes.
-  if (opts.trigger === "auto" && analysisConversation.processing) {
+  if (opts.trigger === "auto" && analysisConversation.isProcessing()) {
     log.info(
       {
         sourceConversationId: resolvedId,
@@ -247,7 +247,7 @@ export async function analyzeConversation(
   analysisConversation.updateClient(broadcastMessage, !hasLiveSubscriber);
 
   // k. Set up processing state (required by runAgentLoop guard)
-  analysisConversation.processing = true;
+  analysisConversation.setProcessing(true);
   analysisConversation.abortController = new AbortController();
   analysisConversation.currentRequestId = crypto.randomUUID();
 

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

@@ -9,7 +9,7 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
   type AttentionState,

package/src/schedule/schedule-store.ts

@@ -49,6 +49,7 @@ export interface ScheduleJob {
   retryBackoffMs: number;
   /** Script-mode execution timeout override (ms); null = use the default. */
   timeoutMs: number | null;
+  createdFromConversationId: string | null;
   createdBy: string;
   mode: ScheduleMode;
   routingIntent: RoutingIntent;
@@ -102,6 +103,7 @@ export function createSchedule(params: {
   maxRetries?: number;
   retryBackoffMs?: number;
   timeoutMs?: number | null;
+  createdFromConversationId?: string | null;
 }): ScheduleJob {
   const expression = params.expression ?? params.cronExpression ?? null;
   const isOneShot = expression == null;
@@ -138,6 +140,7 @@ export function createSchedule(params: {
   const maxRetries = params.maxRetries ?? 3;
   const retryBackoffMs = params.retryBackoffMs ?? 60000;
   const timeoutMs = params.timeoutMs ?? null;
+  const createdFromConversationId = params.createdFromConversationId ?? null;
 
   let nextRunAt: number;
   if (isOneShot) {
@@ -165,6 +168,7 @@ export function createSchedule(params: {
     maxRetries,
     retryBackoffMs,
     timeoutMs,
+    createdFromConversationId,
     createdBy: params.createdBy ?? "agent",
     mode,
     routingIntent,
@@ -264,6 +268,7 @@ export function updateSchedule(
     maxRetries?: number;
     retryBackoffMs?: number;
     timeoutMs?: number | null;
+    createdFromConversationId?: string | null;
   },
 ): ScheduleJob | null {
   const db = getDb();
@@ -329,6 +334,8 @@ export function updateSchedule(
   if (updates.retryBackoffMs !== undefined)
     set.retryBackoffMs = updates.retryBackoffMs;
   if (updates.timeoutMs !== undefined) set.timeoutMs = updates.timeoutMs;
+  if (updates.createdFromConversationId !== undefined)
+    set.createdFromConversationId = updates.createdFromConversationId;
 
   // Recompute nextRunAt if schedule timing may have changed (only for recurring)
   if (
@@ -591,7 +598,7 @@ export function cancelSchedule(id: string): boolean {
 
 export function createScheduleRun(
   jobId: string,
-  conversationId: string,
+  conversationId: string | null,
 ): string {
   const db = getDb();
   const id = uuid();
@@ -613,6 +620,17 @@ export function createScheduleRun(
   return id;
 }
 
+export function setScheduleRunConversationId(
+  runId: string,
+  conversationId: string,
+): void {
+  const db = getDb();
+  db.update(scheduleRuns)
+    .set({ conversationId })
+    .where(eq(scheduleRuns.id, runId))
+    .run();
+}
+
 export function completeScheduleRun(
   runId: string,
   result: { status: "ok" | "error"; output?: string; error?: string },
@@ -977,6 +995,7 @@ function parseJobRow(row: typeof scheduleJobs.$inferSelect): ScheduleJob {
     maxRetries: row.maxRetries ?? 3,
     retryBackoffMs: row.retryBackoffMs ?? 60000,
     timeoutMs: row.timeoutMs ?? null,
+    createdFromConversationId: row.createdFromConversationId ?? null,
     createdBy: row.createdBy,
     mode: (row.mode ?? "execute") as ScheduleMode,
     routingIntent: (row.routingIntent ?? "all_channels") as RoutingIntent,