@vellumai/assistant 0.11.10-staging.1 → 0.11.10-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.10-staging.1",
+  "version": "0.11.10-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/openai-responses-prompt-cache.test.ts

@@ -412,12 +412,17 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
     expect(JSON.stringify(messages)).not.toContain("prompt_cache_breakpoint");
   });
 
-  test("catalog flags exactly the GPT-5.6 direct-openai rows", () => {
+  test("catalog flags GPT-5.6 and GPT-6 Astra direct-openai rows", () => {
     const openai = PROVIDER_CATALOG.find((p) => p.id === "openai");
     const flagged = (openai?.models ?? [])
       .filter((m) => m.supportsPromptCacheBreakpoints)
       .map((m) => m.id)
       .sort();
-    expect(flagged).toEqual(["gpt-5.6-luna", "gpt-5.6-sol", "gpt-5.6-terra"]);
+    expect(flagged).toEqual([
+      "gpt-5.6-luna",
+      "gpt-5.6-sol",
+      "gpt-5.6-terra",
+      "gpt-6-astra",
+    ]);
   });
 });

package/src/__tests__/openai-responses-provider.test.ts

@@ -700,6 +700,36 @@ describe("OpenAIResponsesProvider", () => {
     });
   });
 
+  test('GPT-6 Astra effort: "max" is sent as reasoning.effort "max"', async () => {
+    const astraProvider = new OpenAIResponsesProvider("sk-test", "gpt-6-astra");
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await astraProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { effort: "max" } },
+    );
+
+    expect(lastStreamParams!.reasoning).toEqual({
+      effort: "max",
+      summary: "auto",
+    });
+  });
+
+  test('GPT-6 Astra effort: "none" snaps to the lowest accepted value', async () => {
+    const astraProvider = new OpenAIResponsesProvider("sk-test", "gpt-6-astra");
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await astraProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { effort: "none" } },
+    );
+
+    expect(lastStreamParams!.reasoning).toEqual({
+      effort: "low",
+      summary: "auto",
+    });
+  });
+
   test("no effort config means no reasoning in params", async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
@@ -845,6 +875,18 @@ describe("OpenAIResponsesProvider", () => {
     expect(lastStreamParams!.text).toEqual({ verbosity: "high" });
   });
 
+  test("verbosity is forwarded for GPT-6 Astra", async () => {
+    const astraProvider = new OpenAIResponsesProvider("sk-test", "gpt-6-astra");
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await astraProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { verbosity: "low" } },
+    );
+
+    expect(lastStreamParams!.text).toEqual({ verbosity: "low" });
+  });
+
   test("verbosity is forwarded for GPT-5 fine-tune IDs", async () => {
     const ftProvider = new OpenAIResponsesProvider(
       "sk-test",

package/src/__tests__/pricing.test.ts

@@ -121,6 +121,35 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBeCloseTo(5 + 6.25 + 1 + 45, 10);
     });
 
+    test("bills GPT-6 Astra at published short-context rates", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-astra", {
+        directInputTokens: 50_000,
+        outputTokens: 0,
+        cacheCreationInputTokens: 50_000,
+        cacheReadInputTokens: 50_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // 0.05M x $10 direct + 0.05M x $12.5 write + 0.05M x $1 read
+      expect(result.estimatedCostUsd).toBeCloseTo(0.5 + 0.625 + 0.05, 10);
+    });
+
+    test("bills GPT-6 Astra at the long-context tier above 272k", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-astra", {
+        directInputTokens: 500_000,
+        outputTokens: 1_000_000,
+        cacheCreationInputTokens: 500_000,
+        cacheReadInputTokens: 1_000_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // Tier rates: 0.5M x $20 direct + 0.5M x $25 write + 1M x $2 read
+      // + 1M x $75 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(10 + 12.5 + 2 + 75, 10);
+    });
+
     test("uses OpenAI short-context tiers through 272k prompt tokens", () => {
       const result = resolvePricingForUsage("openai", "gpt-5.4", {
         directInputTokens: 272_000,

package/src/live-voice/live-voice-session.ts

@@ -1215,6 +1215,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private receivedAudio = false;
   private detectedSpeech = false;
   private dispatchedTurn = false;
+  // Loudest server-VAD chunk not attributed to assistant playback, on the
+  // gate's own scale. Logged with a silent session's end so `no_speech` can
+  // be told apart: a peak under the gate is a user who talked and was not
+  // heard, a peak near the floor is a user who said nothing.
+  private peakChunkAmplitude = 0;
   // The client declared a text input affordance on the start frame, so it can
   // take a turn without the microphone. Governs one thing only: whether a
   // missing speech-to-text leg is fatal to startup (see start()).
@@ -1883,6 +1888,25 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       ),
       outcome: failed ? "failed" : "completed",
     });
+    if (silenceReason !== null) {
+      // The levels behind a silent session, on the gate's scale, since the
+      // end event carries only the classification. A peak below `speechGate`
+      // on a `no_speech` session is a microphone the gate could not hear.
+      log.info(
+        {
+          sessionId: this.context.sessionId,
+          reason,
+          silenceReason,
+          peakChunkAmplitude: Math.round(this.peakChunkAmplitude),
+          noiseFloor:
+            this.roomNoiseFloor.floor === null
+              ? null
+              : Math.round(this.roomNoiseFloor.floor),
+          speechGate: Math.round(this.effectiveBaseThreshold()),
+        },
+        "Live-voice session ended without a turn",
+      );
+    }
 
     const shouldEmitSessionEndMetrics = this.state !== "failed";
     this.state = "closed";
@@ -2294,6 +2318,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (energyClassification === "echo") {
       return;
     }
+    // Measured past the echo gate, so a greeting heard through the speaker
+    // cannot stand in for the user on a silent close.
+    const meanAmplitude = pcm16MeanAmplitude(chunk);
+    if (meanAmplitude > this.peakChunkAmplitude) {
+      this.peakChunkAmplitude = meanAmplitude;
+    }
 
     // Idle mic: hold silent chunks in the bounded pre-roll instead of
     // collecting or streaming them; flushed on speech onset so the

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -54,6 +54,7 @@ describe("isConnectionCompatibleWithModel", () => {
 
   test("oauth_subscription connection is compatible with a Codex model", () => {
     const conn = { auth: oauthAuth };
+    expect(isConnectionCompatibleWithModel(conn, "gpt-6-astra")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-sol")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-terra")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-luna")).toBe(true);

package/src/providers/model-catalog.ts

@@ -403,6 +403,42 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open OpenAI Platform",
     },
     models: [
+      // GPT-6 Astra. cacheRead is the 90% cached-read discount; cacheWrite
+      // is the 1.25x-input rate GPT-5.6+ bills for prompt tokens written to
+      // the cache (reported as `cache_write_tokens` in usage, tracked as
+      // `cacheCreationInputTokens`). Long-context (>272K input) is 2x input
+      // / 1.5x output / 2x cache-read+write for the whole request. Effort
+      // accepts low through max and rejects `none`.
+      {
+        id: "gpt-6-astra",
+        displayName: "GPT-6 Astra",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 10.0,
+          outputPer1mTokens: 50.0,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 1.0,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 20,
+              outputPer1mTokens: 75,
+              cacheWritePer1mTokens: 25,
+              cacheReadPer1mTokens: 2,
+            },
+          ],
+        },
+      },
       // GPT-5.6 family (Sol / Terra / Luna). cacheRead is the 90% cached-read
       // discount; cacheWrite is the 1.25x-input rate GPT-5.6+ bills for
       // prompt tokens written to the cache (reported as `cache_write_tokens`
@@ -1309,6 +1345,72 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         },
       },
       // OpenAI
+      // GPT-6 Astra. The `*-pro` slug is the same underlying model served
+      // with `reasoning.mode: pro` at identical rates. cacheWrite is the
+      // 1.25x-input rate GPT-5.6+ bills for prompt tokens written to the
+      // cache. Long-context (>272K input) is 2x input / 1.5x output / 2x
+      // cache-read+write for the whole request. Effort accepts low through
+      // max and rejects `none`.
+      {
+        id: "openai/gpt-6-astra",
+        displayName: "GPT-6 Astra",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 10.0,
+          outputPer1mTokens: 50.0,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 1.0,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 20,
+              outputPer1mTokens: 75,
+              cacheWritePer1mTokens: 25,
+              cacheReadPer1mTokens: 2,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-astra-pro",
+        displayName: "GPT-6 Astra Pro",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 10.0,
+          outputPer1mTokens: 50.0,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 1.0,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 20,
+              outputPer1mTokens: 75,
+              cacheWritePer1mTokens: 25,
+              cacheReadPer1mTokens: 2,
+            },
+          ],
+        },
+      },
       // GPT-5.6 family (Sol / Terra / Luna). The `*-pro` slugs are the same
       // underlying models served with `reasoning.mode: pro` at identical
       // rates. cacheWrite is the 1.25x-input rate GPT-5.6+ bills for prompt

package/src/providers/openai/chat-completions-provider.ts

@@ -191,7 +191,7 @@ const log = getLogger("chat-completions");
 /** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
  *  `"max"`, but Fireworks accepts it for DeepSeek V4; the assignment to
  *  `params.reasoning_effort` casts through this union. */
-type ReasoningEffortWire = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ReasoningEffortWire = "none" | "low" | "medium" | "high" | "xhigh" | "max";
 
 const REASONING_EFFORT_RANK: Record<ReasoningEffortWire, number> = {
   none: 0,

package/src/providers/openai/codex-models.ts

@@ -9,6 +9,7 @@
  * connection" profile.
  */
 export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
+  "gpt-6-astra",
   "gpt-5.6-sol",
   "gpt-5.6-terra",
   "gpt-5.6-luna",

package/src/providers/openai/responses-provider.ts

@@ -8,7 +8,11 @@ import { extractRetryAfterMs } from "../../util/retry.js";
 import { clampProviderString } from "../content-block-size.js";
 import { fileBlockToProviderText } from "../file-block-text.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
-import { PROMPT_CACHE_BREAKPOINT_MODEL_IDS } from "../model-catalog.js";
+import {
+  modelEffortCeilings,
+  modelSupportedEfforts,
+  PROMPT_CACHE_BREAKPOINT_MODEL_IDS,
+} from "../model-catalog.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import { createToolProgressEmitter } from "../tool-progress-events.js";
@@ -26,7 +30,12 @@ import {
   formatNormalizedOpenAIAPIError,
   normalizeOpenAIAPIError,
 } from "./api-error-normalization.js";
-import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
+import {
+  clampReasoningEffort,
+  detectOpenAICompatibleContextOverflow,
+  type ReasoningEffortWire,
+  snapReasoningEffortToSupported,
+} from "./chat-completions-provider.js";
 import { serializeToolResult } from "./orphaned-tool-result.js";
 
 const log = getLogger("openai-responses");
@@ -46,22 +55,63 @@ export interface OpenAIResponsesProviderOptions {
 }
 
 /** Map our internal effort values to the Responses API reasoning.effort parameter.
- *  OpenAI caps at "xhigh", so our "max" tier collapses to "xhigh". `"none"` is
- *  passed through explicitly because OpenAI defaults `reasoning.effort` to
- *  "medium" when the field is omitted — the user's opt-out is only honored
- *  when we send it on the wire. */
-const EFFORT_TO_REASONING_EFFORT: Record<
-  string,
-  "none" | "low" | "medium" | "high" | "xhigh"
-> = {
+ *  `"max"` is emitted raw and then clamped to the model's catalog ceiling
+ *  ({@link mapResponsesReasoningEffort}); models that omit `maxEffort`
+ *  inherit OpenAI's historical `xhigh` cap. `"none"` is passed through
+ *  explicitly because OpenAI defaults `reasoning.effort` to "medium" when
+ *  the field is omitted, except on models whose `supportedEfforts` omit
+ *  `none` (those snap to the lowest accepted value). */
+const EFFORT_TO_REASONING_EFFORT: Record<string, ReasoningEffortWire> = {
   none: "none",
   low: "low",
   medium: "medium",
   high: "high",
   xhigh: "xhigh",
-  max: "xhigh",
+  max: "max",
 };
 
+const OPENAI_EFFORT_CEILINGS = modelEffortCeilings("openai");
+const OPENROUTER_EFFORT_CEILINGS = modelEffortCeilings("openrouter");
+const OPENAI_SUPPORTED_EFFORTS = modelSupportedEfforts("openai");
+const OPENROUTER_SUPPORTED_EFFORTS = modelSupportedEfforts("openrouter");
+
+function effortCeilingForModel(model: string): "high" | "xhigh" | "max" {
+  return (
+    OPENAI_EFFORT_CEILINGS.get(model) ??
+    OPENROUTER_EFFORT_CEILINGS.get(model) ??
+    "xhigh"
+  );
+}
+
+function supportedEffortsForModel(
+  model: string,
+): readonly ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined {
+  return (
+    OPENAI_SUPPORTED_EFFORTS.get(model) ??
+    OPENROUTER_SUPPORTED_EFFORTS.get(model)
+  );
+}
+
+/** Translate a Vellum effort value onto the Responses wire for `model`. */
+function mapResponsesReasoningEffort(
+  effort: string,
+  model: string,
+): ReasoningEffortWire | undefined {
+  const raw = EFFORT_TO_REASONING_EFFORT[effort];
+  if (!raw) {
+    return undefined;
+  }
+  const supported = supportedEffortsForModel(model);
+  if (raw === "none") {
+    if (supported && supported.length > 0) {
+      return supported[0];
+    }
+    return "none";
+  }
+  const clamped = clampReasoningEffort(raw, effortCeilingForModel(model));
+  return supported ? snapReasoningEffortToSupported(clamped, supported) : clamped;
+}
+
 /** Values accepted by the Responses API `text.verbosity` parameter. */
 const VALID_VERBOSITIES = new Set<string>(["low", "medium", "high"]);
 
@@ -102,15 +152,15 @@ export function mapNeutralToolChoiceForResponses(
   }
 }
 
-/** `text.verbosity` is a GPT-5-series-only parameter. Older models on the
+/** `text.verbosity` is a GPT-5/GPT-6-series parameter. Older models on the
  *  Responses API (o-series, etc.) reject unknown wire fields with HTTP 400, so
  *  gate forwarding by model name here. The retry layer can't make this call
  *  because verbosity defaults to "medium" in the LLM schema, so every
  *  callSite-resolved request would otherwise carry it regardless of model.
  *  Also matches OpenAI fine-tune IDs of the form `ft:gpt-5.x:org::id` so users
- *  on GPT-5 fine-tunes keep explicit verbosity control. */
+ *  on GPT-5/GPT-6 fine-tunes keep explicit verbosity control. */
 function modelSupportsVerbosity(model: string): boolean {
-  return /^(ft:)?gpt-5(\b|[-.])/i.test(model);
+  return /^(ft:)?gpt-[56](\b|[-.])/i.test(model);
 }
 
 /** Loosely-typed Responses stream event to avoid `any` while the SDK types settle. */
@@ -295,7 +345,7 @@ export class OpenAIResponsesProvider implements Provider {
       }
 
       const reasoningEffort = effort
-        ? EFFORT_TO_REASONING_EFFORT[effort]
+        ? mapResponsesReasoningEffort(effort, effectiveModel)
         : undefined;
       if (reasoningEffort) {
         // Request a human-readable reasoning summary whenever the model will