@vellumai/assistant 0.11.1-dev.202608032034.aebd2da → 0.11.1-dev.202608032226.351a4e2

package/openapi.yaml

@@ -21436,6 +21436,7 @@ paths:
                   minLength: 1
                   description: Feed item id (notif:<uuid>) or bare uuid
                 title:
+                  description: New title. An empty value is ignored, never cleared.
                   type: string
                 body:
                   type: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608032034.aebd2da",
+  "version": "0.11.1-dev.202608032226.351a4e2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-resume-interrupted.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Cover for the loop's interrupted-call recovery.
+ *
+ * The reported failure: the model runs several tools, the next call streams for
+ * a while and then dies (the upstream killed a generation that blew its decode
+ * deadline), and the loop surfaces the error and ends the turn — leaving the
+ * task half-done until the user types "continue". These tests assert the loop
+ * now carries on by itself, and that it still stops when carrying on would be
+ * pointless.
+ *
+ * The recovery is built into {@link AgentLoop}, not contributed by a plugin, so
+ * these run it as the loop's own behavior. The default plugin stack is
+ * registered because the loop fires hook chains during a turn regardless.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
+
+const tools: ToolDefinition[] = [
+  {
+    name: "read_file",
+    description: "Read a file",
+    input_schema: { type: "object", properties: { path: { type: "string" } } },
+  },
+];
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "finish the course page" }],
+};
+
+/** The rejection from the reported turn, thrown from inside a live stream. */
+function midStreamRejection(): ProviderError {
+  return new ProviderError(
+    "OpenAI-compatible API error (unknown status): litellm.MidStreamFallbackError: " +
+      "litellm.APIConnectionError: OpenAIException - Decode wall clock timeout after 600s",
+    "openai-compatible",
+  );
+}
+
+/** A scripted turn: return a response, or stream `thinking` and then throw. */
+type Turn =
+  | { kind: "reply"; response: ProviderResponse }
+  | { kind: "interrupt"; thinking: string }
+  | { kind: "refuse" };
+
+function scriptedProvider(turns: Turn[]): {
+  provider: Provider;
+  callCount: () => number;
+} {
+  let index = 0;
+  const provider: Provider = {
+    name: "openai-compatible",
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      const turn = turns[Math.min(index, turns.length - 1)]!;
+      index++;
+      if (turn.kind === "refuse") {
+        // Rejected before generating: nothing ever streams.
+        throw midStreamRejection();
+      }
+      if (turn.kind === "interrupt") {
+        options?.onEvent?.({ type: "thinking_delta", thinking: turn.thinking });
+        throw midStreamRejection();
+      }
+      for (const block of turn.response.content) {
+        if (block.type === "text") {
+          options?.onEvent?.({ type: "text_delta", text: block.text });
+        }
+      }
+      return turn.response;
+    },
+  };
+  return { provider, callCount: () => index };
+}
+
+function reply(text: string): Turn {
+  return {
+    kind: "reply",
+    response: {
+      content: [{ type: "text", text }],
+      model: "glm-5.2",
+      usage: { inputTokens: 10, outputTokens: 5 },
+      stopReason: "end_turn",
+    },
+  };
+}
+
+function callsTool(id: string): Turn {
+  return {
+    kind: "reply",
+    response: {
+      content: [
+        { type: "tool_use", id, name: "read_file", input: { path: "app.js" } },
+      ],
+      model: "glm-5.2",
+      usage: { inputTokens: 10, outputTokens: 5 },
+      stopReason: "tool_use",
+    },
+  };
+}
+
+function runLoop(provider: Provider, callSite: LLMCallSite = "mainAgent") {
+  const events: AgentEvent[] = [];
+  const loop = new AgentLoop({
+    provider,
+    systemPrompt: "system",
+    conversationId: "conv-resume-e2e",
+    tools,
+    toolExecutor: async () => ({ content: "file data", isError: false }),
+  });
+  return loop
+    .run({
+      requestId: "req-resume-e2e",
+      messages: [userMessage],
+      callSite,
+      onEvent: (event) => {
+        events.push(event);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    })
+    .then((result) => ({ ...result, events }));
+}
+
+function assistantTextOf(history: Message[]): string {
+  return history
+    .filter((message) => message.role === "assistant")
+    .flatMap((message) => message.content)
+    .map((block) => (block.type === "text" ? block.text : ""))
+    .join("");
+}
+
+describe("AgentLoop — a call interrupted mid-generation", () => {
+  beforeEach(() => {
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("carries on instead of ending the turn", async () => {
+    const { provider, callCount } = scriptedProvider([
+      callsTool("call-1"),
+      { kind: "interrupt", thinking: "Now I need to understand the layout" },
+      reply("Done — the page is wired up."),
+    ]);
+
+    const { history, events } = await runLoop(provider);
+
+    // The turn finished on its own: tool call, interrupted call, resumed call.
+    expect(callCount()).toBe(3);
+    expect(assistantTextOf(history)).toContain("Done — the page is wired up.");
+    expect(events.filter((event) => event.type === "error")).toHaveLength(0);
+  });
+
+  test("keeps the tool work the interrupted turn had already done", async () => {
+    const { provider } = scriptedProvider([
+      callsTool("call-1"),
+      { kind: "interrupt", thinking: "reading the file" },
+      reply("Summary of the file."),
+    ]);
+
+    const { history } = await runLoop(provider);
+
+    // The resumed call re-sends the same history, so the completed tool call
+    // and its result are still there rather than being replayed or dropped.
+    const toolUses = history
+      .flatMap((message) => message.content)
+      .filter((block) => block.type === "tool_use");
+    const toolResults = history
+      .flatMap((message) => message.content)
+      .filter((block) => block.type === "tool_result");
+    expect(toolUses).toHaveLength(1);
+    expect(toolResults).toHaveLength(1);
+  });
+
+  test("surfaces the error when the resumed call is interrupted too", async () => {
+    const { provider, callCount } = scriptedProvider([
+      { kind: "interrupt", thinking: "starting" },
+    ]);
+
+    const { events } = await runLoop(provider);
+
+    // One resume, then the error stands rather than looping.
+    expect(callCount()).toBe(2);
+    expect(events.filter((event) => event.type === "error")).toHaveLength(1);
+  });
+
+  test("does not resume a background call site", async () => {
+    // A compaction, subagent, or other background call answers to a caller
+    // that owns its own failure handling; nobody is sitting there to type
+    // "continue" at it.
+    const { provider, callCount } = scriptedProvider([
+      { kind: "interrupt", thinking: "summarizing" },
+    ]);
+
+    await runLoop(provider, "compactionAgent");
+
+    expect(callCount()).toBe(1);
+  });
+
+  test("does not resume a request the provider refused outright", async () => {
+    // Nothing streamed, so re-sending the identical request would fail the same
+    // way; the error surfaces on the first rejection.
+    const { provider, callCount } = scriptedProvider([{ kind: "refuse" }]);
+
+    const { events } = await runLoop(provider);
+
+    expect(callCount()).toBe(1);
+    expect(events.filter((event) => event.type === "error")).toHaveLength(1);
+  });
+});

package/src/__tests__/conversation-agent-loop.test.ts

@@ -3022,12 +3022,20 @@ describe("session-agent-loop", () => {
       }));
 
       // GIVEN a real loop whose provider streams a delta — landing a debounced
-      // partial flush on the reserved row — then rejects, so the loop emits
-      // `provider_error` and `error` and exits with no `message_complete`.
+      // partial flush on the reserved row — then rejects. The loop resumes a
+      // call that died after it had started streaming, so the second attempt
+      // is scripted to fail before streaming anything: that keeps exactly one
+      // row carrying partial content, and the turn then exits via
+      // `provider_error` with no `message_complete`.
+      let attempt = 0;
       const ctx = makeCtx({
         loopProvider: {
           name: "mock-provider",
           async sendMessage(_messages, options) {
+            attempt++;
+            if (attempt > 1) {
+              throw new Error("upstream 500");
+            }
             options?.onEvent?.({ type: "text_delta", text: "hello world" });
             await new Promise((resolve) => setTimeout(resolve, 1100));
             throw new Error("upstream 500");
@@ -3051,11 +3059,12 @@ describe("session-agent-loop", () => {
         .split("\n");
       expect(orphanLines).toHaveLength(1);
       expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
-      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
-      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
-        string,
-      ];
-      expect(deleteCall[0]).toBe("msg-orphan-with-partial");
+      // Scoped to the row under test: the resumed attempt reserves a row of
+      // its own, which its own cleanup deletes.
+      const deletedIds = deleteMessageByIdMock.mock.calls.map(
+        (call) => (call as unknown as [string])[0],
+      );
+      expect(deletedIds).toContain("msg-orphan-with-partial");
     });
   });
 

package/src/__tests__/conversation-error.test.ts

@@ -170,6 +170,112 @@ describe("classifyConversationError", () => {
       expect(result.userMessage).toContain("AI provider");
       expect(result.errorCategory).toBe("rate_limit");
     });
+
+    it("uses the ChatGPT OAuth route instead of the OpenAI registry default", () => {
+      providerRoutingSources.openai = "managed-proxy";
+      const err = new ProviderError(
+        "OpenAI API error (429): Too many requests",
+        "openai",
+        429,
+        { reason: "rate_limited" },
+      );
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "chatgpt-subscription",
+        isManagedRoute: false,
+      });
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.userMessage).toContain("AI provider");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
+
+    it("prefers the failed call's direct route over stale managed turn attribution", () => {
+      providerRoutingSources.openai = "managed-proxy";
+      const err = new ProviderError(
+        "OpenAI API error (429): Too many requests",
+        "openai",
+        429,
+        { reason: "rate_limited" },
+      );
+      err.attachRouteAttribution({
+        connectionName: "chatgpt-subscription",
+        profileName: "chatgpt",
+        isManagedRoute: false,
+      });
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "vellum",
+        profileName: "managed",
+        isManagedRoute: true,
+      });
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.userMessage).toContain("AI provider");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
+
+    it("prefers the failed call's managed fallback over stale direct turn attribution", () => {
+      const err = new ProviderError(
+        "Anthropic API error (429): Too many requests",
+        "anthropic",
+        429,
+        { reason: "rate_limited" },
+      );
+      err.attachRouteAttribution({
+        profileName: "direct",
+        isManagedRoute: true,
+      });
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "anthropic-key",
+        profileName: "direct",
+        isManagedRoute: false,
+      });
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.userMessage).toContain("Vellum managed inference");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
+
+    it("does not apply a managed LLM route to a plain rate-limit error", () => {
+      const result = classifyConversationError(
+        new Error("429 Too Many Requests from a tool API"),
+        {
+          ...baseCtx,
+          isManagedRoute: true,
+        },
+      );
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
+
+    it("falls back to context for fields the failed call's route omits", () => {
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      err.attachRouteAttribution({ profileName: "direct" });
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "anthropic-key",
+      });
+
+      expect(result.connectionName).toBe("anthropic-key");
+      expect(result.profileName).toBe("direct");
+    });
+
+    it("still recognizes a rewrapped Vellum quota body", () => {
+      const result = classifyConversationError(
+        new Error('429 {"code":"daily_quota_exceeded"}'),
+        baseCtx,
+      );
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
   });
 
   describe("provider overloaded errors", () => {

package/src/__tests__/llm-resolver.test.ts

@@ -6,6 +6,7 @@ import { CODE_DEFAULT_PROFILE_ENTRIES } from "../config/default-profile-catalog.
 import {
   type ResolutionFallbackReason,
   resolveCallSiteConfig,
+  resolveCallSiteConfigWithProfile,
   resolveDefaultProfileKey,
   resolveEffectiveProfileKey,
 } from "../config/llm-resolver.js";
@@ -859,6 +860,21 @@ describe("mix profiles", () => {
     }
   });
 
+  test("config and profile attribution share one mix selection", () => {
+    const selectedArms: string[] = [];
+    const resolved = resolveCallSiteConfigWithProfile("mainAgent", mixLlm, {
+      onMixSelected: ({ chosenProfile }) => {
+        selectedArms.push(chosenProfile);
+      },
+    });
+
+    expect(resolved.profileName).toBe("ab");
+    expect(selectedArms).toHaveLength(1);
+    expect(resolved.config.model).toBe(
+      selectedArms[0] === "a" ? "model-a" : "model-b",
+    );
+  });
+
   test("all dereference spots in a turn agree for the same seed", () => {
     // mainAgent (mix as activeProfile) and a non-main call site resolving the
     // same mix as its call-site profile must pick the same arm when given the

package/src/__tests__/provider-send-message-override-profile.test.ts

@@ -27,6 +27,7 @@ import type {
   ProviderResponse,
   SendMessageOptions,
 } from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
 import { setConfig } from "./helpers/set-config.js";
 
 const DUMMY_MESSAGES: Message[] = [
@@ -239,6 +240,91 @@ describe("SendMessageOptions.config.overrideProfile", () => {
     expect(response.model).toBe("openai");
   });
 
+  test("CallSiteRoutingProvider attributes provider errors to the actual resolved connection", async () => {
+    setLlmConfig({
+      profiles: {
+        fast: {
+          provider: "openai",
+          provider_connection: "openai-conn",
+          model: "gpt-5.4",
+        },
+      },
+    });
+
+    const providerError = new ProviderError(
+      "OpenAI API error (429): Too many requests",
+      "openai",
+      429,
+      { reason: "rate_limited" },
+    );
+    const defaultProvider = makeThrowingProvider(
+      "anthropic",
+      new Error("default provider should not be called"),
+    );
+    const altProvider = makeThrowingProvider("openai", providerError);
+    altProvider.routeAttribution = {
+      connectionName: "openai-recovered",
+      isManagedRoute: false,
+    };
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      async (connectionName) =>
+        connectionName === "openai-conn" ? altProvider : null,
+      { connectionName: "vellum", isManagedRoute: true },
+    );
+
+    await expect(
+      wrapped.sendMessage(DUMMY_MESSAGES, {
+        config: { callSite: "mainAgent", overrideProfile: "fast" },
+      }),
+    ).rejects.toBe(providerError);
+    expect(providerError.routeAttribution).toEqual({
+      connectionName: "openai-recovered",
+      profileName: "fast",
+      isManagedRoute: false,
+    });
+  });
+
+  test("CallSiteRoutingProvider attributes soft fallback errors to the actual default connection", async () => {
+    setLlmConfig({
+      profiles: {
+        fast: {
+          provider: "openai",
+          provider_connection: "openai-conn",
+          model: "gpt-5.4",
+        },
+      },
+    });
+
+    const providerError = new ProviderError(
+      "Anthropic API error (429): Too many requests",
+      "anthropic",
+      429,
+      { reason: "rate_limited" },
+    );
+    const defaultProvider = makeThrowingProvider("anthropic", providerError);
+    defaultProvider.routeAttribution = {
+      connectionName: "anthropic-default",
+      isManagedRoute: false,
+    };
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      async () => null,
+      defaultProvider.routeAttribution,
+    );
+
+    await expect(
+      wrapped.sendMessage(DUMMY_MESSAGES, {
+        config: { callSite: "mainAgent", overrideProfile: "fast" },
+      }),
+    ).rejects.toBe(providerError);
+    expect(providerError.routeAttribution).toEqual({
+      connectionName: "anthropic-default",
+      profileName: "fast",
+      isManagedRoute: false,
+    });
+  });
+
   test("missing overrideProfile name silently falls through to base resolution", async () => {
     setLlmConfig({
       // The call-site tweak applies last in resolution, so it pins the model
@@ -328,6 +414,15 @@ describe("SendMessageOptions.config.overrideProfile", () => {
   });
 });
 
+function makeThrowingProvider(name: string, error: Error): Provider {
+  return {
+    name,
+    async sendMessage(): Promise<ProviderResponse> {
+      throw error;
+    },
+  };
+}
+
 describe("SendMessageOptions.config.forceOverrideProfile", () => {
   test("CallSiteConfiguredProvider forwards forceOverrideProfile into the send config", async () => {
     let captured: SendMessageOptions | undefined;

package/src/__tests__/workspace-migration-137-repair-retired-fireworks-minimax-model-id.test.ts

@@ -47,15 +47,15 @@ afterEach(() => {
 });
 
 describe("137-repair-retired-fireworks-minimax-model-id migration", () => {
-  test("has correct migration id and is registered last", () => {
+  test("has correct migration id and is registered", () => {
     expect(repairRetiredFireworksMinimaxModelIdMigration.id).toBe(
       "137-repair-retired-fireworks-minimax-model-id",
     );
-    // getLastWorkspaceMigrationId() reports the final entry as the registry
-    // ceiling, so the highest id must stay last.
-    expect(WORKSPACE_MIGRATIONS[WORKSPACE_MIGRATIONS.length - 1]?.id).toBe(
-      "137-repair-retired-fireworks-minimax-model-id",
-    );
+    expect(
+      WORKSPACE_MIGRATIONS.some(
+        (m) => m.id === "137-repair-retired-fireworks-minimax-model-id",
+      ),
+    ).toBe(true);
   });
 
   test("repairs the retired ID in default, call sites, and profiles", () => {