@vellumai/assistant 0.12.2-dev.202609181315.9aaf787 → 0.12.2-dev.202609181515.7e76c92

package/docs/voice-input-diagnostics.md

@@ -30,6 +30,7 @@ Search the assistant log for `Live voice input diagnostics` or `voice_input_`. A
 - `voice_input_window` summarizes each approximately five-second arrival window: received audio duration, zero-signal duration, duration-weighted mean amplitude, minimum/maximum chunk mean amplitude, classified speech/silence/echo duration, and maximum arrival gap. Window emission requires incoming audio; `voice_input_closed` flushes a partial window.
 - The same window includes `sttSubmittedChunks`, `sttSubmittedAudioMs`, and `sttMaxSubmissionGapMs`. These measure handoff to the transcription adapter, not provider receipt. A probe can buffer audio before submission, and the final chunk of an arrival window can be submitted in the next window. Compare sustained windows to identify input that arrives normally but stops reaching transcription.
 - `voice_input_provider_turn_start` and `voice_input_provider_turn_end` record provider boundaries alongside local VAD state. End records include confidence, the provider's `trigger` (`model`, `timeout`, or `manual`), decoded audio position in seconds from stream start, and elapsed time since locally detected speech. Missing provider fields are null. These records describe received decisions, including ones ignored as stale or after fallback; correlate with the turn metrics to identify the boundary that committed the request.
+- `voice_input_microphone_gate_changed` records when the transcription audio gate closes or reopens. `microphoneGateClosed` is included with the other input diagnostics. Closing replaces room audio with silence; it does not commit a transcript or stop local interruption detection.
 - `voice_input_barge_in_armed`, `voice_input_barge_in_fired`, and `voice_input_barge_in_expired` distinguish a candidate from an accepted or expired interruption. Fired events include accumulated speech duration, guard resets, and a bounded trace of the preceding two seconds (at most 40 input chunks).
 - Each trace entry captures the amplitude and gate/echo state before classification, and classified durations, remaining probe buffer, and correlation result after classification. The classifier can hold a probe and release multiple older chunks together, so a row's classified duration can differ from its received duration. A null correlation means no comparison ran, not a measured zero correlation.
 - `voice_input_speech_routed` binds the speech generation to the input turn that actually receives its audio. At onset, the prior spent cycle may still be installed, so use this routing record for correlation rather than assuming the onset's `inputTurnId` is the new utterance.
@@ -41,6 +42,12 @@ These are local diagnostic logs, not new analytics events or voice protocol fiel
 
 ## Flux pause handling
 
-When Flux owns turn detection, it receives microphone audio through idle periods and pauses, including quiet speech below the local VAD gate. Confirmed playback echo is replaced by silence of the same duration so it advances the provider's audio clock without transcribing the assistant's voice. Echo probes can briefly buffer that audio. Local VAD still owns barge-in; its thresholds and guard are independent of this continuous transcription feed. Idle audio is not accumulated into request recordings.
+When Flux owns turn detection, microphone audio passes through for one second of received audio after the last locally detected speech. After that, the input gate replaces room audio with digital silence while the microphone and local interruption detector keep listening. The cutoff is measured in PCM samples, so network batching does not change it. Flux continues receiving elapsed silence and owns the turn boundary; closing this gate does not release the question.
+
+While closed, the gate holds the most recent 200 ms before deciding whether to send those samples as silence or as the lead-in to resumed speech. On speech onset, it forwards that lead-in and the new speech exactly once. The provider feed can lag input by up to 200 ms while idle, then catches up on speech onset. Confirmed playback echo is replaced with silence before entering this buffer. Local VAD still owns barge-in, and idle audio is not accumulated into request recordings. Manual capture and locally endpointed providers retain their existing routing.
+
+The gate shares the existing adaptive energy classifier. Quiet speech within the one-second tail passes through; quiet onset in the 200 ms buffer is preserved if followed by detected speech. Sustained speech entirely below the local threshold can be suppressed, and noise classified as speech can reopen the gate. This limits background exposure rather than guaranteeing that every false transcript is eliminated.
 
 For a focused reproduction, say an unfinished question such as "Did they help invent", pause briefly, then complete it with "ChatGPT". Repeat with a shorter and a longer pause, plus a complete short question. Note when the assistant starts answering and export the logs. Check that STT submissions continue during the pause, then use the provider end event's time, confidence, and trigger to distinguish model endpointing from a timeout. Tests verify audio delivery and event handling; they do not establish how Flux will segment real speech.
+
+For the idle gate, stay silent and type for 20 seconds, then ask a question with a pause longer than one second. Repeat with a quiet voice and with a deliberate interruption during an answer. Check for phantom requests, a clipped first syllable, split questions, and missed interruptions. Correlate those observations with gate transitions and provider turn events.

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/package.json

@@ -27,7 +27,8 @@
     "./reactions": "./src/reactions.ts",
     "./guardian-requests": "./src/guardian-requests.ts",
     "./platform-credential": "./src/platform-credential.ts",
-    "./plan-credit": "./src/plan-credit.ts"
+    "./plan-credit": "./src/plan-credit.ts",
+    "./integration-categories": "./src/integration-categories.ts"
   },
   "scripts": {
     "typecheck": "bunx tsc --noEmit",

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/index.ts

@@ -29,6 +29,7 @@ export * from "./trust-rules.js";
 export * from "./ingress.js";
 export * from "./no-response.js";
 export * from "./plan-credit.js";
+export * from "./integration-categories.js";
 export * from "./platform-credential.js";
 export * from "./remote-web-pairing.js";
 export * from "./twilio-ingress.js";

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/integration-categories.ts

@@ -0,0 +1,36 @@
+/**
+ * Category vocabulary for the integrations catalog, shared by the assistant
+ * daemon (which stamps it on OAuth providers and marketplace MCP entries) and
+ * the clients (which draw the category filter from it).
+ *
+ * The order here is the order clients show the categories in. The slug is the
+ * wire value; the user-facing label is the client's, so it can be translated.
+ */
+export const INTEGRATION_CATEGORIES = [
+  "productivity",
+  "communication",
+  "meetings",
+  "sales",
+  "marketing",
+  "finance",
+  "commerce",
+  "engineering",
+  "knowledge",
+  "recruiting",
+] as const;
+
+export type IntegrationCategory = (typeof INTEGRATION_CATEGORIES)[number];
+
+const INTEGRATION_CATEGORY_SET: ReadonlySet<string> = new Set(
+  INTEGRATION_CATEGORIES,
+);
+
+/**
+ * Whether `value` names a category this build knows. A client reading a newer
+ * catalog treats an unknown slug as uncategorized rather than failing.
+ */
+export function isIntegrationCategory(
+  value: unknown,
+): value is IntegrationCategory {
+  return typeof value === "string" && INTEGRATION_CATEGORY_SET.has(value);
+}

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/package.json

@@ -27,7 +27,8 @@
     "./reactions": "./src/reactions.ts",
     "./guardian-requests": "./src/guardian-requests.ts",
     "./platform-credential": "./src/platform-credential.ts",
-    "./plan-credit": "./src/plan-credit.ts"
+    "./plan-credit": "./src/plan-credit.ts",
+    "./integration-categories": "./src/integration-categories.ts"
   },
   "scripts": {
     "typecheck": "bunx tsc --noEmit",

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/index.ts

@@ -29,6 +29,7 @@ export * from "./trust-rules.js";
 export * from "./ingress.js";
 export * from "./no-response.js";
 export * from "./plan-credit.js";
+export * from "./integration-categories.js";
 export * from "./platform-credential.js";
 export * from "./remote-web-pairing.js";
 export * from "./twilio-ingress.js";

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/integration-categories.ts

@@ -0,0 +1,36 @@
+/**
+ * Category vocabulary for the integrations catalog, shared by the assistant
+ * daemon (which stamps it on OAuth providers and marketplace MCP entries) and
+ * the clients (which draw the category filter from it).
+ *
+ * The order here is the order clients show the categories in. The slug is the
+ * wire value; the user-facing label is the client's, so it can be translated.
+ */
+export const INTEGRATION_CATEGORIES = [
+  "productivity",
+  "communication",
+  "meetings",
+  "sales",
+  "marketing",
+  "finance",
+  "commerce",
+  "engineering",
+  "knowledge",
+  "recruiting",
+] as const;
+
+export type IntegrationCategory = (typeof INTEGRATION_CATEGORIES)[number];
+
+const INTEGRATION_CATEGORY_SET: ReadonlySet<string> = new Set(
+  INTEGRATION_CATEGORIES,
+);
+
+/**
+ * Whether `value` names a category this build knows. A client reading a newer
+ * catalog treats an unknown slug as uncategorized rather than failing.
+ */
+export function isIntegrationCategory(
+  value: unknown,
+): value is IntegrationCategory {
+  return typeof value === "string" && INTEGRATION_CATEGORY_SET.has(value);
+}

package/node_modules/@vellumai/service-contracts/package.json

@@ -27,7 +27,8 @@
     "./reactions": "./src/reactions.ts",
     "./guardian-requests": "./src/guardian-requests.ts",
     "./platform-credential": "./src/platform-credential.ts",
-    "./plan-credit": "./src/plan-credit.ts"
+    "./plan-credit": "./src/plan-credit.ts",
+    "./integration-categories": "./src/integration-categories.ts"
   },
   "scripts": {
     "typecheck": "bunx tsc --noEmit",

package/node_modules/@vellumai/service-contracts/src/index.ts

@@ -29,6 +29,7 @@ export * from "./trust-rules.js";
 export * from "./ingress.js";
 export * from "./no-response.js";
 export * from "./plan-credit.js";
+export * from "./integration-categories.js";
 export * from "./platform-credential.js";
 export * from "./remote-web-pairing.js";
 export * from "./twilio-ingress.js";

package/node_modules/@vellumai/service-contracts/src/integration-categories.ts

@@ -0,0 +1,36 @@
+/**
+ * Category vocabulary for the integrations catalog, shared by the assistant
+ * daemon (which stamps it on OAuth providers and marketplace MCP entries) and
+ * the clients (which draw the category filter from it).
+ *
+ * The order here is the order clients show the categories in. The slug is the
+ * wire value; the user-facing label is the client's, so it can be translated.
+ */
+export const INTEGRATION_CATEGORIES = [
+  "productivity",
+  "communication",
+  "meetings",
+  "sales",
+  "marketing",
+  "finance",
+  "commerce",
+  "engineering",
+  "knowledge",
+  "recruiting",
+] as const;
+
+export type IntegrationCategory = (typeof INTEGRATION_CATEGORIES)[number];
+
+const INTEGRATION_CATEGORY_SET: ReadonlySet<string> = new Set(
+  INTEGRATION_CATEGORIES,
+);
+
+/**
+ * Whether `value` names a category this build knows. A client reading a newer
+ * catalog treats an unknown slug as uncategorized rather than failing.
+ */
+export function isIntegrationCategory(
+  value: unknown,
+): value is IntegrationCategory {
+  return typeof value === "string" && INTEGRATION_CATEGORY_SET.has(value);
+}

package/openapi.yaml

@@ -21120,6 +21120,7 @@ paths:
                                           - keenable
                                           - firecrawl
                                           - fastcrw
+                                          - searxng
                                       resultCount:
                                         type: number
                                       durationMs:
@@ -21637,6 +21638,7 @@ paths:
                                                   - keenable
                                                   - firecrawl
                                                   - fastcrw
+                                                  - searxng
                                               resultCount:
                                                 type: number
                                               durationMs:
@@ -24508,6 +24510,22 @@ paths:
                             anyOf:
                               - type: string
                               - type: "null"
+                          category:
+                            anyOf:
+                              - type: string
+                                enum:
+                                  - productivity
+                                  - communication
+                                  - meetings
+                                  - sales
+                                  - marketing
+                                  - finance
+                                  - commerce
+                                  - engineering
+                                  - knowledge
+                                  - recruiting
+                              - type: "null"
+                            description: Where the integrations catalog files the provider; null for a provider without a seed entry.
                           tenant_host:
                             anyOf:
                               - type: object
@@ -24540,6 +24558,7 @@ paths:
                           - supports_managed_mode
                           - managed_service_is_paid
                           - feature_flag
+                          - category
                           - tenant_host
                           - acts_as
                         additionalProperties: false
@@ -25059,6 +25078,22 @@ paths:
                           anyOf:
                             - type: string
                             - type: "null"
+                        category:
+                          anyOf:
+                            - type: string
+                              enum:
+                                - productivity
+                                - communication
+                                - meetings
+                                - sales
+                                - marketing
+                                - finance
+                                - commerce
+                                - engineering
+                                - knowledge
+                                - recruiting
+                            - type: "null"
+                          description: Where the integrations catalog files the provider; null for a provider without a seed entry.
                         tenant_host:
                           anyOf:
                             - type: object
@@ -25091,6 +25126,7 @@ paths:
                         - supports_managed_mode
                         - managed_service_is_paid
                         - feature_flag
+                        - category
                         - tenant_host
                         - acts_as
                       additionalProperties: false
@@ -27656,6 +27692,11 @@ paths:
                               type: string
                             oauthProvider:
                               type: string
+                            category:
+                              description:
+                                "Where the integrations catalog files the entry: a slug from the shared integration-category vocabulary,
+                                passed through as the catalog declares it."
+                              type: string
                           required:
                             - kind
                             - displayName

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609181315.9aaf787",
+  "version": "0.12.2-dev.202609181515.7e76c92",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-provider-error-recording.test.ts

@@ -3,17 +3,19 @@
  *
  * When the provider call throws (provider rejected the request before
  * returning a usable response), the loop must emit a `provider_error` event
- * carrying the loop-level raw request and the thrown error so downstream
- * consumers can persist an `llm_request_logs` row. Without this, rejected
- * calls leave nothing in the LLM inspector — only a pino log line.
+ * carrying the inspectable wire request (when the throw attached one) and
+ * the thrown error so downstream consumers can persist an `llm_request_logs`
+ * row. Without this, rejected calls leave nothing in the LLM inspector —
+ * only a pino log line.
  *
  * Coverage:
- *  - Emits `provider_error` with `rawRequest`, `error`, and `actualProvider`
- *    when the provider throws a `ProviderError`.
- *  - `rawRequest` carries the message history, tools, and system prompt the
- *    loop attempted to send — so the row replays/debugs cleanly.
- *  - `actualProvider` echoes `ProviderError.provider` when available, falling
- *    back to `provider.name` for non-ProviderError throws.
+ *  - Emits `provider_error` with `error` and `actualProvider` when the
+ *    provider throws a `ProviderError`.
+ *  - `rawRequest` is `ProviderError.rawRequest` when present, and stays
+ *    unset when the throw did not attach a wire payload. The loop does
+ *    not invent a messages/tools/systemPrompt snapshot.
+ *  - `actualProvider` echoes `ProviderError.provider` when available, even
+ *    if the wrapping `provider.name` is a different default transport.
  *  - The error is still re-thrown internally (the existing `error` event
  *    still fires after the new `provider_error` event), preserving the
  *    outer-catch behavior (abort/Sentry/break).
@@ -73,7 +75,7 @@ function makeThrowingProvider(
 }
 
 describe("AgentLoop provider_error event emission", () => {
-  test("emits provider_error with loop-level rawRequest when provider throws ProviderError", async () => {
+  test("emits provider_error without inventing a rawRequest snapshot", async () => {
     const thrown = new ProviderError(
       "Anthropic API error (429): rate limited",
       "anthropic",
@@ -107,16 +109,81 @@ describe("AgentLoop provider_error event emission", () => {
     }
     expect(providerErrorEvent.error).toBe(thrown);
     expect(providerErrorEvent.actualProvider).toBe("anthropic");
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
+  });
+
+  test("forwards ProviderError.rawRequest on the provider_error event", async () => {
+    const wirePayload = {
+      model: "qwen/qwen3-8b",
+      directions: { serious: 0.8 },
+    };
+    const thrown = new ProviderError(
+      "Vellum API error (400): directions are not loaded",
+      "vellum",
+      400,
+      {
+        rawRequest: wirePayload,
+        rawBody: '{"detail":"directions are not loaded"}',
+      },
+    );
+    const { provider } = makeThrowingProvider("fireworks", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.actualProvider).toBe("vellum");
+    expect(providerErrorEvent.rawRequest).toEqual(wirePayload);
+  });
+
+  test("actualProvider uses ProviderError.provider, not the wrapper name", async () => {
+    const thrown = new ProviderError(
+      "Vellum API error (400): directions are not loaded",
+      "vellum",
+      400,
+    );
+    const { provider } = makeThrowingProvider("fireworks", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
 
-    // rawRequest should carry the loop-level abstract shape: messages,
-    // tools, systemPrompt, and the provider name we tried to dispatch
-    // through. The provider-specific shape (e.g. Gemini's `contents`) is
-    // never built because the provider threw before returning it.
-    const raw = providerErrorEvent.rawRequest as Record<string, unknown>;
-    expect(raw.provider).toBe("anthropic");
-    expect(raw.systemPrompt).toBe("you are a helpful assistant");
-    expect(Array.isArray(raw.messages)).toBe(true);
-    expect((raw.messages as Message[])[0].role).toBe("user");
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.actualProvider).toBe("vellum");
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
   });
 
   test("error event still fires after provider_error (outer catch behavior unchanged)", async () => {
@@ -185,6 +252,7 @@ describe("AgentLoop provider_error event emission", () => {
     // `provider` column populated even for surprise errors.
     expect(providerErrorEvent.actualProvider).toBe("openai");
     expect(providerErrorEvent.error).toBe(thrown);
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
   });
 
   test("does NOT emit provider_error on user-aborted runs", async () => {

package/src/__tests__/anthropic-gateway-shared.test.ts

@@ -103,6 +103,26 @@ describe("retagDelegateError", () => {
     expect(err.apiErrorCode).toBe("restricted");
     expect(err.apiErrorParam).toBe("model");
     expect(err.rawBody).toBe('{"type":"error"}');
+    expect(err.rawRequest).toBeUndefined();
+  });
+
+  test("carries rawRequest across the re-tag", () => {
+    const rawRequest = { model: "anthropic/claude-opus-4.6", messages: [] };
+    const inner = new ProviderError("rate limited", "anthropic", 429, {
+      rawRequest,
+    });
+
+    let caught: unknown;
+    try {
+      retagDelegateError(inner, providerName);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(ProviderError);
+    const err = caught as ProviderError;
+    expect(err.provider).toBe(providerName);
+    expect(err.rawRequest).toEqual(rawRequest);
   });
 
   test("re-tags a delegate ContextOverflowError, preserving token counts", () => {
@@ -110,6 +130,7 @@ describe("retagDelegateError", () => {
       actualTokens: 250_000,
       maxTokens: 200_000,
       statusCode: 400,
+      rawRequest: { model: "anthropic/claude-opus-4.6" },
     });
 
     let caught: unknown;
@@ -126,6 +147,7 @@ describe("retagDelegateError", () => {
     expect(err.maxTokens).toBe(200_000);
     expect(err.statusCode).toBe(400);
     expect(err.cause).toBe(inner);
+    expect(err.rawRequest).toEqual({ model: "anthropic/claude-opus-4.6" });
   });
 
   test("rethrows an already-tagged error unchanged", () => {