@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/providers/inference/auth.ts

@@ -18,26 +18,28 @@ import { PROVIDER_CATALOG } from "../model-catalog.js";
  * Schema-accepted variants (runtime rejects with a clear "not yet shipped" error):
  *   - service_account: service-account credentials (Vertex AI, Bedrock).
  */
-export const AuthSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("api_key"),
-    credential: z.string().min(1),
-  }),
-  z.object({
-    type: z.literal("platform"),
-  }),
-  z.object({
-    type: z.literal("none"),
-  }),
-  z.object({
-    type: z.literal("oauth_subscription"),
-    credential: z.string().min(1),
-  }),
-  z.object({
-    type: z.literal("service_account"),
-    credential: z.string().min(1),
-  }),
-]);
+export const AuthSchema = z
+  .discriminatedUnion("type", [
+    z.object({
+      type: z.literal("api_key"),
+      credential: z.string().min(1),
+    }),
+    z.object({
+      type: z.literal("platform"),
+    }),
+    z.object({
+      type: z.literal("none"),
+    }),
+    z.object({
+      type: z.literal("oauth_subscription"),
+      credential: z.string().min(1),
+    }),
+    z.object({
+      type: z.literal("service_account"),
+      credential: z.string().min(1),
+    }),
+  ])
+  .meta({ id: "Auth" });
 
 export type Auth = z.infer<typeof AuthSchema>;
 
@@ -75,42 +77,46 @@ export const VALID_CONNECTION_PROVIDERS: readonly string[] =
 
 export type ConnectionProvider = string;
 
-export const ConnectionProviderSchema = z.enum(
-  VALID_CONNECTION_PROVIDERS as readonly [string, ...string[]],
-);
+export const ConnectionProviderSchema = z
+  .enum(VALID_CONNECTION_PROVIDERS as readonly [string, ...string[]])
+  .meta({ id: "ConnectionProvider" });
 
 // ---------------------------------------------------------------------------
 // Per-connection model entries (openai-compatible)
 // ---------------------------------------------------------------------------
 
-export const ConnectionModelSchema = z.object({
-  id: z.string().min(1),
-  displayName: z.string().min(1).optional(),
-});
+export const ConnectionModelSchema = z
+  .object({
+    id: z.string().min(1),
+    displayName: z.string().min(1).optional(),
+  })
+  .meta({ id: "ConnectionModel" });
 export type ConnectionModel = z.infer<typeof ConnectionModelSchema>;
 
 // ---------------------------------------------------------------------------
 // Full connection shape used by CRUD layer
 // ---------------------------------------------------------------------------
 
-export const ProviderConnectionSchema = z.object({
-  name: z.string().min(1),
-  provider: ConnectionProviderSchema,
-  auth: AuthSchema,
-  label: z.string().min(1).nullable(),
-  baseUrl: z.string().url().nullable(),
-  models: z.array(ConnectionModelSchema).nullable(),
-  createdAt: z.number().int(),
-  updatedAt: z.number().int(),
-  /**
-   * Whether this row is a Vellum-managed connection (`anthropic-managed`,
-   * `openai-managed`, `gemini-managed`). Derived from
-   * `MANAGED_CONNECTION_NAMES` in `connections.ts` at serialize time; the
-   * DB column does not exist. Clients use this to render the read-only
-   * "Vellum" badge + view-only editor and to disable the delete affordance
-   * without mirroring the canonical name list locally.
-   */
-  isManaged: z.boolean(),
-});
+export const ProviderConnectionSchema = z
+  .object({
+    name: z.string().min(1),
+    provider: ConnectionProviderSchema,
+    auth: AuthSchema,
+    label: z.string().min(1).nullable(),
+    baseUrl: z.string().url().nullable(),
+    models: z.array(ConnectionModelSchema).nullable(),
+    createdAt: z.number().int(),
+    updatedAt: z.number().int(),
+    /**
+     * Whether this row is a Vellum-managed connection (`anthropic-managed`,
+     * `openai-managed`, `gemini-managed`). Derived from
+     * `MANAGED_CONNECTION_NAMES` in `connections.ts` at serialize time; the
+     * DB column does not exist. Clients use this to render the read-only
+     * "Vellum" badge + view-only editor and to disable the delete affordance
+     * without mirroring the canonical name list locally.
+     */
+    isManaged: z.boolean(),
+  })
+  .meta({ id: "ProviderConnection" });
 
 export type ProviderConnection = z.infer<typeof ProviderConnectionSchema>;

package/src/providers/model-intents.ts

@@ -13,7 +13,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
     balanced: "claude-sonnet-4-6",
     "latency-optimized": "claude-haiku-4-5-20251001",
-    "quality-optimized": "claude-fable-5",
+    "quality-optimized": "claude-opus-4-8",
     "vision-optimized": "claude-opus-4-6",
   },
   openai: {
@@ -43,7 +43,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   openrouter: {
     balanced: "anthropic/claude-sonnet-4.6",
     "latency-optimized": "anthropic/claude-haiku-4.5",
-    "quality-optimized": "anthropic/claude-fable-5",
+    "quality-optimized": "anthropic/claude-opus-4.8",
     "vision-optimized": "anthropic/claude-opus-4.6",
   },
 };

package/src/providers/openai/__tests__/coerce-object-args.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  coerceObjectParamsToJsonString,
+  decodeCoercedObjectArgs,
+} from "../coerce-object-args.js";
+
+const SKILL_EXECUTE_SCHEMA = {
+  type: "object",
+  properties: {
+    tool: { type: "string", description: "The skill tool name" },
+    input: { type: "object", description: "Tool-specific parameters" },
+    activity: { type: "string", description: "Progress update" },
+  },
+  required: ["tool", "input", "activity"],
+};
+
+describe("coerceObjectParamsToJsonString", () => {
+  test("rewrites object params to strings and reports the keys", () => {
+    const { parameters, objectKeys } =
+      coerceObjectParamsToJsonString(SKILL_EXECUTE_SCHEMA);
+
+    expect(objectKeys).toEqual(["input"]);
+    const props = (
+      parameters as { properties: Record<string, { type: string }> }
+    ).properties;
+    expect(props.input.type).toBe("string");
+    // Scalars are left untouched.
+    expect(props.tool.type).toBe("string");
+    expect(props.activity.type).toBe("string");
+    // The required list is preserved.
+    expect((parameters as { required: string[] }).required).toEqual([
+      "tool",
+      "input",
+      "activity",
+    ]);
+  });
+
+  test("leaves array and scalar params alone (no coercion)", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        sources: { type: "array", items: { type: "string" } },
+      },
+    };
+    const { parameters, objectKeys } = coerceObjectParamsToJsonString(schema);
+    expect(objectKeys).toEqual([]);
+    expect(parameters).toEqual(schema);
+  });
+
+  test("handles type unions that include object", () => {
+    const schema = {
+      type: "object",
+      properties: { data: { type: ["object", "null"] } },
+    };
+    const { objectKeys } = coerceObjectParamsToJsonString(schema);
+    expect(objectKeys).toEqual(["data"]);
+  });
+});
+
+describe("decodeCoercedObjectArgs", () => {
+  test("round-trips a JSON-string object back into an object", () => {
+    const { objectKeys } = coerceObjectParamsToJsonString(SKILL_EXECUTE_SCHEMA);
+    // What minimax would send once `input` is a string param.
+    const onWire = {
+      tool: "app_delete",
+      input: '{"app_id": "5ee3d2d5-46e8-4a79-928f-00a7471d340b"}',
+      activity: "Delete placeholder",
+    };
+    const { input, failedKey } = decodeCoercedObjectArgs(onWire, objectKeys);
+    expect(failedKey).toBeUndefined();
+    expect(input.input).toEqual({
+      app_id: "5ee3d2d5-46e8-4a79-928f-00a7471d340b",
+    });
+    // Scalars pass through unchanged.
+    expect(input.tool).toBe("app_delete");
+  });
+
+  test("empty string decodes to an empty object", () => {
+    const { input } = decodeCoercedObjectArgs({ input: "" }, ["input"]);
+    expect(input.input).toEqual({});
+  });
+
+  test("is idempotent when the value is already an object", () => {
+    const args = { input: { app_id: "x" } };
+    const { input, failedKey } = decodeCoercedObjectArgs(args, ["input"]);
+    expect(failedKey).toBeUndefined();
+    expect(input.input).toEqual({ app_id: "x" });
+  });
+
+  test("reports failedKey on invalid JSON instead of throwing", () => {
+    const { failedKey } = decodeCoercedObjectArgs(
+      { input: "{not valid json" },
+      ["input"],
+    );
+    expect(failedKey).toBe("input");
+  });
+
+  test("no-op when there are no coerced keys", () => {
+    const args = { tool: "x", input: "{}" };
+    const { input } = decodeCoercedObjectArgs(args, []);
+    expect(input).toEqual(args);
+  });
+});

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

@@ -18,7 +18,14 @@ import {
   ContextOverflowError,
   extractOverflowTokensFromMessage,
 } from "../types.js";
-import { wrapUnparseableToolArgs } from "../unparseable-tool-args.js";
+import {
+  isUnparseableToolArgs,
+  wrapUnparseableToolArgs,
+} from "../unparseable-tool-args.js";
+import {
+  coerceObjectParamsToJsonString,
+  decodeCoercedObjectArgs,
+} from "./coerce-object-args.js";
 
 /**
  * Detect OpenAI-compatible context-overflow signals on an `OpenAI.APIError`.
@@ -199,6 +206,12 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  content or tool_calls must be set`. See {@link
    *  EMPTY_ASSISTANT_TURN_PLACEHOLDER}. */
   backfillEmptyAssistantContent?: boolean;
+  /** Present object-typed tool params to the model as JSON-string params and
+   *  decode them back to objects on the response. Works around models whose
+   *  function-call serialization collapses nested objects to `{}` (observed
+   *  with minimax-m3 on Fireworks). Off by default; scalars/arrays unaffected.
+   *  See {@link coerceObjectParamsToJsonString}. */
+  coerceObjectArgsToJsonString?: boolean;
 }
 
 /** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
@@ -312,6 +325,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     | "reasoning_content"
     | undefined;
   private backfillEmptyAssistantContent: boolean;
+  private coerceObjectArgsToJsonString: boolean;
 
   constructor(
     apiKey: string,
@@ -337,6 +351,8 @@ export class OpenAIChatCompletionsProvider implements Provider {
     this.assistantReasoningField = options.assistantReasoningField;
     this.backfillEmptyAssistantContent =
       options.backfillEmptyAssistantContent ?? false;
+    this.coerceObjectArgsToJsonString =
+      options.coerceObjectArgsToJsonString ?? false;
   }
 
   async sendMessage(
@@ -355,6 +371,11 @@ export class OpenAIChatCompletionsProvider implements Provider {
       | Record<string, string>
       | undefined;
 
+    // Per-tool keys whose object schemas were rewritten to JSON strings for the
+    // wire, to be decoded back on the response. Empty unless
+    // `coerceObjectArgsToJsonString` is enabled.
+    const coercedObjectKeys = new Map<string, string[]>();
+
     try {
       const openaiMessages = this.toOpenAIMessages(messages, systemPrompt);
 
@@ -398,14 +419,24 @@ export class OpenAIChatCompletionsProvider implements Provider {
       }
 
       if (tools && tools.length > 0) {
-        params.tools = tools.map((t) => ({
-          type: "function" as const,
-          function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.input_schema as OpenAI.FunctionParameters,
-          },
-        }));
+        params.tools = tools.map((t) => {
+          let parameters = t.input_schema as OpenAI.FunctionParameters;
+          if (this.coerceObjectArgsToJsonString) {
+            const coerced = coerceObjectParamsToJsonString(t.input_schema);
+            parameters = coerced.parameters as OpenAI.FunctionParameters;
+            if (coerced.objectKeys.length > 0) {
+              coercedObjectKeys.set(t.name, coerced.objectKeys);
+            }
+          }
+          return {
+            type: "function" as const,
+            function: {
+              name: t.name,
+              description: t.description,
+              parameters,
+            },
+          };
+        });
 
         // Honor a caller-supplied tool_choice (e.g. `{ type: "none" }` to force
         // a text-only answer, or `{ type: "tool", name }` for a forced call).
@@ -638,6 +669,13 @@ export class OpenAIChatCompletionsProvider implements Provider {
         } catch {
           input = wrapUnparseableToolArgs(tc.args);
         }
+        const objectKeys = coercedObjectKeys.get(tc.name);
+        if (objectKeys && !isUnparseableToolArgs(input)) {
+          const decoded = decodeCoercedObjectArgs(input, objectKeys);
+          input = decoded.failedKey
+            ? wrapUnparseableToolArgs(tc.args)
+            : decoded.input;
+        }
         content.push({
           type: "tool_use",
           id: tc.id,

package/src/providers/openai/coerce-object-args.ts

@@ -0,0 +1,104 @@
+/**
+ * Some OpenAI-compatible models (notably minimax-m3 served via Fireworks)
+ * collapse nested *object*-typed tool arguments to `{}` during their
+ * function-call serialization, while scalars and arrays survive intact. The
+ * model reasons correctly about the intended fields, but the object value is
+ * lost on the wire before it reaches us as valid-but-empty JSON, so there is
+ * nothing to recover at parse time.
+ *
+ * The workaround presents every top-level object-typed parameter to the model
+ * as a `string` it fills with JSON (strings survive the serializer), then
+ * decodes that string back into an object before dispatch. The transform is a
+ * matched pair — {@link coerceObjectParamsToJsonString} on the outbound schema
+ * and {@link decodeCoercedObjectArgs} on the inbound tool-call arguments — and
+ * is gated to the affected providers so other models keep native object
+ * passthrough.
+ */
+
+interface ObjectSchemaLike {
+  type?: unknown;
+  properties?: Record<string, { type?: unknown; description?: string }>;
+}
+
+function isObjectTyped(prop: { type?: unknown }): boolean {
+  if (prop?.type === "object") return true;
+  if (Array.isArray(prop?.type) && prop.type.includes("object")) return true;
+  return false;
+}
+
+export interface CoercedToolSchema {
+  /** The tool's JSON schema with object params rewritten to JSON-string params. */
+  parameters: Record<string, unknown>;
+  /** Top-level param keys that were object-typed and are now JSON strings. */
+  objectKeys: string[];
+}
+
+/**
+ * Rewrite top-level `type: "object"` properties of a tool's input schema into
+ * `type: "string"` params the model fills with JSON. Returns the rewritten
+ * schema plus the list of converted keys so the inbound side can reverse it.
+ * Non-object params (scalars, arrays) are passed through unchanged. Arrays and
+ * deeper-nested objects are intentionally left alone — only top-level object
+ * params are observed to collapse.
+ */
+export function coerceObjectParamsToJsonString(
+  inputSchema: unknown,
+): CoercedToolSchema {
+  const schema = inputSchema as ObjectSchemaLike | undefined;
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return {
+      parameters: (inputSchema as Record<string, unknown>) ?? {},
+      objectKeys: [],
+    };
+  }
+
+  const objectKeys: string[] = [];
+  const properties: Record<string, unknown> = {};
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    if (isObjectTyped(prop)) {
+      objectKeys.push(key);
+      properties[key] = {
+        type: "string",
+        description:
+          `${prop.description ?? ""}\n\nPass this argument as a JSON object encoded as a string, e.g. "{\\"key\\": \\"value\\"}".`.trim(),
+      };
+    } else {
+      properties[key] = prop;
+    }
+  }
+
+  return { parameters: { ...schema, properties }, objectKeys };
+}
+
+/**
+ * Reverse {@link coerceObjectParamsToJsonString}: for each coerced key whose
+ * value arrived as a string, JSON-parse it back into an object. Values that are
+ * already objects (e.g. replayed conversation history, or a model that sent the
+ * object natively) are left untouched, so the decode is idempotent. An empty
+ * string decodes to `{}`. If a non-empty string fails to parse, the key name is
+ * returned in `failedKey` so the caller can surface a retryable error instead of
+ * silently dispatching garbage.
+ */
+export function decodeCoercedObjectArgs(
+  input: Record<string, unknown>,
+  objectKeys: string[],
+): { input: Record<string, unknown>; failedKey?: string } {
+  if (objectKeys.length === 0) return { input };
+
+  const result: Record<string, unknown> = { ...input };
+  for (const key of objectKeys) {
+    const value = result[key];
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      result[key] = {};
+      continue;
+    }
+    try {
+      result[key] = JSON.parse(trimmed);
+    } catch {
+      return { input: result, failedKey: key };
+    }
+  }
+  return { input: result };
+}

package/src/providers/retry.ts

@@ -197,22 +197,25 @@ function normalizeSendMessageOptions(
   delete nextConfig.usageAttributionHeaders;
   delete nextConfig.usageTracking;
 
-  // `overrideProfile` and `selectionSeed` are routing/resolution-time concerns
-  // (consumed by the resolver below and `CallSiteRoutingProvider`'s provider
-  // selection); neither is a wire-format field. Strip unconditionally so they
-  // never leak into provider request bodies even when callers set them without
-  // a `callSite`.
+  // `overrideProfile`, `forceOverrideProfile`, and `selectionSeed` are
+  // routing/resolution-time concerns (consumed by the resolver below and
+  // `CallSiteRoutingProvider`'s provider selection); none is a wire-format
+  // field. Strip unconditionally so they never leak into provider request
+  // bodies even when callers set them without a `callSite`.
   delete nextConfig.overrideProfile;
+  delete nextConfig.forceOverrideProfile;
   delete nextConfig.selectionSeed;
 
   if (config.callSite !== undefined) {
     const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm, {
       overrideProfile: config.overrideProfile,
+      forceOverrideProfile: config.forceOverrideProfile,
       selectionSeed: config.selectionSeed,
     });
     const attribution = resolveUsageAttribution({
       callSite: config.callSite,
       overrideProfile: config.overrideProfile,
+      forceOverrideProfile: config.forceOverrideProfile,
       selectionSeed: config.selectionSeed,
     });
 

package/src/providers/types.ts

@@ -182,6 +182,16 @@ export interface SendMessageConfig {
    * silently fall through.
    */
   overrideProfile?: string;
+  /**
+   * When true, the resolver floats `overrideProfile` above the call-site
+   * layers (named site profile + call-site override) for non-main-agent call
+   * sites — see `ResolveCallSiteOpts.forceOverrideProfile`. Used by callers
+   * that must run a background call site under a specific conversation's
+   * inference profile (e.g. fork-based memory retrospectives). A
+   * resolution/routing-time concern only; stripped before any provider wire
+   * request.
+   */
+  forceOverrideProfile?: boolean;
   /**
    * Per-conversation seed for deterministic `mix`-profile expansion. The agent
    * loop sets this to the conversation id so every resolver call this send