@vellumai/assistant 0.6.4 → 0.6.5

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.0.0
 info:
   title: Vellum Assistant API
-  version: 0.6.4
+  version: 0.6.5
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -2088,7 +2088,7 @@ paths:
                   description: Pending interaction request ID
                 decision:
                   type: string
-                  description: "One of: allow, allow_10m, allow_conversation, deny, always_allow, always_deny, always_allow_high_risk"
+                  description: "One of: allow, allow_10m, allow_conversation, deny, always_allow, always_deny"
                 selectedPattern:
                   type: string
                   description: Allowlist pattern for persistent decisions
@@ -4243,6 +4243,7 @@ paths:
                             - new
                             - seen
                             - acted_on
+                            - dismissed
                         expiresAt:
                           type: string
                         minTimeAway:
@@ -4265,6 +4266,13 @@ paths:
                               - label
                               - prompt
                             additionalProperties: false
+                        urgency:
+                          type: string
+                          enum:
+                            - low
+                            - medium
+                            - high
+                            - critical
                         author:
                           type: string
                           enum:
@@ -4301,10 +4309,51 @@ paths:
                       - timeAwayLabel
                       - newCount
                     additionalProperties: false
+                  suggestedPrompts:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        id:
+                          type: string
+                        label:
+                          type: string
+                        icon:
+                          type: string
+                        prompt:
+                          type: string
+                        source:
+                          type: string
+                          enum:
+                            - deterministic
+                            - assistant
+                      required:
+                        - id
+                        - label
+                        - prompt
+                        - source
+                      additionalProperties: false
+                  lowPriorityCollapsed:
+                    type: object
+                    properties:
+                      count:
+                        type: integer
+                        minimum: 0
+                        maximum: 9007199254740991
+                      itemIds:
+                        type: array
+                        items:
+                          type: string
+                    required:
+                      - count
+                      - itemIds
+                    additionalProperties: false
                 required:
                   - items
                   - updatedAt
                   - contextBanner
+                  - suggestedPrompts
+                  - lowPriorityCollapsed
                 additionalProperties: false
       parameters:
         - name: timeAwaySeconds
@@ -4365,6 +4414,7 @@ paths:
                       - new
                       - seen
                       - acted_on
+                      - dismissed
                   expiresAt:
                     type: string
                   minTimeAway:
@@ -4387,6 +4437,13 @@ paths:
                         - label
                         - prompt
                       additionalProperties: false
+                  urgency:
+                    type: string
+                    enum:
+                      - low
+                      - medium
+                      - high
+                      - critical
                   author:
                     type: string
                     enum:
@@ -4424,6 +4481,7 @@ paths:
                     - new
                     - seen
                     - acted_on
+                    - dismissed
               required:
                 - status
               additionalProperties: false
@@ -4915,6 +4973,14 @@ paths:
       responses:
         "200":
           description: Successful response
+  /v1/integrations/slack/channel/oauth-install:
+    post:
+      operationId: integrations_slack_channel_oauthinstall_post
+      tags:
+        - channel
+      responses:
+        "200":
+          description: Successful response
   /v1/integrations/telegram/commands:
     post:
       operationId: integrations_telegram_commands_post
@@ -5525,7 +5591,10 @@ paths:
     post:
       operationId: migrations_import_post
       summary: Import a .vbundle archive
-      description: Commit a .vbundle archive import to disk — destructive. Backs up existing files before overwriting.
+      description:
+        Commit a .vbundle archive import to disk — destructive. Accepts the bundle as raw bytes
+        (application/octet-stream), multipart/form-data, or a JSON body carrying a signed URL the daemon fetches and
+        streams through the importer.
       tags:
         - migrations
       responses:
@@ -5559,6 +5628,56 @@ paths:
                   - manifest
                   - warnings
                 additionalProperties: false
+        "502":
+          description:
+            "Upstream fetch failed (URL body only). Body shape: { success: false, reason: 'fetch_failed',
+            upstream_status?: number }."
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  success:
+                    type: boolean
+                  reason:
+                    type: string
+                    enum:
+                      - fetch_failed
+                  upstream_status:
+                    type: integer
+                required:
+                  - success
+                  - reason
+      requestBody:
+        required: true
+        content:
+          application/octet-stream:
+            schema:
+              type: string
+              format: binary
+              description: Raw .vbundle archive bytes.
+          multipart/form-data:
+            schema:
+              type: object
+              properties:
+                file:
+                  type: string
+                  format: binary
+                  description: The .vbundle archive uploaded as a file field.
+              required:
+                - file
+          application/json:
+            schema:
+              type: object
+              properties:
+                url:
+                  type: string
+                  format: uri
+                  description:
+                    A signed GCS URL pointing to the .vbundle archive. The daemon fetches the URL and streams the body through
+                    the importer.
+              required:
+                - url
   /v1/migrations/import-preflight:
     post:
       operationId: migrations_importpreflight_post
@@ -8488,9 +8607,6 @@ paths:
                 decision:
                   type: string
                   description: allow or deny
-                allowHighRisk:
-                  type: boolean
-                  description: Allow high-risk invocations
               required:
                 - requestId
                 - pattern
@@ -8556,20 +8672,16 @@ paths:
                   description: Allowlist pattern
                 scope:
                   type: string
-                  description: Scope
+                  description: Scope (required for scoped tools, ignored for others)
                 decision:
                   type: string
                   description: allow, deny, or ask
-                allowHighRisk:
-                  type: boolean
-                  description: Allow high-risk invocations
                 executionTarget:
                   type: string
                   description: Execution target
               required:
                 - toolName
                 - pattern
-                - scope
                 - decision
               additionalProperties: false
   /v1/trust-rules/manage/{id}:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -35,6 +35,8 @@
     "@modelcontextprotocol/sdk": "1.27.1",
     "@qdrant/js-client-rest": "1.17.0",
     "@resvg/resvg-js": "2.6.2",
+    "@resvg/resvg-js-darwin-arm64": "2.6.2",
+    "@resvg/resvg-js-darwin-x64": "2.6.2",
     "@sentry/node": "10.43.0",
     "@vellumai/ces-contracts": "file:../packages/ces-contracts",
     "@vellumai/credential-storage": "file:../packages/credential-storage",
@@ -54,6 +56,7 @@
     "postgres": "3.4.8",
     "qrcode": "1.5.4",
     "rrule": "2.8.1",
+    "tar-stream": "3.1.7",
     "tldts": "7.0.25",
     "tree-sitter-bash": "0.25.1",
     "uuid": "11.1.0",
@@ -70,8 +73,8 @@
     "@vellumai/egress-proxy"
   ],
   "overrides": {
-    "lodash": "^4.18.0",
-    "path-to-regexp": "^8.4.0"
+    "lodash": "4.18.1",
+    "path-to-regexp": "8.4.2"
   },
   "devDependencies": {
     "@types/archiver": "7.0.0",

package/scripts/generate-openapi.ts

@@ -56,6 +56,17 @@ const RouteBodySchemaSchema = z.any().refine(
   { message: "Expected a Zod schema or a plain JSON Schema object" },
 );
 
+const RouteRequestBodyVariantSchema = z.object({
+  contentType: z.string(),
+  /** Zod schema OR plain JSON Schema fragment. */
+  schema: z.any(),
+});
+
+const RouteAdditionalResponseSchema = z.object({
+  description: z.string(),
+  schema: z.any().optional(),
+});
+
 const RouteEntrySchema = z.object({
   method: z.string(),
   /** Endpoint path relative to /v1/ (e.g. "conversations/:id"). */
@@ -70,8 +81,14 @@ const RouteEntrySchema = z.object({
   queryParams: z.array(RouteQueryParamSchema).optional(),
   /** JSON Schema for the request body. */
   requestBody: RouteBodySchemaSchema.optional(),
+  /** Multi-content-type request body variants (overrides `requestBody` when present). */
+  requestBodies: z.array(RouteRequestBodyVariantSchema).optional(),
   /** JSON Schema for the 200 response body. */
   responseBody: RouteBodySchemaSchema.optional(),
+  /** Extra non-200 responses documented in the spec. */
+  additionalResponses: z
+    .record(z.string(), RouteAdditionalResponseSchema)
+    .optional(),
   /** Source module filename, used for auto-deriving tags. */
   sourceModule: z.string().optional(),
 });
@@ -298,21 +315,13 @@ interface OpenApiOperation {
   parameters?: OpenApiParameter[];
   requestBody?: {
     required: boolean;
-    content: {
-      "application/json": {
-        schema: JSONSchemaObject;
-      };
-    };
+    content: Record<string, { schema: JSONSchemaObject }>;
   };
   responses: Record<
     string,
     {
       description: string;
-      content?: {
-        "application/json": {
-          schema: JSONSchemaObject;
-        };
-      };
+      content?: Record<string, { schema: JSONSchemaObject }>;
     }
   >;
 }
@@ -446,7 +455,19 @@ function buildSpec(
       operation.parameters = parameters;
     }
 
-    if (entry.requestBody) {
+    // Multi-content-type request bodies take precedence over the single
+    // application/json requestBody. This lets an endpoint advertise a
+    // `oneOf`-style choice between `application/octet-stream`,
+    // `multipart/form-data`, and `application/json` on the same URL.
+    if (entry.requestBodies && entry.requestBodies.length > 0) {
+      const content: Record<string, { schema: JSONSchemaObject }> = {};
+      for (const variant of entry.requestBodies) {
+        content[variant.contentType] = {
+          schema: toJSONSchemaObject(variant.schema),
+        };
+      }
+      operation.requestBody = { required: true, content };
+    } else if (entry.requestBody) {
       operation.requestBody = {
         required: true,
         content: {
@@ -457,6 +478,24 @@ function buildSpec(
       };
     }
 
+    // Extra documented response variants (e.g. 502 fetch_failed).
+    if (entry.additionalResponses) {
+      for (const [status, resp] of Object.entries(entry.additionalResponses)) {
+        operation.responses[status] = {
+          description: resp.description,
+          ...(resp.schema
+            ? {
+                content: {
+                  "application/json": {
+                    schema: toJSONSchemaObject(resp.schema),
+                  },
+                },
+              }
+            : {}),
+        };
+      }
+    }
+
     paths[route.path][methodLower] = operation;
   }
 

package/src/__tests__/agent-loop-callsite-precedence.test.ts

@@ -0,0 +1,318 @@
+/**
+ * Verifies the field-precedence contract for `AgentLoop.run(..., callSite)`.
+ *
+ * When `callSite` is set, the loop must NOT pre-set the
+ * `max_tokens`/`thinking`/`effort`/`speed` fields from `this.config`
+ * (sourced from `llm.default`) because the downstream
+ * `RetryProvider.normalizeSendMessageOptions` only fills these fields when
+ * they're undefined. If the loop pre-sets them, every per-call-site override
+ * for these knobs is silently ignored.
+ *
+ * Precedence (highest wins):
+ *   1. Per-turn explicit (from `resolveSystemPrompt`'s
+ *      `resolved.maxTokens` / `resolved.model`)
+ *   2. Call-site resolved values (from `resolveCallSiteConfig` via the
+ *      normalizer)
+ *   3. Conversation defaults (`this.config.*`, from `llm.default`)
+ *
+ * The tests pipe the loop's per-call options through `RetryProvider` so we
+ * can observe the final, post-resolution config that downstream provider
+ * clients consume.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let mockLlmConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ llm: mockLlmConfig }),
+}));
+
+import type { ResolvedSystemPrompt } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { RetryProvider } from "../providers/retry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../providers/types.js";
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "hi" }],
+};
+
+function setLlmConfig(raw: unknown): void {
+  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+});
+
+/**
+ * Build a provider that captures the final `config` it receives. Wrap it in
+ * `RetryProvider` so the call-site resolver runs over whatever the agent loop
+ * emits — exactly mirroring production wiring.
+ */
+function makePipeline(providerName: string): {
+  provider: Provider;
+  lastConfig: () => Record<string, unknown> | undefined;
+} {
+  let captured: Record<string, unknown> | undefined;
+  const inner: Provider = {
+    name: providerName,
+    async sendMessage(
+      _messages: Message[],
+      _tools?: ToolDefinition[],
+      _systemPrompt?: string,
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      captured = options?.config as Record<string, unknown> | undefined;
+      return {
+        content: [{ type: "text", text: "ok" }],
+        model: "mock-model",
+        usage: { inputTokens: 1, outputTokens: 1 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return {
+    provider: new RetryProvider(inner),
+    lastConfig: () => captured,
+  };
+}
+
+describe("AgentLoop — call-site precedence", () => {
+  test("call-site maxTokens wins over conversation default when callSite is set", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        maxTokens: 64000,
+      },
+      callSites: { mainAgent: { maxTokens: 4096 } },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const loop = new AgentLoop(provider, "system", { maxTokens: 64000 });
+
+    await loop.run(
+      [userMessage],
+      () => {},
+      undefined,
+      undefined,
+      undefined,
+      "mainAgent",
+    );
+
+    expect(lastConfig()!.max_tokens).toBe(4096);
+  });
+
+  test("call-site effort wins over conversation default when callSite is set", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        effort: "high",
+      },
+      callSites: { mainAgent: { effort: "low" } },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const loop = new AgentLoop(provider, "system", {
+      maxTokens: 64000,
+      effort: "high",
+    });
+
+    await loop.run(
+      [userMessage],
+      () => {},
+      undefined,
+      undefined,
+      undefined,
+      "mainAgent",
+    );
+
+    expect(lastConfig()!.effort).toBe("low");
+  });
+
+  test("call-site speed wins over conversation default when callSite is set", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        speed: "standard",
+      },
+      callSites: { mainAgent: { speed: "fast" } },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const loop = new AgentLoop(provider, "system", {
+      maxTokens: 64000,
+      effort: "high",
+      // Conversation default is "fast" (which would normally be applied) —
+      // ensure the call-site value is the one that ends up on the wire.
+      speed: "fast",
+    });
+
+    await loop.run(
+      [userMessage],
+      () => {},
+      undefined,
+      undefined,
+      undefined,
+      "mainAgent",
+    );
+
+    expect(lastConfig()!.speed).toBe("fast");
+  });
+
+  test("call-site thinking wins over conversation default when callSite is set", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        // Default thinking enabled.
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: {
+        // Call site disables thinking — must be honoured even though the
+        // conversation default has it on.
+        mainAgent: { thinking: { enabled: false } },
+      },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const loop = new AgentLoop(provider, "system", {
+      maxTokens: 64000,
+      // Conversation default also has thinking on — without the fix, this
+      // would pre-set `thinking: { type: "adaptive" }` and mask the
+      // call-site override.
+      thinking: { enabled: true },
+    });
+
+    await loop.run(
+      [userMessage],
+      () => {},
+      undefined,
+      undefined,
+      undefined,
+      "mainAgent",
+    );
+
+    // Call-site override resolves `thinking.enabled: false`, so the
+    // RetryProvider normalizer must omit `thinking` entirely (matching the
+    // legacy non-callSite path which only sets `providerConfig.thinking`
+    // when enabled). Without the fix at agent/loop.ts, the conversation
+    // default's `thinking: { type: "adaptive" }` would be pre-set and mask
+    // the call-site override.
+    expect(lastConfig()!.thinking).toBeUndefined();
+  });
+
+  test("call-site thinking is converted to Anthropic wire-format when enabled", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        thinking: { enabled: true, streamThinking: true },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const loop = new AgentLoop(provider, "system", { maxTokens: 64000 });
+
+    await loop.run(
+      [userMessage],
+      () => {},
+      undefined,
+      undefined,
+      undefined,
+      "mainAgent",
+    );
+
+    // Must be wire-format `{ type: "adaptive" }` so the Anthropic SDK's
+    // `ThinkingConfigParam` accepts it. The schema-shape `{ enabled,
+    // streamThinking }` would be a runtime API error.
+    expect(lastConfig()!.thinking).toEqual({ type: "adaptive" });
+  });
+
+  test("conversation defaults still apply when callSite is absent", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        // Resolver values that would *normally* be filled — but we don't
+        // pass a callSite, so they must not surface.
+        maxTokens: 999,
+        effort: "low",
+      },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const loop = new AgentLoop(provider, "system", {
+      maxTokens: 64000,
+      effort: "high",
+      speed: "fast",
+      thinking: { enabled: true },
+    });
+
+    await loop.run([userMessage], () => {}, undefined, undefined, undefined);
+
+    const config = lastConfig()!;
+    expect(config.max_tokens).toBe(64000);
+    expect(config.effort).toBe("high");
+    expect(config.speed).toBe("fast");
+    // No callSite → loop sets the wire-format thinking directly.
+    expect(config.thinking).toEqual({ type: "adaptive" });
+  });
+
+  test("per-turn resolveSystemPrompt.maxTokens wins over both call-site and default", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-default",
+        maxTokens: 64000,
+      },
+      callSites: { mainAgent: { maxTokens: 4096 } },
+    });
+
+    const { provider, lastConfig } = makePipeline("anthropic");
+    const resolveSystemPrompt = (): ResolvedSystemPrompt => ({
+      systemPrompt: "per-turn system",
+      maxTokens: 8192,
+    });
+
+    const loop = new AgentLoop(
+      provider,
+      "system",
+      { maxTokens: 64000 },
+      [],
+      undefined,
+      undefined,
+      resolveSystemPrompt,
+    );
+
+    await loop.run(
+      [userMessage],
+      () => {},
+      undefined,
+      undefined,
+      undefined,
+      "mainAgent",
+    );
+
+    // Per-turn explicit value beats both the call-site (4096) and the
+    // default (64000).
+    expect(lastConfig()!.max_tokens).toBe(8192);
+  });
+});