@vellumai/assistant 0.10.6-staging.1 → 0.10.6

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.10.5
+  version: 0.10.6
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -13810,9 +13810,8 @@ paths:
       operationId: inference_providerconnections_by_name_delete
       summary: Delete a provider connection
       description:
-        Delete a provider connection. Fails with 400 for managed connections (anthropic-managed, openai-managed,
-        gemini-managed) which are re-seeded on boot. Fails with 409 if any profile or call-site references the
-        connection.
+        Delete a provider connection. Fails with 400 for the Vellum-managed connection (vellum) which is re-seeded
+        on boot. Fails with 409 if any profile or call-site references the connection.
       tags:
         - inference
       parameters:
@@ -13866,8 +13865,8 @@ paths:
       operationId: inference_providerconnections_by_name_patch
       summary: Update a provider connection
       description:
-        Update an existing connection. Cannot rename or change the provider. For managed connections
-        (anthropic-managed, openai-managed, gemini-managed) the auth is locked to platform; label remains editable.
+        Update an existing connection. Cannot rename or change the provider. For the Vellum-managed connection
+        (vellum) the auth is locked to platform; label remains editable.
       tags:
         - inference
       parameters:
@@ -21080,6 +21079,44 @@ paths:
                   showPlatformLogin:
                     type: boolean
                 additionalProperties: false
+  /v1/platform/credits:
+    get:
+      operationId: platform_credits_get
+      summary: Get the organization's remaining credit balance
+      description:
+        Fetches the org's settled, pending, and effective (remaining) credit balance in USD from the platform
+        billing summary.
+      tags:
+        - platform
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  remaining:
+                    type: number
+                  settled:
+                    type: number
+                  pending:
+                    type: number
+                  unit:
+                    type: string
+                    const: USD
+                  stale:
+                    type: boolean
+                  as_of:
+                    type: string
+                required:
+                  - remaining
+                  - settled
+                  - pending
+                  - unit
+                  - stale
+                  - as_of
+                additionalProperties: false
   /v1/platform/disconnect:
     post:
       operationId: platform_disconnect_post

package/package.json

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

package/src/__tests__/attachment-stored-path-annotation.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Regression: re-uploading a document with the same filename must not leave
+ * the model pointing at the older upload. Storage resolves the collision with
+ * a -2/-3 suffix in the conversation's attachments/ directory, so the
+ * LLM-facing user message (and the metadata used to rebuild it on history
+ * reload) must carry the resolved stored path of every linked attachment —
+ * otherwise the model's only on-disk handle is the original filename, which
+ * stays bound to the oldest upload.
+ */
+import { readFileSync } from "node:fs";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+import { reinjectAttachmentPathAnnotations } from "../daemon/conversation-lifecycle.js";
+import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
+import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
+import { createConversation } from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { rawGet } from "../persistence/raw-query.js";
+import type { ContentBlock } from "../providers/types.js";
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function makeCtx(conversationId: string): MessagingConversationContext {
+  return {
+    conversationId,
+    messages: [],
+    abortController: null,
+    currentRequestId: undefined,
+    queue: {} as never,
+    isProcessing: () => false,
+    setProcessing: () => {},
+    getTurnChannelContext: () => null,
+    getTurnInterfaceContext: () => null,
+  } as unknown as MessagingConversationContext;
+}
+
+function lastAnnotationBlock(ctx: MessagingConversationContext): {
+  type: string;
+  text: string;
+} {
+  const llmMessage = ctx.messages.at(-1)!;
+  return (llmMessage.content as ContentBlock[]).at(-1) as {
+    type: string;
+    text: string;
+  };
+}
+
+describe("persistQueuedMessageBody stored path annotations", () => {
+  beforeEach(resetTables);
+
+  test("same-named re-upload annotates the resolved -2 path", async () => {
+    const conv = createConversation();
+    const ctx = makeCtx(conv.id);
+
+    // "aGVsbG8=" = "hello", "d29ybGQ=" = "world"
+    const first = await persistQueuedMessageBody(ctx, {
+      content: "here is my file",
+      attachments: [
+        { filename: "report.csv", mimeType: "text/csv", data: "aGVsbG8=" },
+      ],
+    });
+    const second = await persistQueuedMessageBody(ctx, {
+      content: "I edited it, take another look",
+      attachments: [
+        { filename: "report.csv", mimeType: "text/csv", data: "d29ybGQ=" },
+      ],
+    });
+
+    // Second turn's persisted metadata records the collision-suffixed copy.
+    const row = rawGet<{ metadata: string }>(
+      "test:secondMessageMetadata",
+      "SELECT metadata FROM messages WHERE id = ?",
+      second.id,
+    );
+    const meta = JSON.parse(row!.metadata) as {
+      attachmentStoredPaths: Record<string, string>;
+    };
+    const storedPath = meta.attachmentStoredPaths["0:report.csv"];
+    expect(storedPath.endsWith("report-2.csv")).toBe(true);
+    expect(readFileSync(storedPath).toString()).toBe("world");
+
+    // The in-memory LLM message points at that copy, not the original name.
+    const annotation = lastAnnotationBlock(ctx);
+    expect(annotation.type).toBe("text");
+    expect(annotation.text).toBe(
+      `[Attachment "report.csv" is stored at: ${storedPath}]`,
+    );
+
+    // The first turn's annotation still points at the unsuffixed original.
+    const firstRow = rawGet<{ metadata: string }>(
+      "test:firstMessageMetadata",
+      "SELECT metadata FROM messages WHERE id = ?",
+      first.id,
+    );
+    const firstMeta = JSON.parse(firstRow!.metadata) as {
+      attachmentStoredPaths: Record<string, string>;
+    };
+    const firstStoredPath = firstMeta.attachmentStoredPaths["0:report.csv"];
+    expect(firstStoredPath.endsWith("report.csv")).toBe(true);
+    expect(firstStoredPath.endsWith("report-2.csv")).toBe(false);
+    expect(readFileSync(firstStoredPath).toString()).toBe("hello");
+
+    // History-reload parity: reinjection rebuilds the identical block.
+    const rebuilt = reinjectAttachmentPathAnnotations(
+      [{ type: "text", text: "I edited it, take another look" }],
+      "user",
+      row!.metadata,
+    );
+    const rebuiltBlock = rebuilt.at(-1) as { type: "text"; text: string };
+    expect(rebuiltBlock.text).toBe(annotation.text);
+  });
+
+  test("messages without attachments get no annotation block", async () => {
+    const conv = createConversation();
+    const ctx = makeCtx(conv.id);
+
+    await persistQueuedMessageBody(ctx, { content: "just text" });
+
+    expect(ctx.messages).toHaveLength(1);
+    const content = ctx.messages[0].content as ContentBlock[];
+    expect(content).toHaveLength(1);
+    expect(content[0].type).toBe("text");
+  });
+});

package/src/__tests__/attachments-store.test.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -21,6 +21,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import {
+  attachInlineAttachmentToMessage,
   AttachmentUploadError,
   deleteAttachment,
   deleteOrphanAttachments,
@@ -389,6 +390,41 @@ describe("getAttachmentById", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// attachInlineAttachmentToMessage — filename collisions
+// ---------------------------------------------------------------------------
+
+describe("attachInlineAttachmentToMessage filename collisions", () => {
+  beforeEach(resetTables);
+
+  test("returns the resolved -N path when a same-named file already exists", async () => {
+    const conv = createConversation();
+    const msg1 = await addMessage(conv.id, "user", "first upload");
+    const msg2 = await addMessage(conv.id, "user", "re-upload after editing");
+
+    // "aGVsbG8=" = "hello", "d29ybGQ=" = "world"
+    const first = attachInlineAttachmentToMessage(
+      msg1.id,
+      0,
+      "report.csv",
+      "text/csv",
+      "aGVsbG8=",
+    );
+    const second = attachInlineAttachmentToMessage(
+      msg2.id,
+      0,
+      "report.csv",
+      "text/csv",
+      "d29ybGQ=",
+    );
+
+    expect(first.filePath.endsWith("report.csv")).toBe(true);
+    expect(second.filePath.endsWith("report-2.csv")).toBe(true);
+    expect(readFileSync(first.filePath).toString()).toBe("hello");
+    expect(readFileSync(second.filePath).toString()).toBe("world");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // linkAttachmentToMessage + getAttachmentsForMessage
 // ---------------------------------------------------------------------------

package/src/__tests__/attachments.test.ts

@@ -254,4 +254,57 @@ describe("enrichMessageWithSourcePaths", () => {
     const annotation = enriched.content[3] as { type: "text"; text: string };
     expect(annotation.text).toBe("[Attached image source: /path/to/a.jpg]");
   });
+
+  test("annotates non-image attachments that have storedPath", () => {
+    const attachments = [
+      {
+        filename: "report.pdf",
+        mimeType: "application/pdf",
+        data: "pdfdata",
+        filePath: "/staging/123-report.pdf",
+        storedPath: "/conv/attachments/report-2.pdf",
+      },
+    ];
+    const original = createUserMessage("review my edits", attachments);
+    const enriched = enrichMessageWithSourcePaths(original, attachments);
+
+    expect(enriched).not.toBe(original);
+    // text + file = 2 blocks; enriched adds 1 annotation = 3
+    expect(enriched.content).toHaveLength(3);
+    const annotation = enriched.content[2] as { type: "text"; text: string };
+    expect(annotation.type).toBe("text");
+    expect(annotation.text).toBe(
+      '[Attachment "report.pdf" is stored at: /conv/attachments/report-2.pdf]',
+    );
+  });
+
+  test("emits image source lines before stored path lines in one block", () => {
+    const attachments = [
+      {
+        filename: "data.csv",
+        mimeType: "text/csv",
+        data: "csvdata",
+        storedPath: "/conv/attachments/data-2.csv",
+      },
+      {
+        filename: "photo.jpg",
+        mimeType: "image/jpeg",
+        data: "img",
+        filePath: "/Users/me/Desktop/photo.jpg",
+        storedPath: "/conv/attachments/photo.jpg",
+      },
+    ];
+    const original = createUserMessage("compare", attachments);
+    const enriched = enrichMessageWithSourcePaths(original, attachments);
+
+    const annotation = enriched.content.at(-1) as {
+      type: "text";
+      text: string;
+    };
+    expect(annotation.text).toBe(
+      "[Attached image source: /Users/me/Desktop/photo.jpg]\n" +
+        '[Attachment "data.csv" is stored at: /conv/attachments/data-2.csv]\n' +
+        '[Attachment "photo.jpg" is stored at: /conv/attachments/photo.jpg]',
+    );
+  });
 });

package/src/__tests__/channel-reply-delivery.test.ts

@@ -435,7 +435,10 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls).toHaveLength(0);
   });
 
-  it("treats a current-turn no_response marker as terminal instead of falling back", async () => {
+  // Silence means the turn produced no real reply text anywhere — not "the
+  // last row was a sentinel". A trailing bare <no_response/> row must not
+  // swallow the real reply written earlier in the same turn.
+  it("delivers the earlier real reply when the turn ends with a bare no_response row", async () => {
     conversationMessages.push(
       { id: "msg-current-user", role: "user", content: "current prompt" },
       {
@@ -449,7 +452,7 @@ describe("channel-reply-delivery", () => {
         content: '[{"type":"text","text":"<no_response/>"}]',
       },
     );
-    renderedHistoryContentQueue.push({
+    const silentStub = {
       text: "<no_response/>",
       textSegments: ["<no_response/>"],
       toolCalls: [],
@@ -457,8 +460,42 @@ describe("channel-reply-delivery", () => {
       contentOrder: ["text:0"],
       surfaces: [],
       thinkingSegments: [],
-    });
-    renderedHistoryContentQueue.push({
+    };
+    const answerStub = {
+      text: "current answer",
+      textSegments: ["current answer"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    };
+    // Turn scan reads the silent row then the text row; delivery re-reads
+    // the chosen text row.
+    renderedHistoryContentQueue.push(silentStub, answerStub, answerStub);
+
+    await deliverReplyViaCallback(
+      "conv-1",
+      "chat-current",
+      "http://gateway/deliver/slack",
+      "assistant-current",
+      { sinceMessageId: "msg-current-user" },
+    );
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("current answer");
+  });
+
+  it("stays silent when a no_response turn has no real reply text anywhere", async () => {
+    conversationMessages.push(
+      { id: "msg-current-user", role: "user", content: "current prompt" },
+      {
+        id: "msg-current-silent",
+        role: "assistant",
+        content: '[{"type":"text","text":"<no_response/>"}]',
+      },
+    );
+    const silentStub = {
       text: "<no_response/>",
       textSegments: ["<no_response/>"],
       toolCalls: [],
@@ -466,7 +503,10 @@ describe("channel-reply-delivery", () => {
       contentOrder: ["text:0"],
       surfaces: [],
       thinkingSegments: [],
-    });
+    };
+    // Turn scan reads the silent row; delivery re-reads it as the terminal
+    // deliberate-silence target.
+    renderedHistoryContentQueue.push(silentStub, silentStub);
 
     await deliverReplyViaCallback(
       "conv-1",
@@ -479,6 +519,124 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls).toHaveLength(0);
   });
 
+  it("falls through a messageId-targeted bare no_response row to the turn's real reply", async () => {
+    conversationMessages.push(
+      { id: "msg-current-user", role: "user", content: "current prompt" },
+      {
+        id: "msg-current-text",
+        role: "assistant",
+        content: '[{"type":"text","text":"current answer"}]',
+      },
+      {
+        id: "msg-current-silent",
+        role: "assistant",
+        content: '[{"type":"text","text":"<no_response/>"}]',
+      },
+    );
+    const silentStub = {
+      text: "<no_response/>",
+      textSegments: ["<no_response/>"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    };
+    const answerStub = {
+      text: "current answer",
+      textSegments: ["current answer"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    };
+    // messageId branch reads the targeted silent row, the turn scan reads
+    // the silent row then the text row, and delivery re-reads the text row.
+    renderedHistoryContentQueue.push(
+      silentStub,
+      silentStub,
+      answerStub,
+      answerStub,
+    );
+
+    await deliverReplyViaCallback(
+      "conv-1",
+      "chat-current",
+      "http://gateway/deliver/slack",
+      "assistant-current",
+      { messageId: "msg-current-silent", sinceMessageId: "msg-current-user" },
+    );
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("current answer");
+  });
+
+  // A bare-sentinel row never delivers its attachments (marker rows suppress
+  // attachment delivery), so attachments alone must not make the row count
+  // as the turn's real reply and stop the fall-through.
+  it("falls through a bare no_response row with attachments to the turn's real reply", async () => {
+    conversationMessages.push(
+      { id: "msg-current-user", role: "user", content: "current prompt" },
+      {
+        id: "msg-current-text",
+        role: "assistant",
+        content: '[{"type":"text","text":"current answer"}]',
+      },
+      {
+        id: "msg-current-silent",
+        role: "assistant",
+        content: '[{"type":"text","text":"<no_response/>"}]',
+      },
+    );
+    attachmentsByMessageId.set("msg-current-silent", [
+      {
+        id: "att-silent",
+        originalFilename: "chart.png",
+        mimeType: "image/png",
+        sizeBytes: 10,
+        kind: "generated",
+      },
+    ]);
+    const silentStub = {
+      text: "<no_response/>",
+      textSegments: ["<no_response/>"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    };
+    const answerStub = {
+      text: "current answer",
+      textSegments: ["current answer"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    };
+    // messageId branch reads the targeted silent row, the turn scan reads
+    // the silent row then the text row, and delivery re-reads the text row.
+    renderedHistoryContentQueue.push(
+      silentStub,
+      silentStub,
+      answerStub,
+      answerStub,
+    );
+
+    await deliverReplyViaCallback(
+      "conv-1",
+      "chat-current",
+      "http://gateway/deliver/slack",
+      "assistant-current",
+      { messageId: "msg-current-silent", sinceMessageId: "msg-current-user" },
+    );
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("current answer");
+  });
+
   it("skips already-delivered segments when startFromSegment is set", async () => {
     await deliverRenderedReplyViaCallback({
       callbackUrl: "http://gateway/deliver/telegram",
@@ -703,6 +861,57 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls[0].payload.text).toBe("Real response.");
   });
 
+  it("strips a prefixed inline <no_response/> and delivers the rest of the segment", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-inline-prefix",
+      textSegments: ["<no_response/>\n\nReal reply."],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("Real reply.");
+  });
+
+  it("strips a trailing inline <no_response/> and delivers the rest of the segment", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-inline-trailing",
+      textSegments: ["Real reply.\n\n<no_response/>"],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("Real reply.");
+  });
+
+  it("never leaks the sentinel into delivered text, including the fallback path", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-fallback-strip",
+      textSegments: [],
+      fallbackText: "Fallback reply. <no_response/>",
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("Fallback reply.");
+    for (const call of deliveryCalls) {
+      expect(String(call.payload.text)).not.toContain("<no_response");
+    }
+  });
+
+  it("suppresses delivery for a case-insensitive bare sentinel", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-silent-case",
+      textSegments: ["<NO_RESPONSE/>"],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(0);
+  });
+
   it("passes startFromSegment through deliverReplyViaCallback options", async () => {
     conversationMessages.push(
       { id: "msg-u", role: "user", content: "hi" },