@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -46,6 +46,7 @@ import {
   deleteApp,
   deleteConnection,
   disconnectOAuthProvider,
+  getActiveConnection,
   getApp,
   getAppByProviderAndClientId,
   getConnection,
@@ -631,6 +632,120 @@ describe("connection operations", () => {
     });
   });
 
+  describe("getActiveConnection", () => {
+    test("returns the most recent active connection with no filters", async () => {
+      const app = await createTestApp("github", "client-1");
+
+      createConnection({
+        oauthAppId: app.id,
+        providerKey: "github",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+        createdAt: 1000,
+      });
+
+      const conn2 = createConnection({
+        oauthAppId: app.id,
+        providerKey: "github",
+        grantedScopes: ["repo", "user"],
+        hasRefreshToken: true,
+        createdAt: 2000,
+      });
+
+      const result = getActiveConnection("github");
+      expect(result).toBeDefined();
+      expect(result!.id).toBe(conn2.id);
+    });
+
+    test("narrows by account when provided", async () => {
+      const app = await createTestApp("github", "client-1");
+
+      const conn1 = createConnection({
+        oauthAppId: app.id,
+        providerKey: "github",
+        accountInfo: "user1@example.com",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+        createdAt: 1000,
+      });
+
+      createConnection({
+        oauthAppId: app.id,
+        providerKey: "github",
+        accountInfo: "user2@example.com",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+        createdAt: 2000,
+      });
+
+      const result = getActiveConnection("github", {
+        account: "user1@example.com",
+      });
+      expect(result).toBeDefined();
+      expect(result!.id).toBe(conn1.id);
+    });
+
+    test("narrows by clientId when provided", async () => {
+      const app1 = await createTestApp("github", "client-a");
+      const app2 = await createTestApp("github", "client-b");
+
+      const conn1 = createConnection({
+        oauthAppId: app1.id,
+        providerKey: "github",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+        createdAt: 1000,
+      });
+
+      createConnection({
+        oauthAppId: app2.id,
+        providerKey: "github",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+        createdAt: 2000,
+      });
+
+      const result = getActiveConnection("github", { clientId: "client-a" });
+      expect(result).toBeDefined();
+      expect(result!.id).toBe(conn1.id);
+    });
+
+    test("returns undefined when clientId has no matching app", async () => {
+      const app = await createTestApp("github", "client-1");
+
+      createConnection({
+        oauthAppId: app.id,
+        providerKey: "github",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+      });
+
+      const result = getActiveConnection("github", {
+        clientId: "nonexistent",
+      });
+      expect(result).toBeUndefined();
+    });
+
+    test("skips revoked connections", async () => {
+      const app = await createTestApp("github", "client-1");
+
+      const conn = createConnection({
+        oauthAppId: app.id,
+        providerKey: "github",
+        grantedScopes: ["repo"],
+        hasRefreshToken: false,
+      });
+      updateConnection(conn.id, { status: "revoked" });
+
+      const result = getActiveConnection("github");
+      expect(result).toBeUndefined();
+    });
+
+    test("returns undefined when no connections exist", () => {
+      expect(getActiveConnection("github")).toBeUndefined();
+    });
+  });
+
   describe("getConnectionByProvider", () => {
     test("returns the most recent active connection", async () => {
       const app = await createTestApp("github", "client-1");

package/src/__tests__/parse-identity-fields.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Unit tests for identity field parsing and template placeholder filtering.
+ *
+ * Validates that parseIdentityFields correctly extracts real values from
+ * IDENTITY.md content while treating template placeholders (e.g.
+ * `_(not yet chosen)_`) as empty/unset.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  isTemplatePlaceholder,
+  parseIdentityFields,
+} from "../daemon/handlers/identity.js";
+
+// ---------------------------------------------------------------------------
+// isTemplatePlaceholder
+// ---------------------------------------------------------------------------
+
+describe("isTemplatePlaceholder", () => {
+  test("returns true for _(not yet chosen)_", () => {
+    expect(isTemplatePlaceholder("_(not yet chosen)_")).toBe(true);
+  });
+
+  test("returns true for _(not yet established)_", () => {
+    expect(isTemplatePlaceholder("_(not yet established)_")).toBe(true);
+  });
+
+  test("returns true for any value matching _(…)_ pattern", () => {
+    expect(isTemplatePlaceholder("_(something else)_")).toBe(true);
+  });
+
+  test("returns false for normal values", () => {
+    expect(isTemplatePlaceholder("Your helpful coding assistant")).toBe(false);
+    expect(isTemplatePlaceholder("Jarvis")).toBe(false);
+    expect(isTemplatePlaceholder("")).toBe(false);
+  });
+
+  test("returns false for partial matches", () => {
+    expect(isTemplatePlaceholder("_(incomplete")).toBe(false);
+    expect(isTemplatePlaceholder("incomplete)_")).toBe(false);
+    expect(isTemplatePlaceholder("_(")).toBe(false);
+    expect(isTemplatePlaceholder(")_")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseIdentityFields — placeholder filtering
+// ---------------------------------------------------------------------------
+
+describe("parseIdentityFields", () => {
+  test("returns empty strings for all template placeholder values", () => {
+    const content = [
+      "- **Name:** _(not yet chosen)_",
+      "- **Role:** _(not yet established)_",
+      "- **Personality:** _(not yet chosen)_",
+      "- **Emoji:** _(not yet chosen)_",
+      "- **Home:** _(not yet chosen)_",
+    ].join("\n");
+
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("");
+    expect(fields.role).toBe("");
+    expect(fields.personality).toBe("");
+    expect(fields.emoji).toBe("");
+    expect(fields.home).toBe("");
+  });
+
+  test("preserves real user-provided values", () => {
+    const content = [
+      "- **Name:** Jarvis",
+      "- **Role:** Coding assistant",
+      "- **Personality:** Friendly and helpful",
+      "- **Emoji:** 🤖",
+      "- **Home:** ~/projects",
+    ].join("\n");
+
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("Jarvis");
+    expect(fields.role).toBe("Coding assistant");
+    expect(fields.personality).toBe("Friendly and helpful");
+    expect(fields.emoji).toBe("🤖");
+    expect(fields.home).toBe("~/projects");
+  });
+
+  test("handles a mix of real and placeholder values", () => {
+    const content = [
+      "- **Name:** Jarvis",
+      "- **Role:** _(not yet established)_",
+      "- **Personality:** Friendly",
+      "- **Emoji:** _(not yet chosen)_",
+      "- **Home:** ~/dev",
+    ].join("\n");
+
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("Jarvis");
+    expect(fields.role).toBe("");
+    expect(fields.personality).toBe("Friendly");
+    expect(fields.emoji).toBe("");
+    expect(fields.home).toBe("~/dev");
+  });
+
+  test("returns role: '' when IDENTITY.md contains placeholder role", () => {
+    const content = "- **Role:** _(not yet established)_";
+    const fields = parseIdentityFields(content);
+    expect(fields.role).toBe("");
+  });
+
+  test("returns name: '' when IDENTITY.md contains placeholder name", () => {
+    const content = "- **Name:** _(not yet chosen)_";
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("");
+  });
+
+  test('parses role: "Coding assistant" for real values', () => {
+    const content = "- **Role:** Coding assistant";
+    const fields = parseIdentityFields(content);
+    expect(fields.role).toBe("Coding assistant");
+  });
+
+  test("returns empty strings when content has no identity fields", () => {
+    const fields = parseIdentityFields("# Some other content\nHello world");
+    expect(fields.name).toBe("");
+    expect(fields.role).toBe("");
+    expect(fields.personality).toBe("");
+    expect(fields.emoji).toBe("");
+    expect(fields.home).toBe("");
+  });
+});

package/src/__tests__/provider-error-scenarios.test.ts

@@ -68,9 +68,7 @@ mock.module("../util/retry.js", () => {
       const causeCode = (error.cause as NodeJS.ErrnoException).code;
       if (causeCode && retryableCodes.has(causeCode)) return true;
     }
-    if (
-      RETRYABLE_NETWORK_MESSAGE_PATTERNS.some((p) => p.test(error.message))
-    ) {
+    if (RETRYABLE_NETWORK_MESSAGE_PATTERNS.some((p) => p.test(error.message))) {
       return true;
     }
     const cause = error.cause;

package/src/__tests__/provider-failover-actual-provider.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+import { FailoverProvider } from "../providers/failover.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+} from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
+
+const MESSAGES: Message[] = [
+  { role: "user", content: [{ type: "text", text: "Hello" }] },
+];
+
+function successResponse(
+  overrides?: Partial<ProviderResponse>,
+): ProviderResponse {
+  return {
+    content: [{ type: "text", text: "ok" }],
+    model: "test-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+    ...overrides,
+  };
+}
+
+describe("FailoverProvider actual provider propagation", () => {
+  test("stamps the winning provider when failover uses a fallback", async () => {
+    const primary: Provider = {
+      name: "openrouter",
+      async sendMessage() {
+        throw new ProviderError("down", "openrouter", 500);
+      },
+    };
+    const secondary: Provider = {
+      name: "fireworks",
+      async sendMessage() {
+        return successResponse();
+      },
+    };
+
+    const provider = new FailoverProvider([primary, secondary]);
+    const response = await provider.sendMessage(MESSAGES);
+
+    expect(response.actualProvider).toBe("fireworks");
+  });
+
+  test("preserves an inner provider's actual provider when already set", async () => {
+    const inner: Provider = {
+      name: "retry-wrapper",
+      async sendMessage() {
+        return successResponse({ actualProvider: "anthropic" });
+      },
+    };
+
+    const provider = new FailoverProvider([inner]);
+    const response = await provider.sendMessage(MESSAGES);
+
+    expect(response.actualProvider).toBe("anthropic");
+  });
+});

package/src/__tests__/recording-handler.test.ts

@@ -81,6 +81,23 @@ const mockAttachments: Array<{
 let mockAttachmentIdCounter = 0;
 
 mock.module("../memory/attachments-store.js", () => ({
+  attachFileBackedAttachmentToMessage: (
+    _messageId: string,
+    _position: number,
+    filename: string,
+    mimeType: string,
+    _filePath: string,
+    sizeBytes: number,
+  ) => {
+    const att = {
+      id: `att-${++mockAttachmentIdCounter}`,
+      originalFilename: filename,
+      mimeType,
+      sizeBytes,
+    };
+    mockAttachments.push(att);
+    return att;
+  },
   uploadFileBackedAttachment: (
     filename: string,
     mimeType: string,

package/src/__tests__/registry.test.ts

@@ -109,7 +109,7 @@ describe("tool registry dynamic-tools tools", () => {
 
 describe("tool manifest", () => {
   test("eager module tool names list contains expected count", () => {
-    expect(eagerModuleToolNames.length).toBe(11);
+    expect(eagerModuleToolNames.length).toBe(9);
   });
 
   test("explicit tools list includes memory and credential tools", () => {
@@ -187,14 +187,9 @@ describe("baseline characterization: core app tool surface", () => {
 
     const nonProxyAppTools = [
       "app_create",
-      "app_list",
-      "app_query",
-      "app_update",
       "app_delete",
-      "app_file_list",
-      "app_file_read",
-      "app_file_edit",
-      "app_file_write",
+      "app_generate_icon",
+      "app_refresh",
     ];
 
     for (const name of nonProxyAppTools) {

package/src/__tests__/relay-server.test.ts

@@ -159,7 +159,7 @@ mock.module("../providers/registry.js", () => {
     getDefaultModel: (providerName: string) => {
       const defaults: Record<string, string> = {
         anthropic: "claude-opus-4-6",
-        openai: "gpt-5.2",
+        openai: "gpt-5.4",
         gemini: "gemini-3-flash",
         ollama: "llama3.2",
         fireworks: "accounts/fireworks/models/kimi-k2p5",

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -116,7 +116,7 @@ describe("Runtime attachment metadata", () => {
     );
 
     // Upload and link an attachment using "self" as the assistantId
-    const stored = uploadAttachment("chart.png", "image/png", "iVBOR");
+    const stored = uploadAttachment("chart.png", "image/png", "iVBORw==");
     linkAttachmentToMessage(assistantMsg.id, stored.id, 0);
 
     const res = await fetch(
@@ -181,7 +181,11 @@ describe("Runtime attachment metadata", () => {
   });
 
   test("GET /attachments/:id returns attachment with payload", async () => {
-    const stored = uploadAttachment("report.pdf", "application/pdf", "JVBER");
+    const stored = uploadAttachment(
+      "report.pdf",
+      "application/pdf",
+      "JVBERA==",
+    );
 
     const res = await fetch(
       `http://127.0.0.1:${port}/v1/attachments/${stored.id}`,
@@ -201,7 +205,7 @@ describe("Runtime attachment metadata", () => {
     expect(body.filename).toBe("report.pdf");
     expect(body.mimeType).toBe("application/pdf");
     expect(body.kind).toBe("document");
-    expect(body.data).toBe("JVBER");
+    expect(body.data).toBe("JVBERA==");
     expect(body.sizeBytes).toBeGreaterThan(0);
   });
 

package/src/__tests__/schema-transforms.test.ts

@@ -70,21 +70,53 @@ describe("injectActivityField", () => {
     expect("activity" in props0).toBe(false);
   });
 
-  test("skips tools that already have activity in properties", () => {
+  test("returns unchanged when activity is in top-level properties but not required", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
         properties: { activity: { type: "number" } },
-        required: [],
+        required: ["foo"],
       }),
     ];
     const result = injectActivityField(defs);
-    // Should be the exact same object reference (no clone needed)
+    // Should be the exact same object reference (no modification)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
     // Original activity type preserved
     expect(props.activity).toEqual({ type: "number" });
+    // required NOT modified — don't promote server-defined optional activity
+    expect(schema.required).toEqual(["foo"]);
+  });
+
+  test("returns unchanged when activity is in both top-level properties AND required", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { activity: { type: "string" } },
+        required: ["activity"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    const schema = result[0].input_schema as Record<string, unknown>;
+    const props = schema.properties as Record<string, unknown>;
+    // Original activity type preserved
+    expect(props.activity).toEqual({ type: "string" });
+    // activity must be in required even though it was already in properties
+    expect(schema.required).toEqual(["activity"]);
+  });
+
+  test("skips tools that already have activity in both properties and required", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { activity: { type: "number" } },
+        required: ["activity"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no clone needed)
+    expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
   test("does NOT mutate original definition objects", () => {
@@ -125,6 +157,60 @@ describe("injectActivityField", () => {
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
+  test("does NOT add activity to top-level required when only in oneOf branch", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { shared: { type: "string" } },
+        oneOf: [
+          {
+            properties: {
+              activity: { type: "string" },
+              branch_a: { type: "number" },
+            },
+          },
+          {
+            properties: { branch_b: { type: "boolean" } },
+          },
+        ],
+        required: ["shared"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no modification)
+    expect(Object.is(result[0], defs[0])).toBe(true);
+    const schema = result[0].input_schema as Record<string, unknown>;
+    // Top-level required should NOT include activity
+    expect(schema.required).toEqual(["shared"]);
+    // Top-level properties should NOT have activity injected
+    const props = schema.properties as Record<string, unknown>;
+    expect("activity" in props).toBe(false);
+  });
+
+  test("does NOT add activity to top-level required when only in allOf sub-schema with additionalProperties: false", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { foo: { type: "string" } },
+        additionalProperties: false,
+        allOf: [
+          {
+            properties: { activity: { type: "string" } },
+          },
+        ],
+        required: ["foo"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no modification)
+    expect(Object.is(result[0], defs[0])).toBe(true);
+    const schema = result[0].input_schema as Record<string, unknown>;
+    // Top-level required should NOT include activity
+    expect(schema.required).toEqual(["foo"]);
+    const props = schema.properties as Record<string, unknown>;
+    expect("activity" in props).toBe(false);
+  });
+
   test("skips tools with activity defined inside allOf member (composite schema)", () => {
     const defs = [
       makeDef("my_tool", {
@@ -139,18 +225,92 @@ describe("injectActivityField", () => {
       }),
     ];
     const result = injectActivityField(defs);
-    // Should be the exact same object reference (no injection)
+    // Should be the exact same object reference (no modification)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    // Top-level properties should NOT have activity injected
+    // Top-level properties should NOT have activity injected (it's in allOf)
     expect("activity" in props).toBe(false);
+    // Top-level required should NOT include activity (it's only in composite sub-schemas)
+    expect(schema.required).toEqual([]);
+  });
+
+  test("skips allOf composite schema where activity is already required", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { foo: { type: "string" } },
+        allOf: [
+          {
+            properties: { activity: { type: "string" } },
+          },
+        ],
+        required: ["activity"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no change needed)
+    expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
   test("handles empty definitions array", () => {
     const result = injectActivityField([]);
     expect(result).toEqual([]);
   });
+
+  test("injects activity only on tools that don't define it at all", () => {
+    const defs = [
+      // Normal tool without activity — should get it injected
+      makeDef("tool_a", {
+        type: "object",
+        properties: { foo: { type: "string" } },
+        required: ["foo"],
+      }),
+      // Tool defines activity in properties but NOT in required — left unchanged
+      makeDef("tool_b", {
+        type: "object",
+        properties: {
+          bar: { type: "string" },
+          activity: { type: "string", description: "custom activity" },
+        },
+        required: ["bar"],
+      }),
+      // Tool that defines activity in both properties AND required — left unchanged
+      makeDef("tool_c", {
+        type: "object",
+        properties: {
+          baz: { type: "number" },
+          activity: { type: "string", description: "custom activity" },
+        },
+        required: ["baz", "activity"],
+      }),
+      // Non-object schema — should be left alone
+      makeDef("tool_d", { type: "string" }),
+      // Object schema without properties — should be left alone
+      makeDef("tool_e", { type: "object" }),
+    ];
+
+    const result = injectActivityField(defs);
+
+    // tool_a: activity injected and required
+    const schemaA = result[0].input_schema as Record<string, unknown>;
+    expect(
+      (schemaA.properties as Record<string, unknown>).activity,
+    ).toBeDefined();
+    expect(schemaA.required).toEqual(["foo", "activity"]);
+
+    // tool_b: unchanged (activity optional, not promoted)
+    expect(Object.is(result[1], defs[1])).toBe(true);
+    const schemaB = result[1].input_schema as Record<string, unknown>;
+    expect(schemaB.required).toEqual(["bar"]);
+
+    // tool_c: unchanged (activity already present and required)
+    expect(Object.is(result[2], defs[2])).toBe(true);
+
+    // tool_d, tool_e: unchanged
+    expect(Object.is(result[3], defs[3])).toBe(true);
+    expect(Object.is(result[4], defs[4])).toBe(true);
+  });
 });
 
 describe("schemaDefinesProperty", () => {

package/src/__tests__/server-history-render.test.ts

@@ -330,7 +330,7 @@ describe("getAttachmentsForMessage", () => {
 
   test("returns attachments linked to a message", async () => {
     const msgId = await createMessage("assistant", "Here is a chart");
-    const stored = uploadAttachment("chart.png", "image/png", "iVBOR");
+    const stored = uploadAttachment("chart.png", "image/png", "iVBORw==");
     linkAttachmentToMessage(msgId, stored.id, 0);
 
     const result = getAttachmentsForMessage(msgId);
@@ -338,7 +338,7 @@ describe("getAttachmentsForMessage", () => {
     expect(result[0].id).toBe(stored.id);
     expect(result[0].originalFilename).toBe("chart.png");
     expect(result[0].mimeType).toBe("image/png");
-    expect(result[0].dataBase64).toBe("iVBOR");
+    expect(result[0].dataBase64).toBe("iVBORw==");
   });
 
   test("returns empty array when no attachments are linked", () => {