@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/__tests__/public-ingress-urls.test.ts

@@ -12,6 +12,7 @@ import {
   getTwilioMediaStreamUrl,
   getTwilioStatusCallbackUrl,
   getTwilioVoiceWebhookUrl,
+  tryGetPublicBaseUrl,
 } from "../inbound/public-ingress-urls.js";
 
 // ---------------------------------------------------------------------------
@@ -163,6 +164,41 @@ describe("getPublicBaseUrl", () => {
   });
 });
 
+describe("tryGetPublicBaseUrl", () => {
+  beforeEach(() => {
+    setIngressPublicBaseUrl(undefined);
+  });
+
+  afterEach(() => {
+    setIngressPublicBaseUrl(undefined);
+  });
+
+  test("returns the configured public base URL", () => {
+    expect(
+      tryGetPublicBaseUrl({
+        ingress: { publicBaseUrl: "https://ingress.example.com/" },
+      }),
+    ).toBe("https://ingress.example.com");
+  });
+
+  test("returns the detected module-level ingress URL", () => {
+    setIngressPublicBaseUrl("https://detected.example.com/");
+    expect(tryGetPublicBaseUrl({})).toBe("https://detected.example.com");
+  });
+
+  test("returns undefined when no URL is configured", () => {
+    expect(tryGetPublicBaseUrl({})).toBeUndefined();
+  });
+
+  test("returns undefined when ingress is explicitly disabled", () => {
+    expect(
+      tryGetPublicBaseUrl({
+        ingress: { enabled: false, publicBaseUrl: "https://example.com" },
+      }),
+    ).toBeUndefined();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Twilio-specific public base URL selection
 // ---------------------------------------------------------------------------

package/src/__tests__/resolve-trust-class.test.ts

@@ -13,7 +13,6 @@ mock.module("../config/env.js", () => ({
 
 import {
   FALLBACK_TURN_TRUST,
-  mapChatTypeToConversationType,
   resolveTrustClass,
 } from "../daemon/trust-context.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
@@ -73,50 +72,3 @@ describe("resolveTrustClass", () => {
     expect(resolveTrustClass(FALLBACK_TURN_TRUST)).toBe("unknown");
   });
 });
-
-describe("mapChatTypeToConversationType", () => {
-  test("maps DM-shaped chat types to dm", () => {
-    expect(mapChatTypeToConversationType("im")).toBe("dm"); // Slack DM
-    expect(mapChatTypeToConversationType("private")).toBe("dm"); // Telegram DM
-    expect(mapChatTypeToConversationType("dm")).toBe("dm"); // Discord DM
-  });
-
-  test("every DM-capable channel's own word for a DM lands on the axis", () => {
-    // A missing arm is silent rather than loud: the permission cell stays
-    // settable, because the adapter validates against the channel registry,
-    // and simply never matches. The guardian sets a rule for DMs on that
-    // channel and it does nothing. Stated as a sweep so adding a DM-capable
-    // channel without its arm fails here.
-    const dmChatTypeByChannel = {
-      slack: "im",
-      telegram: "private",
-      whatsapp: "private",
-      discord: "dm",
-    };
-    for (const [channel, chatType] of Object.entries(dmChatTypeByChannel)) {
-      expect(`${channel}:${mapChatTypeToConversationType(chatType)}`).toBe(
-        `${channel}:dm`,
-      );
-    }
-  });
-
-  test("maps closed-group chat types to private", () => {
-    expect(mapChatTypeToConversationType("mpim")).toBe("private"); // Slack multi-party DM
-    expect(mapChatTypeToConversationType("group")).toBe("private");
-    expect(mapChatTypeToConversationType("supergroup")).toBe("private");
-  });
-
-  test("maps Slack 'channel' to undefined — public and private are indistinguishable", () => {
-    // The gateway forwards every non-DM Slack conversation as "channel"
-    // without a public/private distinction. Mapping it to "public" would let
-    // a permissive public-channel matrix cell govern private channels, so
-    // the channel-type tier must not match at all.
-    expect(mapChatTypeToConversationType("channel")).toBeUndefined();
-  });
-
-  test("maps unknown or absent chat types to undefined", () => {
-    expect(mapChatTypeToConversationType(undefined)).toBeUndefined();
-    expect(mapChatTypeToConversationType("")).toBeUndefined();
-    expect(mapChatTypeToConversationType("broadcast")).toBeUndefined();
-  });
-});

package/src/__tests__/sanitize-config-for-transfer.test.ts

@@ -155,6 +155,34 @@ describe("sanitizeConfigForTransfer", () => {
     });
   });
 
+  test("strips the remembered tunnels and the assistant they fronted", () => {
+    // Every record describes the source host's tunnels; a destination that
+    // inherited them would report the old deployment's tunnel as its own, and
+    // advertise an address on the source's tailnet for pairing.
+    const input = {
+      ingress: {
+        publicBaseUrl: "https://source.ngrok.app",
+        lastTunnel: {
+          provider: "ngrok",
+          publicBaseUrl: "https://source.ngrok.app",
+        },
+        pairingTunnel: {
+          provider: "tailscale",
+          publicBaseUrl: "https://source-host.example.ts.net",
+        },
+        assistantId: "source-assistant",
+        webhook: { path: "/webhook" },
+      },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.ingress).toEqual({
+      publicBaseUrl: "",
+      webhook: { path: "/webhook" },
+    });
+  });
+
   test("preserves nested ingress fields other than environment-specific URL state", () => {
     const input = {
       ingress: {

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -1,6 +1,10 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { eq } from "drizzle-orm";
+
 import { getConfig } from "../config/loader.js";
+import { getDb } from "../persistence/db-connection.js";
+import { providerConnections } from "../persistence/schema/inference.js";
 import { credentialKey } from "../security/credential-key.js";
 
 let lastGeminiConstructorOpts: Record<string, unknown> | null = null;
@@ -160,6 +164,10 @@ describe("secret routes managed proxy registry sync", () => {
     lastGeminiConstructorOpts = null;
     platformBaseUrlOverride = undefined;
     providerRefreshCalls = 0;
+    getDb()
+      .delete(providerConnections)
+      .where(eq(providerConnections.name, "openrouter-connection"))
+      .run();
     await initializeProviders(getConfig());
   });
 
@@ -252,6 +260,47 @@ describe("secret routes managed proxy registry sync", () => {
     expect(providerRefreshCalls).toBe(2);
   });
 
+  /**
+   * Verifies that rotating a credential refreshes providers for dependent connections.
+   */
+  test("non-managed credentials refresh providers when a connection uses them", async () => {
+    // GIVEN a non-managed credential.
+    // AND a provider connection references its canonical credential key.
+    const now = Date.now();
+    getDb()
+      .insert(providerConnections)
+      .values({
+        name: "openrouter-connection",
+        provider: "openai",
+        auth: JSON.stringify({
+          type: "api_key",
+          credential: credentialKey("openrouter", "api_key"),
+        }),
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    // WHEN the credential is rotated.
+    await addCredential("openrouter:api_key", "openrouter-key");
+
+    // THEN the provider refresh runs once.
+    expect(providerRefreshCalls).toBe(1);
+  });
+
+  /**
+   * Verifies that rotating an unused credential does not refresh providers.
+   */
+  test("non-managed credentials do not refresh providers when no connection uses them", async () => {
+    // GIVEN a non-managed credential.
+    // AND no provider connection references its credential key.
+    // WHEN the credential is rotated.
+    await addCredential("openrouter:api_key", "openrouter-key");
+
+    // THEN the provider refresh does not run.
+    expect(providerRefreshCalls).toBe(0);
+  });
+
   test("storing vellum:platform_base_url sets override and triggers initializeProviders", async () => {
     await addCredential(
       "vellum:platform_base_url",

package/src/__tests__/settings-routes.test.ts

@@ -1,9 +1,11 @@
 /**
- * Tests for the `workspace-files` list/read endpoints in settings-routes.
+ * Tests for the `workspace-files` list/read and ingress-config endpoints in
+ * settings-routes.
  *
  * Focus: the list includes the guardian's per-user persona file
- * (`users/<slug>.md`) whenever a guardian exists, and the read endpoint
- * accepts paths under `users/`.
+ * (`users/<slug>.md`) whenever a guardian exists, the read endpoint accepts
+ * paths under `users/`, and writing a different ingress URL drops the tunnel
+ * records that described the old one.
  */
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -194,3 +196,83 @@ describe("GET /workspace-files/read", () => {
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// PUT /integrations/ingress/config
+// ---------------------------------------------------------------------------
+
+describe("PUT integrations/ingress/config", () => {
+  const handler = getHandler("integrations/ingress/config", "PUT");
+  const configPath = join(testWorkspaceDir, "config.json");
+
+  const TUNNEL_URL = "https://assistant-1.example.ts.net";
+  const LAST_TUNNEL = { provider: "tailscale", publicBaseUrl: TUNNEL_URL };
+
+  function readConfig(): Record<string, unknown> {
+    return existsSync(configPath)
+      ? JSON.parse(readFileSync(configPath, "utf-8"))
+      : {};
+  }
+
+  function seedIngress(ingress: Record<string, unknown>): void {
+    writeFileSync(
+      configPath,
+      JSON.stringify({ ...readConfig(), ingress }, null, 2),
+      "utf-8",
+    );
+  }
+
+  function readIngress(): Record<string, unknown> {
+    return readConfig().ingress as Record<string, unknown>;
+  }
+
+  beforeEach(() => {
+    seedIngress({
+      publicBaseUrl: TUNNEL_URL,
+      enabled: true,
+      assistantId: "assistant-1",
+      lastTunnel: LAST_TUNNEL,
+    });
+  });
+
+  test("keeps the records when the URL is unchanged", async () => {
+    await handler(makeArgs({}, { publicBaseUrl: TUNNEL_URL, enabled: false }));
+
+    const ingress = readIngress();
+    expect(ingress.assistantId).toBe("assistant-1");
+    expect(ingress.lastTunnel).toEqual(LAST_TUNNEL);
+  });
+
+  test("ignores trailing slashes and whitespace when comparing", async () => {
+    await handler(
+      makeArgs({}, { publicBaseUrl: ` ${TUNNEL_URL}/ `, enabled: true }),
+    );
+
+    const ingress = readIngress();
+    expect(ingress.assistantId).toBe("assistant-1");
+    expect(ingress.lastTunnel).toEqual(LAST_TUNNEL);
+  });
+
+  test("drops the records when the URL is retargeted", async () => {
+    await handler(
+      makeArgs(
+        {},
+        { publicBaseUrl: "https://other.example.ts.net", enabled: true },
+      ),
+    );
+
+    const ingress = readIngress();
+    expect(ingress.publicBaseUrl).toBe("https://other.example.ts.net");
+    expect(ingress.assistantId).toBeUndefined();
+    expect(ingress.lastTunnel).toBeUndefined();
+  });
+
+  test("drops the records when the URL is cleared", async () => {
+    await handler(makeArgs({}, { publicBaseUrl: "", enabled: false }));
+
+    const ingress = readIngress();
+    expect(ingress.publicBaseUrl).toBeUndefined();
+    expect(ingress.assistantId).toBeUndefined();
+    expect(ingress.lastTunnel).toBeUndefined();
+  });
+});

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -29,6 +29,8 @@ interface JsonCatalogEntry {
   secretKey?: string;
   fallbackOrder?: number;
   privacyPolicyUrl?: string;
+  supportsApiBase?: boolean;
+  defaultApiBase?: string;
 }
 
 interface JsonCatalog {
@@ -75,6 +77,12 @@ function entryToPlain(
   if (entry.privacyPolicyUrl !== undefined) {
     out.privacyPolicyUrl = entry.privacyPolicyUrl;
   }
+  if (entry.supportsApiBase !== undefined) {
+    out.supportsApiBase = entry.supportsApiBase;
+  }
+  if (entry.defaultApiBase !== undefined) {
+    out.defaultApiBase = entry.defaultApiBase;
+  }
   return out;
 }
 

package/src/agent/history-repair/history-repair.ts

@@ -15,6 +15,7 @@
  * recover — so detection and repair of ordering drift live together as one unit.
  */
 
+import { isEffectivelyEmptyContent } from "../../providers/content-blocks.js";
 import { analyzeServerToolPairing } from "../../providers/server-tool-pairing.js";
 import type {
   ContentBlock,
@@ -391,7 +392,7 @@ function formatWebSearchContent(content: unknown): string {
 
 /**
  * Provider rejection messages indicating a tool_use/tool_result pairing or
- * message-ordering violation — the structural drift `deepRepairHistory`
+ * message-ordering violation. The structural drift `deepRepairHistory`
  * re-normalizes.
  */
 export const ORDERING_ERROR_PATTERNS: readonly RegExp[] = [
@@ -420,6 +421,19 @@ export const WEB_SEARCH_ORDERING_PATTERNS: readonly RegExp[] = [
   /web_search.*tool_result/i,
 ];
 
+/** Provider rejections for APIs that require the last history turn to be a user or function turn. */
+export const USER_TERMINAL_HISTORY_PATTERNS: readonly RegExp[] = [
+  /ending with a model turn/i,
+  /must end with a user (turn|message)/i,
+];
+
+/** Whether a provider error message requires history to end with a user turn. */
+export function isUserTerminalHistoryError(message: string): boolean {
+  return USER_TERMINAL_HISTORY_PATTERNS.some((pattern) =>
+    pattern.test(message),
+  );
+}
+
 /**
  * Whether a provider error message denotes an ordering/pairing violation that
  * `deepRepairHistory` can recover by re-normalizing the history. Detection and
@@ -429,21 +443,22 @@ export const WEB_SEARCH_ORDERING_PATTERNS: readonly RegExp[] = [
 export function isRepairableOrderingError(message: string): boolean {
   return (
     ORDERING_ERROR_PATTERNS.some((pattern) => pattern.test(message)) ||
-    WEB_SEARCH_ORDERING_PATTERNS.some((pattern) => pattern.test(message))
+    WEB_SEARCH_ORDERING_PATTERNS.some((pattern) => pattern.test(message)) ||
+    isUserTerminalHistoryError(message)
   );
 }
 
 /**
- * Aggressive repair pass that handles edge cases beyond repairHistory:
- * - Removes empty messages
- * - Ensures the first message is from the user
- * - Merges consecutive same-role messages (before tool-use/result repair)
- * Then applies the standard repairHistory on top (which also merges any
- * consecutive same-role messages introduced by tool-use/result repair).
+ * Removes effectively empty messages, ensures the first message is from the
+ * user, merges consecutive same-role messages, optionally ensures the history
+ * ends with a user message, and applies standard tool-use/result repair.
  */
-export function deepRepairHistory(messages: Message[]): RepairResult {
-  // 1. Remove messages with no content blocks
-  let cleaned = messages.filter((m) => m.content.length > 0);
+export function deepRepairHistory(
+  messages: Message[],
+  options: { requireUserTerminal?: boolean } = {},
+): RepairResult {
+  // 1. Remove messages with no serializable content
+  let cleaned = messages.filter((m) => !isEffectivelyEmptyContent(m.content));
 
   // 2. Strip leading assistant messages (provider requires user-first)
   while (cleaned.length > 0 && cleaned[0].role === "assistant") {
@@ -461,9 +476,25 @@ export function deepRepairHistory(messages: Message[]): RepairResult {
     }
   }
 
-  // 4. Apply standard tool-use/tool-result repair on top. The inner mapping
-  // is keyed to `merged`'s indices, not the caller's input — steps 1–3 drop
-  // and merge messages untracked — so it is not returned.
+  if (options.requireUserTerminal) {
+    let droppedCount = 0;
+    while (
+      merged.length > 0 &&
+      merged[merged.length - 1]?.role === "assistant"
+    ) {
+      merged.pop();
+      droppedCount++;
+    }
+    if (droppedCount > 0) {
+      log.warn(
+        { droppedCount },
+        "Dropped trailing assistant turns because the provider requires history to end with a user turn",
+      );
+    }
+  }
+
+  // Apply standard tool-use/tool-result repair on top. The inner mapping is
+  // keyed to `merged`'s indices, not the caller's input, so it is not returned.
   const { messages: repaired, stats } = repairHistory(merged);
   return { messages: repaired, stats };
 }

package/src/agent/loop.ts

@@ -56,6 +56,7 @@ import { CompactionCircuit } from "./compaction-circuit.js";
 import {
   deepRepairHistory,
   isRepairableOrderingError,
+  isUserTerminalHistoryError,
 } from "./history-repair/history-repair.js";
 
 const log = getLogger("agent-loop");
@@ -2538,7 +2539,9 @@ export class AgentLoop {
           ) {
             orderingRepairAttempted = true;
             postModelCallContinues++;
-            history = deepRepairHistory(errorOutcome.messages).messages;
+            history = deepRepairHistory(errorOutcome.messages, {
+              requireUserTerminal: isUserTerminalHistoryError(err.message),
+            }).messages;
             // Deep repair merges and drops messages, so the prior input
             // boundary no longer maps onto the new array; the repaired history
             // is the base the retry's output appends after.

package/src/api/constants/profile-config-validation.ts

@@ -0,0 +1,60 @@
+/**
+ * Static sanity check for a profile's explicit token budget against the
+ * model's catalog limits. Catches configurations that can never dispatch
+ * (the output budget consumes the model's entire context window, or exceeds
+ * its output cap) at save time instead of on the first chat message.
+ *
+ * Shared surface: the daemon's profile write routes enforce it as a blocking
+ * error, and the web profile editor mirrors the same judgment before its
+ * generic config PATCH, so the two paths cannot drift. Only fires when both
+ * sides of a judgment are known; unlisted models are covered by the live
+ * save-time probe instead.
+ */
+
+/**
+ * Input room a profile must leave when its output budget is judged against
+ * the model's total context window.
+ */
+export const MIN_INPUT_RESERVE_TOKENS = 4096;
+
+export interface ProfileConfigIssue {
+  field: "maxTokens";
+  /** Which judgment fired, so clients can compose surface-specific copy. */
+  code: "over_output_cap" | "no_input_room";
+  message: string;
+}
+
+export function validateInferenceProfileConfig(args: {
+  maxTokens?: number;
+  modelMaxOutputTokens?: number;
+  modelContextWindowTokens?: number;
+}): ProfileConfigIssue | null {
+  const { maxTokens, modelMaxOutputTokens, modelContextWindowTokens } = args;
+  if (maxTokens === undefined) {
+    return null;
+  }
+  if (modelMaxOutputTokens !== undefined && maxTokens > modelMaxOutputTokens) {
+    return {
+      field: "maxTokens",
+      code: "over_output_cap",
+      message:
+        `maxTokens (${maxTokens}) exceeds the model's maximum output of ` +
+        `${modelMaxOutputTokens} tokens. Requests would be rejected upstream; ` +
+        `reduce maxTokens to ${modelMaxOutputTokens} or less.`,
+    };
+  }
+  if (
+    modelContextWindowTokens !== undefined &&
+    maxTokens >= modelContextWindowTokens - MIN_INPUT_RESERVE_TOKENS
+  ) {
+    return {
+      field: "maxTokens",
+      code: "no_input_room",
+      message:
+        `maxTokens (${maxTokens}) reserves the entire ${modelContextWindowTokens}-token ` +
+        `context window for output, leaving no room for your messages. ` +
+        `Reduce maxTokens (e.g. 8000) so input fits.`,
+    };
+  }
+  return null;
+}

package/src/api/events/tool-result.ts

@@ -50,11 +50,16 @@ export const WebSearchProviderIdSchema = z.enum([
   "tavily",
   "keenable",
   "firecrawl",
+  "fastcrw",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
 
-export const WebFetchProviderIdSchema = z.enum(["default", "firecrawl"]);
+export const WebFetchProviderIdSchema = z.enum([
+  "default",
+  "firecrawl",
+  "fastcrw",
+]);
 
 export type WebFetchProviderId = z.infer<typeof WebFetchProviderIdSchema>;
 

package/src/api/events/watch-retro-completed.ts

@@ -0,0 +1,52 @@
+/**
+ * `watch_retro_completed` SSE event.
+ *
+ * Server → client broadcast marking the end of a watch session's
+ * retrospective, the turn `runWatchRetro` dispatches once the recording socket
+ * is gone (`assistant/src/watch/watch-retro.ts`).
+ *
+ * **The watch stream cannot carry this.** A session's socket sends `closed`
+ * and is torn down before the retro is dispatched, so by the time there is
+ * anything to report the transport the user pressed stop on no longer exists.
+ * Every client that draws a watch session is already subscribed to `/v1/events`
+ * for the assistant, which is the one channel still open at that point.
+ *
+ * **Global, not conversation-scoped.** `conversationId` names the thread the
+ * report was written into, which is a background conversation the user is
+ * almost never sitting in: a session is narrated while working in another app
+ * entirely. Clients route this by `sessionId` rather than against whichever
+ * conversation they have open, the same way `notification_conversation_created`
+ * announces a conversation other than the active one.
+ *
+ * **Emitted on every outcome, including the empty ones.** A client that told
+ * the user their session is being summarized has to be told when it is not
+ * coming, or it draws a progress affordance over nothing until it gives up on
+ * its own. `reportReady` is the whole of that distinction: true when the turn
+ * left an account of the session behind and the conversation has been surfaced
+ * for the user to open, false when the session recorded nothing or the turn
+ * failed to produce a report.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly from
+ * this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const WatchRetroCompletedEventSchema = z.object({
+  type: z.literal("watch_retro_completed"),
+  /**
+   * The watch session the retrospective was run for, as the `ready` frame on
+   * the watch stream named it. Clients match on this rather than on the
+   * conversation, because a session can be started against a conversation it
+   * did not mint and two sessions can therefore share one.
+   */
+  sessionId: z.string(),
+  /** The conversation holding the report, and the one to open on a yes. */
+  conversationId: z.string(),
+  /** Whether there is a report in that conversation to read. */
+  reportReady: z.boolean(),
+});
+
+export type WatchRetroCompletedEvent = z.infer<
+  typeof WatchRetroCompletedEventSchema
+>;

package/src/api/index.ts

@@ -129,6 +129,7 @@ import { UISurfaceUpdateEventSchema } from "./events/ui-surface-update.js";
 import { UsageProgressEventSchema } from "./events/usage-progress.js";
 import { UsageUpdateEventSchema } from "./events/usage-update.js";
 import { UserMessageEchoEventSchema } from "./events/user-message-echo.js";
+import { WatchRetroCompletedEventSchema } from "./events/watch-retro-completed.js";
 import { WorkflowCompletedEventSchema } from "./events/workflow-completed.js";
 import { WorkflowLeafFinishedEventSchema } from "./events/workflow-leaf-finished.js";
 import { WorkflowLeafStartedEventSchema } from "./events/workflow-leaf-started.js";
@@ -151,6 +152,11 @@ export {
   type DocumentMutationTool,
   REOPENABLE_DOCUMENT_MUTATION_TOOL_NAMES,
 } from "./constants/document-tools.js";
+export {
+  MIN_INPUT_RESERVE_TOKENS,
+  type ProfileConfigIssue,
+  validateInferenceProfileConfig,
+} from "./constants/profile-config-validation.js";
 export {
   SSE_REPLAY_RING_AGE_LIMIT_MS,
   SSE_REPLAY_RING_COUNT_LIMIT,
@@ -676,6 +682,10 @@ export {
   type UserMessageEchoEvent,
   UserMessageEchoEventSchema,
 } from "./events/user-message-echo.js";
+export {
+  type WatchRetroCompletedEvent,
+  WatchRetroCompletedEventSchema,
+} from "./events/watch-retro-completed.js";
 export {
   type WorkflowCompletedEvent,
   WorkflowCompletedEventSchema,
@@ -1032,6 +1042,7 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   UsageProgressEventSchema,
   UsageUpdateEventSchema,
   UserMessageEchoEventSchema,
+  WatchRetroCompletedEventSchema,
   WorkflowCompletedEventSchema,
   WorkflowLeafFinishedEventSchema,
   WorkflowLeafStartedEventSchema,