@vellumai/assistant 0.12.6 → 0.12.7-staging.1

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.12.6
+  version: 0.12.7
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -4849,6 +4849,7 @@ paths:
                       - a2a
                       - discord
                       - plugin
+                      - vellum-shared
                   assistantId:
                     type: string
                   hasPendingChallenge:
@@ -5279,6 +5280,7 @@ paths:
                             - a2a
                             - discord
                             - plugin
+                            - vellum-shared
                         ready:
                           type: boolean
                         setupStatus:
@@ -5403,6 +5405,7 @@ paths:
                     - a2a
                     - discord
                     - plugin
+                    - vellum-shared
                 includeRemote:
                   description: Include remote checks (default true)
                   type: boolean
@@ -5434,6 +5437,7 @@ paths:
                             - a2a
                             - discord
                             - plugin
+                            - vellum-shared
                         ready:
                           type: boolean
                         setupStatus:
@@ -5567,6 +5571,7 @@ paths:
                     - a2a
                     - discord
                     - plugin
+                    - vellum-shared
                   description: Channel to send on
                 target:
                   type: object
@@ -5617,6 +5622,7 @@ paths:
                       - a2a
                       - discord
                       - plugin
+                      - vellum-shared
                   chatId:
                     type: string
                   threadId:
@@ -5835,6 +5841,135 @@ paths:
                 required:
                   - recorded
                 additionalProperties: false
+  /v1/composer/settings:
+    get:
+      operationId: composer_settings_get
+      summary: Get the current user's composer preferences
+      tags:
+        - settings
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  preferences:
+                    type: object
+                    properties:
+                      favoriteModeIds:
+                        default: []
+                        maxItems: 5
+                        type: array
+                        items:
+                          type: string
+                          minLength: 1
+                          maxLength: 200
+                      lastModeId:
+                        default: null
+                        anyOf:
+                          - type: string
+                            minLength: 1
+                            maxLength: 200
+                          - type: "null"
+                      lastAutonomy:
+                        default: null
+                        anyOf:
+                          - type: string
+                            enum:
+                              - none
+                              - low
+                              - medium
+                              - high
+                          - type: "null"
+                    required:
+                      - favoriteModeIds
+                      - lastModeId
+                      - lastAutonomy
+                    additionalProperties: false
+                required:
+                  - preferences
+                additionalProperties: false
+    patch:
+      operationId: composer_settings_patch
+      summary: Update the current user's composer preferences
+      tags:
+        - settings
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                favoriteModeIds:
+                  maxItems: 5
+                  type: array
+                  items:
+                    type: string
+                    minLength: 1
+                    maxLength: 200
+                lastModeId:
+                  anyOf:
+                    - type: string
+                      minLength: 1
+                      maxLength: 200
+                    - type: "null"
+                lastAutonomy:
+                  anyOf:
+                    - type: string
+                      enum:
+                        - none
+                        - low
+                        - medium
+                        - high
+                    - type: "null"
+              additionalProperties: false
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  preferences:
+                    type: object
+                    properties:
+                      favoriteModeIds:
+                        default: []
+                        maxItems: 5
+                        type: array
+                        items:
+                          type: string
+                          minLength: 1
+                          maxLength: 200
+                      lastModeId:
+                        default: null
+                        anyOf:
+                          - type: string
+                            minLength: 1
+                            maxLength: 200
+                          - type: "null"
+                      lastAutonomy:
+                        default: null
+                        anyOf:
+                          - type: string
+                            enum:
+                              - none
+                              - low
+                              - medium
+                              - high
+                          - type: "null"
+                    required:
+                      - favoriteModeIds
+                      - lastModeId
+                      - lastAutonomy
+                    additionalProperties: false
+                required:
+                  - preferences
+                additionalProperties: false
   /v1/config:
     get:
       operationId: config_get
@@ -6025,6 +6160,7 @@ paths:
                     - minimax
                     - atlascloud
                     - baseten
+                    - ionet
                     - poolside
                 connectionName:
                   type: string
@@ -8073,6 +8209,7 @@ paths:
               - a2a
               - discord
               - plugin
+              - vellum-shared
           description:
             Filter by origin channel. When provided, only conversations with this exact origin_channel value are
             returned. Omit to include all channels.
@@ -8237,6 +8374,7 @@ paths:
                                 - a2a
                                 - discord
                                 - plugin
+                                - vellum-shared
                             - type: "null"
                         assistantAttention:
                           type: object
@@ -8607,6 +8745,7 @@ paths:
                               - a2a
                               - discord
                               - plugin
+                              - vellum-shared
                           - type: "null"
                       assistantAttention:
                         type: object
@@ -9821,6 +9960,7 @@ paths:
                               - a2a
                               - discord
                               - plugin
+                              - vellum-shared
                           - type: "null"
                       assistantAttention:
                         type: object
@@ -14470,6 +14610,8 @@ paths:
                         type: boolean
                       chatsSettings:
                         type: boolean
+                      composerSettings:
+                        type: boolean
                     required:
                       - memoryOptOut
                       - retryLastTurn
@@ -14706,6 +14848,8 @@ paths:
                         type: boolean
                       chatsSettings:
                         type: boolean
+                      composerSettings:
+                        type: boolean
                     required:
                       - memoryOptOut
                       - retryLastTurn
@@ -16973,8 +17117,8 @@ paths:
             type: string
           description:
             "Filter by provider id. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
-            vellum"
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, ionet, poolside,
+            typesafe, vellum"
       responses:
         "200":
           description: Successful response
@@ -17246,8 +17390,8 @@ paths:
             type: string
           description:
             "Filter by provider. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
-            vellum, chatgpt"
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, ionet, poolside,
+            typesafe, vellum, chatgpt"
       responses:
         "200":
           description: Successful response
@@ -25225,6 +25369,7 @@ paths:
                     - a2a
                     - discord
                     - plugin
+                    - vellum-shared
                     - scheduler
                     - watcher
                 sourceContextId:
@@ -39425,6 +39570,7 @@ components:
         - minimax
         - atlascloud
         - baseten
+        - ionet
         - poolside
         - typesafe
         - vellum
@@ -39689,6 +39835,7 @@ components:
                     - minimax
                     - atlascloud
                     - baseten
+                    - ionet
                     - poolside
                 connectionName:
                   type: string
@@ -40077,6 +40224,7 @@ components:
                 - minimax
                 - atlascloud
                 - baseten
+                - ionet
                 - poolside
             - type: "null"
         connectionName:

package/package.json

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

package/src/__tests__/channel-policy.test.ts

@@ -16,6 +16,7 @@ import {
   isNotificationDeliverable,
 } from "../channels/config.js";
 import { CHANNEL_IDS, type ChannelId } from "../channels/types.js";
+import { getTransportForChannel } from "../messaging/providers/index.js";
 
 describe("channel policy registry", () => {
   // ── Exhaustiveness ────────────────────────────────────────────────────
@@ -133,6 +134,12 @@ describe("channel policy registry", () => {
     expect(getConversationStrategy("phone")).toBe("not_deliverable");
   });
 
+  test("vellum-shared has no transport and receives no notifications", () => {
+    expect(isNotificationDeliverable("vellum-shared")).toBe(false);
+    expect(getConversationStrategy("vellum-shared")).toBe("not_deliverable");
+    expect(getTransportForChannel("vellum-shared")).toBeUndefined();
+  });
+
   test("deliverable channels include vellum and telegram", () => {
     const deliverable = getDeliverableChannels();
     expect(deliverable).toContain("vellum");

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -1,11 +1,18 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 
 import { createAssistantMessage } from "../agent/message-types.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { EnqueueMessageOptions } from "../daemon/conversation-messaging.js";
 import { persistUserMessage } from "../daemon/conversation-messaging.js";
+import * as gatewayClient from "../ipc/gateway-client.js";
 import {
   addMessage,
   findMessageIdByClientMessageId,
@@ -18,11 +25,16 @@ import {
   syncMessageToDisk,
 } from "../persistence/conversation-disk-view.js";
 import {
+  _resetFirstConversationSeenForTesting,
   getConversationByKey,
   getOrCreateConversation as getOrCreateConversationMapping,
 } from "../persistence/conversation-key-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import {
+  conversationKeys,
+  conversations,
+} from "../persistence/schema/index.js";
 import {
   AssistantEventHub,
   assistantEventHub,
@@ -30,6 +42,7 @@ import {
 import type { AuthContext } from "../runtime/auth/types.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import { callHandler } from "./helpers/call-route-handler.js";
 import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
@@ -541,6 +554,132 @@ describe("POST /v1/messages — body.conversationId direct id lookup", () => {
     );
   }
 
+  test.each(["unavailable", "rejected"])(
+    "an autonomy write that is %s rolls back a minted chat before retry",
+    async (failure) => {
+      _resetFirstConversationSeenForTesting();
+      const bootstrapFiles = ["BOOTSTRAP.md", "BOOTSTRAP-REFERENCE.md"].map(
+        (name) => join(testDir, name),
+      );
+      for (const path of bootstrapFiles) {
+        writeFileSync(path, "Onboarding instructions");
+      }
+      const ipc = spyOn(gatewayClient, "ipcCall");
+      if (failure === "unavailable") {
+        ipc.mockResolvedValueOnce(undefined);
+      } else {
+        ipc.mockRejectedValueOnce(new Error("Gateway unavailable"));
+      }
+      const body = {
+        content: "Start a new chat",
+        sourceChannel: "vellum",
+        interface: "macos",
+        riskThreshold: "none",
+      };
+      try {
+        if (failure === "rejected") {
+          await expect(sendMessage(body)).rejects.toThrow(
+            "Gateway unavailable",
+          );
+        } else {
+          const failed = await sendMessage(body);
+          expect(failed.status).toBe(500);
+        }
+        expect(getDb().select().from(conversations).all()).toHaveLength(0);
+        expect(getDb().select().from(conversationKeys).all()).toHaveLength(0);
+        expect(conversationInstances.size).toBe(0);
+        expect(bootstrapFiles.every((path) => existsSync(path))).toBe(true);
+
+        ipc.mockResolvedValueOnce({ ok: true });
+        const retried = await sendMessage(body);
+        expect(retried.status).toBe(202);
+        const rows = getDb().select().from(conversations).all();
+        expect(rows).toHaveLength(1);
+        expect(getDb().select().from(conversationKeys).all()).toHaveLength(1);
+        await waitFor(() => {
+          const messages = readPersistedMessages(rows[0]!.id);
+          return messages.length === 2 ? messages : undefined;
+        });
+        expect(bootstrapFiles.every((path) => existsSync(path))).toBe(true);
+        getOrCreateConversationMapping("second-successful-chat");
+        expect(bootstrapFiles.some((path) => existsSync(path))).toBe(false);
+      } finally {
+        ipc.mockRestore();
+        for (const path of bootstrapFiles) {
+          assertNotLiveDb(path);
+          rmSync(path, { force: true });
+        }
+      }
+    },
+  );
+
+  test("an autonomy write failure preserves an existing chat and its messages", async () => {
+    const seeded = getOrCreateConversationMapping("existing-chat");
+    await addMessage(seeded.conversationId, "user", "Existing message");
+    const ipc = spyOn(gatewayClient, "ipcCall").mockResolvedValueOnce(
+      undefined,
+    );
+    try {
+      const response = await sendMessage({
+        conversationId: seeded.conversationId,
+        content: "Continue this chat",
+        sourceChannel: "vellum",
+        interface: "macos",
+        riskThreshold: "none",
+      });
+      expect(response.status).toBe(500);
+      expect(getConversation(seeded.conversationId)).not.toBeNull();
+      expect(readPersistedMessages(seeded.conversationId)).toHaveLength(1);
+    } finally {
+      ipc.mockRestore();
+    }
+  });
+
+  test("a minted chat with a concurrent message survives an autonomy write failure", async () => {
+    const ipc = spyOn(gatewayClient, "ipcCall").mockImplementationOnce(
+      async () => {
+        const row = getDb().select().from(conversations).all()[0]!;
+        await addMessage(row.id, "user", "Concurrent message");
+        return undefined;
+      },
+    );
+    try {
+      const response = await sendMessage({
+        content: "Start a new chat",
+        sourceChannel: "vellum",
+        interface: "macos",
+        riskThreshold: "none",
+      });
+      expect(response.status).toBe(500);
+      const rows = getDb().select().from(conversations).all();
+      expect(rows).toHaveLength(1);
+      expect(readPersistedMessages(rows[0]!.id)).toHaveLength(1);
+    } finally {
+      ipc.mockRestore();
+    }
+  });
+
+  test("an autonomy write failure preserves a keyed chat for retry or concurrent senders", async () => {
+    const ipc = spyOn(gatewayClient, "ipcCall").mockResolvedValueOnce(
+      undefined,
+    );
+    try {
+      const response = await sendMessage({
+        conversationKey: "shared-chat-key",
+        content: "Send to a keyed chat",
+        sourceChannel: "vellum",
+        interface: "macos",
+        riskThreshold: "none",
+      });
+      expect(response.status).toBe(500);
+      const mapping = getConversationByKey("shared-chat-key");
+      expect(mapping).not.toBeNull();
+      expect(getConversation(mapping!.conversationId)).not.toBeNull();
+    } finally {
+      ipc.mockRestore();
+    }
+  });
+
   test("body.conversationId=<existing-id> scopes the send to that conversation", async () => {
     // Pre-materialise a conversation via the key path, then send a message
     // by its assistant-minted internal id.

package/src/__tests__/identity-routes.test.ts

@@ -167,6 +167,7 @@ describe("identity routes — health endpoint", () => {
         retryLastTurn: true,
         appPins: true,
         chatsSettings: true,
+        composerSettings: true,
       });
 
       // Profiler should either be absent or show enabled: false

package/src/__tests__/list-messages-client-message-id.test.ts

@@ -8,6 +8,7 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { MESSAGE_KEYS } from "../i18n/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Keep the memory system off so addMessage skips indexing side effects.
@@ -31,6 +32,7 @@ function resetTables() {
 
 interface MessagePayload {
   role: string;
+  textSegments?: string[];
   clientMessageId?: string;
 }
 
@@ -59,6 +61,47 @@ describe("handleListMessages clientMessageId", () => {
     expect(body.messages[0].clientMessageId).toBe("nonce-abc");
   });
 
+  test("localizes persisted assistant keys without rewriting legacy text", async () => {
+    const localizedConv = createConversation();
+    await addMessage(
+      localizedConv.id,
+      "assistant",
+      JSON.stringify([
+        {
+          type: "text",
+          text: MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
+        },
+      ]),
+      { skipIndexing: true },
+    );
+
+    const localizedResponse = await handleListMessages({
+      queryParams: { conversationId: localizedConv.id },
+      headers: { "accept-language": "es" },
+    });
+    const localizedBody = localizedResponse as { messages: MessagePayload[] };
+    expect(localizedBody.messages[0]?.textSegments).toEqual([
+      "Me detuve después de varias llamadas de herramienta con formato incorrecto para evitar que esta conversación creciera indefinidamente. Inténtalo de nuevo o cambia de modelo si el problema continúa.",
+    ]);
+
+    const legacyConv = createConversation();
+    const legacy =
+      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.";
+    await addMessage(
+      legacyConv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: legacy }]),
+      { skipIndexing: true },
+    );
+
+    const legacyResponse = await handleListMessages({
+      queryParams: { conversationId: legacyConv.id },
+      headers: { "accept-language": "es" },
+    });
+    const legacyBody = legacyResponse as { messages: MessagePayload[] };
+    expect(legacyBody.messages[0]?.textSegments).toEqual([legacy]);
+  });
+
   test("omits clientMessageId when the row was persisted without one", async () => {
     // GIVEN a user message persisted without a client nonce (e.g. a channel send)
     const conv = createConversation();

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

@@ -1178,6 +1178,33 @@ describe("OpenAIProvider", () => {
     });
   });
 
+  test("bounds malformed arguments in the diagnostic raw response only", async () => {
+    const raw = '{"content":"' + "x".repeat(1_000);
+    fakeChunks = [
+      ...toolCallChunks([{ id: "call_large_bad", name: "test", args: raw }]),
+      usageChunk(10, 5),
+    ];
+
+    const result = await provider.sendMessage([userMsg("test")]);
+
+    expect(result.content[0]).toEqual({
+      type: "tool_use",
+      id: "call_large_bad",
+      name: "test",
+      input: { _raw: raw },
+    });
+    const rawResponse = result.rawResponse as {
+      choices: Array<{
+        message: {
+          tool_calls: Array<{ function: { arguments: string } }>;
+        };
+      }>;
+    };
+    expect(
+      rawResponse.choices[0]!.message.tool_calls[0]!.function.arguments,
+    ).toBe(raw.slice(0, 200) + "…");
+  });
+
   // -----------------------------------------------------------------------
   // stream_options and model
   // -----------------------------------------------------------------------

package/src/__tests__/skill-execute-input.test.ts

@@ -188,6 +188,17 @@ describe("recoverSkillExecuteEnvelope", () => {
     expect(recoverSkillExecuteEnvelope(wrapped)).toBe(wrapped);
   });
 
+  test("keeps recovered JSON wrapped when it lacks a string tool name", () => {
+    for (const raw of [
+      JSON.stringify({ input: { content: "hi" }, activity: "x" }),
+      JSON.stringify({ tool: 42, input: {}, activity: "x" }),
+      JSON.stringify(["document_update"]),
+    ]) {
+      const wrapped = { _raw: raw };
+      expect(recoverSkillExecuteEnvelope(wrapped)).toBe(wrapped);
+    }
+  });
+
   test("passes a normal envelope through untouched", () => {
     const envelope = {
       tool: "document_update",

package/src/__tests__/tool-approval-handler.test.ts

@@ -1357,6 +1357,10 @@ describe("ToolApprovalHandler / unparseable tool args gate", () => {
     }
     expect(result.result.content).not.toContain(raw);
     expect(result.result.content).toContain("…");
+    expect(auditCalls.error).toHaveLength(1);
+    expect(auditCalls.error[0].input).toEqual({
+      _raw: raw.slice(0, 200) + "…",
+    });
   });
 
   test("legitimate input containing a _raw field among others is not rejected", async () => {

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -341,6 +341,32 @@ describe("tool preview lifecycle", () => {
       expect((emitted as any).conversationId).toBe("test-session-id");
     });
 
+    test("caps cumulative app preview payloads and stops forwarding growth", () => {
+      const collector = createEventCollector();
+      const deps = createMockDeps({ onEvent: collector.onEvent });
+      const accumulatedJson = '{"code":"' + "x".repeat(300_000);
+
+      handleInputJsonDelta(state, deps, {
+        type: "input_json_delta",
+        toolName: "app_create",
+        toolUseId: "toolu_large_app",
+        accumulatedJson,
+      });
+      handleInputJsonDelta(state, deps, {
+        type: "input_json_delta",
+        toolName: "app_create",
+        toolUseId: "toolu_large_app",
+        accumulatedJson: accumulatedJson + "more",
+      });
+
+      expect(collector.events).toHaveLength(1);
+      const emitted = collector.events[0] as Extract<
+        AssistantEvent,
+        { type: "tool_input_delta" }
+      >;
+      expect(emitted.content).toBe(accumulatedJson.slice(0, 256_000));
+    });
+
     test("a streaming ui_show visual announces its surface exactly once", () => {
       const collector = createEventCollector();
       const deps = createMockDeps({ onEvent: collector.onEvent });