@vellumai/assistant 0.6.5 → 0.7.0

package/src/config/bundled-skills/contacts/tools/contact-search.ts

@@ -1,30 +1,15 @@
-import {
-  gatewayGet,
-  GatewayRequestError,
-} from "../../../../runtime/gateway-internal-client.js";
+import type { ContactWithChannels } from "../../../../contacts/types.js";
+import { cliIpcCall } from "../../../../ipc/cli-client.js";
+import { resolveGuardianName } from "../../../../prompts/user-reference.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
 
-interface ContactChannel {
-  type: string;
-  address: string;
-  isPrimary: boolean;
-  externalUserId?: string | null;
-  externalChatId?: string | null;
-}
-
-interface ContactResponse {
-  id: string;
-  displayName: string;
-  notes: string | null;
-  interactionCount: number;
-  channels: ContactChannel[];
-}
-
-function formatContactSummary(c: ContactResponse): string {
-  const parts = [`- **${c.displayName}** (ID: ${c.id})`];
+function formatContactSummary(c: ContactWithChannels): string {
+  const displayName =
+    c.role === "guardian" ? resolveGuardianName(c.displayName) : c.displayName;
+  const parts = [`- **${displayName}** (ID: ${c.id})`];
   if (c.notes) parts.push(`  Notes: ${c.notes}`);
   if (c.interactionCount > 0)
     parts.push(`  Interactions: ${c.interactionCount}`);
@@ -61,40 +46,29 @@ export async function executeContactSearch(
     };
   }
 
-  try {
-    const params = new URLSearchParams();
-    if (query) params.set("query", query);
-    if (channelAddress) params.set("channelAddress", channelAddress);
-    if (channelType) params.set("channelType", channelType);
-    if (limit !== undefined) params.set("limit", String(limit));
+  const res = await cliIpcCall<ContactWithChannels[]>("search_contacts", {
+    body: { query, channelAddress, channelType, limit },
+  });
 
-    const qs = params.toString();
-    const data = await gatewayGet<{ ok: boolean; contacts: ContactResponse[] }>(
-      `/v1/contacts${qs ? `?${qs}` : ""}`,
-    );
-    const results = data.contacts;
+  if (!res.ok) {
+    return { content: `Error: ${res.error}`, isError: true };
+  }
 
-    if (results.length === 0) {
-      return {
-        content: "No contacts found matching the search criteria.",
-        isError: false,
-      };
-    }
+  const results = res.result ?? [];
 
-    const lines = [`Found ${results.length} contact(s):\n`];
-    for (const contact of results) {
-      lines.push(formatContactSummary(contact));
-    }
+  if (results.length === 0) {
+    return {
+      content: "No contacts found matching the search criteria.",
+      isError: false,
+    };
+  }
 
-    return { content: lines.join("\n"), isError: false };
-  } catch (err) {
-    if (err instanceof GatewayRequestError) {
-      const message = err.gatewayError ?? err.message;
-      return { content: `Error: ${message}`, isError: true };
-    }
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: `Error: ${msg}`, isError: true };
+  const lines = [`Found ${results.length} contact(s):\n`];
+  for (const contact of results) {
+    lines.push(formatContactSummary(contact));
   }
+
+  return { content: lines.join("\n"), isError: false };
 }
 
 export { executeContactSearch as run };

package/src/config/bundled-skills/contacts/tools/contact-upsert.ts

@@ -1,30 +1,15 @@
-import {
-  gatewayPost,
-  GatewayRequestError,
-} from "../../../../runtime/gateway-internal-client.js";
+import type { ContactWithChannels } from "../../../../contacts/types.js";
+import { cliIpcCall } from "../../../../ipc/cli-client.js";
+import { resolveGuardianName } from "../../../../prompts/user-reference.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
 
-interface ContactChannel {
-  type: string;
-  address: string;
-  isPrimary: boolean;
-  externalUserId?: string | null;
-  externalChatId?: string | null;
-}
-
-interface ContactResponse {
-  id: string;
-  displayName: string;
-  notes: string | null;
-  interactionCount: number;
-  channels: ContactChannel[];
-}
-
-function formatContact(c: ContactResponse): string {
-  const lines = [`Contact ${c.id}`, `  Name: ${c.displayName}`];
+function formatContact(c: ContactWithChannels): string {
+  const displayName =
+    c.role === "guardian" ? resolveGuardianName(c.displayName) : c.displayName;
+  const lines = [`Contact ${c.id}`, `  Name: ${displayName}`];
   if (c.notes) lines.push(`  Notes: ${c.notes}`);
   if (c.interactionCount > 0)
     lines.push(`  Interactions: ${c.interactionCount}`);
@@ -71,30 +56,32 @@ export async function executeContactUpsert(
     isPrimary: ch.is_primary,
   }));
 
-  try {
-    const { status, data } = await gatewayPost<{
-      ok: boolean;
-      contact: ContactResponse;
-    }>("/v1/contacts", {
-      id: input.id as string | undefined,
-      displayName: displayName.trim(),
-      notes: input.notes as string | undefined,
-      channels,
-    });
-
-    const created = status === 201;
+  const res = await cliIpcCall<{
+    ok: boolean;
+    contact: ContactWithChannels & { created: boolean };
+  }>(
+    "upsert_contact",
+    {
+      body: {
+        id: input.id as string | undefined,
+        displayName: displayName.trim(),
+        notes: input.notes as string | undefined,
+        channels,
+      },
+    },
+  );
 
-    return {
-      content: `${created ? "Created" : "Updated"} contact:\n${formatContact(data.contact)}`,
-      isError: false,
-    };
-  } catch (err) {
-    if (err instanceof GatewayRequestError) {
-      return { content: `Error: ${err.message}`, isError: true };
-    }
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: `Error: ${msg}`, isError: true };
+  if (!res.ok) {
+    return { content: `Error: ${res.error}`, isError: true };
   }
+
+  const contact = res.result!.contact;
+  const verb = contact.created ? "Created" : "Updated";
+
+  return {
+    content: `${verb} contact:\n${formatContact(contact)}`,
+    isError: false,
+  };
 }
 
 export { executeContactUpsert as run };

package/src/config/bundled-skills/image-studio/SKILL.md

@@ -25,10 +25,11 @@ You are an image generation assistant. When the user asks you to create or edit
 
 - `gemini-3.1-flash-image-preview` (default) - Nano Banana 2, fast, good quality
 - `gemini-3-pro-image-preview` - Nano Banana Pro, higher quality, slower
+- `gpt-image-2` - OpenAI GPT Image 2, high fidelity, slower
 
 ## Tips
 
 - Be descriptive in your prompts for better results. Include details about style, composition, lighting, and mood.
 - When editing images, clearly describe what changes you want made to the source image.
 - Use the `variants` parameter (1-4) to generate multiple options and pick the best one.
-- If no Gemini API key is configured, the tool will return an error - ask the user to set one up.
+- If no API key is configured for the selected model's provider (Gemini or OpenAI), the tool will return an error - ask the user to set one up.

package/src/config/bundled-skills/image-studio/TOOLS.json

@@ -29,7 +29,8 @@
             "type": "string",
             "enum": [
               "gemini-3.1-flash-image-preview",
-              "gemini-3-pro-image-preview"
+              "gemini-3-pro-image-preview",
+              "gpt-image-2"
             ],
             "description": "Which model to use for generation. If omitted, uses the user's configured preference."
           },

package/src/config/bundled-skills/image-studio/tools/media-generate-image.ts

@@ -1,16 +1,12 @@
 import { getConfig } from "../../../../config/loader.js";
+import { resolveImageGenCredentials } from "../../../../media/image-credentials.js";
 import {
   generateImage,
-  type ImageGenCredentials,
-  mapGeminiError,
-} from "../../../../media/gemini-image-service.js";
+  mapImageGenError,
+  providerForModel,
+} from "../../../../media/image-service.js";
 import { getFilePathBySourcePath } from "../../../../memory/attachments-store.js";
-import {
-  buildManagedBaseUrl,
-  resolveManagedProxyContext,
-} from "../../../../providers/managed-proxy/context.js";
 import type { ImageContent } from "../../../../providers/types.js";
-import { getProviderKeyAsync } from "../../../../security/secure-keys.js";
 import { sandboxPolicy } from "../../../../tools/shared/filesystem/path-policy.js";
 import type {
   ToolContext,
@@ -22,42 +18,30 @@ export async function run(
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
   const config = getConfig();
-  const imageGenMode = config.services["image-generation"].mode;
-
-  // Resolve credentials strictly based on mode — no cross-mode fallbacks
-  let credentials: ImageGenCredentials | undefined;
-
-  if (imageGenMode === "managed") {
-    const managedBaseUrl = await buildManagedBaseUrl("gemini");
-    if (managedBaseUrl) {
-      const ctx = await resolveManagedProxyContext();
-      credentials = {
-        type: "managed-proxy",
-        assistantApiKey: ctx.assistantApiKey,
-        baseUrl: managedBaseUrl,
-      };
-    }
-  } else {
-    const apiKey = await getProviderKeyAsync("gemini");
-    if (apiKey) {
-      credentials = { type: "direct", apiKey };
-    }
-  }
-
+  const svc = config.services["image-generation"];
+  const modelOverride = input.model;
+  // Derive provider from the explicit model when supplied so that requesting
+  // e.g. `gpt-image-2` while config.provider === "gemini" routes to OpenAI
+  // instead of silently falling back to the Gemini default model.
+  const provider = providerForModel(modelOverride, svc.provider);
+  const { credentials, errorHint } = await resolveImageGenCredentials({
+    provider,
+    mode: svc.mode,
+  });
   if (!credentials) {
-    const hint =
-      imageGenMode === "managed"
-        ? "Managed proxy is not available. Please log in to Vellum or switch to Your Own mode."
-        : "No Gemini API key configured. Please set your Gemini API key in Settings > Models & Services.";
-    return { content: hint, isError: true };
+    return {
+      content: errorHint ?? "Image generation is not configured.",
+      isError: true,
+    };
   }
 
   const prompt = input.prompt as string;
   const mode = (input.mode as "generate" | "edit") ?? "generate";
   const sourcePaths = input.source_paths as string[] | undefined;
   const model =
-    (input.model as string | undefined) ??
-    config.services["image-generation"].model;
+    typeof modelOverride === "string" && modelOverride
+      ? modelOverride
+      : config.services["image-generation"].model;
   const variants = input.variants as number | undefined;
 
   // Resolve source images from file paths (sandboxed to workingDir, edit mode only)
@@ -111,7 +95,7 @@ export async function run(
   }
 
   try {
-    const result = await generateImage(credentials, {
+    const result = await generateImage(provider, credentials, {
       prompt,
       mode,
       sourceImages,
@@ -147,7 +131,7 @@ export async function run(
     };
   } catch (error) {
     return {
-      content: mapGeminiError(error),
+      content: mapImageGenError(provider, error),
       isError: true,
     };
   }

package/src/config/bundled-skills/media-processing/__tests__/cost-tracker.test.ts

@@ -24,8 +24,8 @@ describe("CostTracker", () => {
     expect(summary.segmentCount).toBe(2);
     expect(summary.totalInputTokens).toBe(1_000_000);
     expect(summary.totalOutputTokens).toBe(1_000_000);
-    // $0.15 for 1M input + $0.60 for 1M output = $0.75
-    expect(summary.totalEstimatedUSD).toBeCloseTo(0.75, 6);
+    // $0.30 for 1M input + $2.50 for 1M output = $2.80
+    expect(summary.totalEstimatedUSD).toBeCloseTo(2.8, 6);
   });
 
   it("computes per-entry costs using Gemini 2.5 Flash pricing", () => {
@@ -38,10 +38,10 @@ describe("CostTracker", () => {
       outputTokens: 50_000,
     });
 
-    // Input: 200k * ($0.15 / 1M) = $0.03
-    // Output: 50k * ($0.60 / 1M) = $0.03
-    // Total: $0.06
-    expect(entry.estimatedUSD).toBeCloseTo(0.06, 6);
+    // Input: 200k * ($0.30 / 1M) = $0.06
+    // Output: 50k * ($2.50 / 1M) = $0.125
+    // Total: $0.185
+    expect(entry.estimatedUSD).toBeCloseTo(0.185, 6);
     expect(entry.segmentId).toBe("seg-010");
     expect(entry.model).toBe("gemini-2.5-flash");
   });

package/src/config/bundled-skills/media-processing/services/reduce.ts

@@ -260,16 +260,3 @@ export async function reduceForAsset(
   }
   return result;
 }
-
-/**
- * Interactive Q&A mode: load existing map output + user query, send to
- * Claude, return the answer. Functionally identical to reduceForAsset
- * but named distinctly for clarity in call sites.
- */
-export async function queryMapOutput(
-  assetId: string,
-  options: ReduceOptions,
-  onProgress?: (msg: string) => void,
-): Promise<ReduceResult> {
-  return reduceForAsset(assetId, options, onProgress);
-}

package/src/config/bundled-skills/messaging/SKILL.md

@@ -145,10 +145,10 @@ Telegram is supported as a messaging provider with limited capabilities compared
 
 ## Notifications vs Messages
 
-- `send_notification` is provided by the **notifications** skill (always active) -- use it when the user asks for an alert/notification (for example "send this as a desktop notification").
+- Notifications are sent via the **notifications** skill (always active) using `assistant notifications send` in `bash` -- use it when the user asks for an alert/notification (for example "send this as a desktop notification").
 - Use `messaging_send` when the user asks to send a message into a specific chat/email destination.
-- `send_notification` channel routing is LLM-driven; `preferred_channels` are hints, not hard channel forcing.
-- Before using `messaging_send` or `send_notification`, look up the recipient's contact record with `contact_search` to inform tone and content (see **Recipient Context** below).
+- Notification channel routing is LLM-driven; `--preferred-channels` are hints, not hard channel forcing.
+- Before using `messaging_send` or sending a notification, look up the recipient's contact record with `contact_search` to inform tone and content (see **Recipient Context** below).
 
 ## Personalized Drafting
 

package/src/config/bundled-skills/messaging/tools/__tests__/messaging-feed-events.test.ts

@@ -0,0 +1,207 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { EmitFeedEventParams } from "../../../../../home/emit-feed-event.js";
+
+// Capture all emitFeedEvent calls
+const emittedEvents: EmitFeedEventParams[] = [];
+
+mock.module("../../../../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: async (params: EmitFeedEventParams) => {
+    emittedEvents.push(params);
+    return {
+      id: `emit:${params.source}:${params.dedupKey ?? "random"}`,
+      type: "action",
+      source: params.source,
+      title: params.title,
+      summary: params.summary,
+      priority: 50,
+      status: "new",
+      author: "assistant",
+      timestamp: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+    };
+  },
+}));
+
+// Stub messaging provider dependencies
+const mockCreateDraft = mock(async () => ({ id: "draft-123" }));
+const mockCreateDraftRaw = mock(async () => ({ id: "draft-raw-456" }));
+const mockGetThread = mock(async () => ({
+  messages: [
+    {
+      payload: {
+        headers: [
+          { name: "From", value: "sender@example.com" },
+          { name: "To", value: "user@example.com" },
+          { name: "Subject", value: "Test Subject" },
+          { name: "Message-ID", value: "<msg-1@example.com>" },
+        ],
+      },
+    },
+  ],
+}));
+const mockGetProfile = mock(async () => ({
+  emailAddress: "user@example.com",
+}));
+
+mock.module("../../../../../messaging/providers/gmail/client.js", () => ({
+  createDraft: mockCreateDraft,
+  createDraftRaw: mockCreateDraftRaw,
+  getThread: mockGetThread,
+  getProfile: mockGetProfile,
+}));
+
+mock.module("../../../../../messaging/providers/gmail/mime-builder.js", () => ({
+  buildMultipartMime: () => "mock-raw-mime",
+}));
+
+const mockSendMessage = mock(async () => ({
+  id: "msg-sent-789",
+  threadId: "thread-1",
+}));
+const mockArchiveByQuery = mock(async () => ({
+  archived: 3,
+  truncated: false,
+}));
+
+mock.module("../shared.js", () => ({
+  resolveProvider: async (platform?: string) => ({
+    id: platform === "slack" ? "slack" : "gmail",
+    displayName: platform === "slack" ? "Slack" : "Gmail",
+    sendMessage: mockSendMessage,
+    archiveByQuery: mockArchiveByQuery,
+  }),
+  getProviderConnection: async () => ({ token: "mock-token" }),
+  ok: (msg: string) => ({ status: "ok", output: msg }),
+  err: (msg: string) => ({ status: "error", output: msg }),
+  extractEmail: (addr: string) => addr.replace(/.*<(.+)>/, "$1").toLowerCase(),
+  extractHeader: (
+    headers: Array<{ name: string; value: string }>,
+    name: string,
+  ) => headers.find((h: { name: string }) => h.name === name)?.value ?? null,
+  parseAddressList: (addrs: string | null) =>
+    addrs ? addrs.split(",").map((a: string) => a.trim()) : [],
+}));
+
+// Stub gmail-mime-helpers
+mock.module("../gmail-mime-helpers.js", () => ({
+  guessMimeType: () => "application/octet-stream",
+}));
+
+// Stub conversation dependencies used by messaging-send cross-post
+mock.module("../../../../../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "msg-1" }),
+  getConversation: () => null,
+}));
+mock.module("../../../../../memory/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+mock.module("../../../../../memory/external-conversation-store.js", () => ({
+  getBindingByChannelChat: () => null,
+}));
+
+const { run: runSend } = await import("../messaging-send.js");
+const { run: runArchive } = await import("../messaging-archive-by-sender.js");
+
+const baseContext = {
+  workingDir: "/tmp/test",
+  conversationId: "conv-xyz",
+  assistantId: "assistant-1",
+  triggeredBySurfaceAction: true,
+  batchAuthorizedByTask: false,
+  approvedViaPrompt: false,
+  trustClass: "guardian" as const,
+};
+
+beforeEach(() => {
+  emittedEvents.length = 0;
+  mockCreateDraft.mockClear();
+  mockCreateDraftRaw.mockClear();
+  mockSendMessage.mockClear();
+  mockArchiveByQuery.mockClear();
+});
+
+afterEach(() => {
+  emittedEvents.length = 0;
+});
+
+describe("messaging-send feed events", () => {
+  test("Gmail draft creation emits with source 'gmail' and dedup by draft ID", async () => {
+    await runSend(
+      {
+        platform: "gmail",
+        conversation_id: "recipient@example.com",
+        text: "Hello there",
+        subject: "Test",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    expect(emittedEvents[0].title).toBe("Email Draft Created");
+    expect(emittedEvents[0].dedupKey).toBe("email-draft:draft-123");
+  });
+
+  test("Slack sends emit with source 'slack'", async () => {
+    await runSend(
+      {
+        platform: "slack",
+        conversation_id: "#general",
+        text: "Hello Slack",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("slack");
+    expect(emittedEvents[0].title).toBe("Slack Message Sent");
+    expect(emittedEvents[0].dedupKey).toBe("message-sent:msg-sent-789");
+  });
+
+  test("Non-Gmail, non-Slack sends emit with source 'gmail' as fallback", async () => {
+    await runSend(
+      {
+        platform: "other-email",
+        conversation_id: "user@example.com",
+        text: "Hello",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    // Mock resolveProvider returns id:"gmail" for non-slack platforms,
+    // so this goes through the Gmail draft path
+    expect(emittedEvents[0].title).toBe("Email Draft Created");
+    expect(emittedEvents[0].summary).toBe("Created an email draft.");
+  });
+});
+
+describe("messaging-archive feed events", () => {
+  test("Archive emits only when result.archived > 0", async () => {
+    await runArchive(
+      { platform: "gmail", query: "from:sender@example.com" },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    expect(emittedEvents[0].title).toBe("Messages Archived");
+    expect(emittedEvents[0].summary).toContain("Archived 3 message(s)");
+  });
+
+  test("Zero-match archives do NOT emit", async () => {
+    mockArchiveByQuery.mockResolvedValueOnce({
+      archived: 0,
+      truncated: false,
+    });
+
+    await runArchive(
+      { platform: "gmail", query: "from:nobody@example.com" },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(0);
+  });
+});

package/src/config/bundled-skills/messaging/tools/gmail-mime-helpers.ts

@@ -4,7 +4,7 @@
 
 import { extname } from "node:path";
 
-export const MIME_MAP: Record<string, string> = {
+const MIME_MAP: Record<string, string> = {
   ".pdf": "application/pdf",
   ".zip": "application/zip",
   ".gz": "application/gzip",

package/src/config/bundled-skills/messaging/tools/messaging-analyze-style.ts

@@ -1,7 +1,7 @@
 import { and, eq, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb } from "../../../../memory/db.js";
+import { getDb } from "../../../../memory/db-connection.js";
 import { enqueueMemoryJob } from "../../../../memory/jobs-store.js";
 import { memoryGraphNodes } from "../../../../memory/schema.js";
 import { clampUnitInterval } from "../../../../memory/validation.js";

package/src/config/bundled-skills/messaging/tools/messaging-archive-by-sender.ts

@@ -1,9 +1,13 @@
+import { emitFeedEvent } from "../../../../home/emit-feed-event.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
+import { getLogger } from "../../../../util/logger.js";
 import { err, getProviderConnection, ok, resolveProvider } from "./shared.js";
 
+const log = getLogger("messaging-archive-by-sender");
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -46,6 +50,14 @@ export async function run(
     }
 
     const summary = `Archived ${result.archived} message(s) matching query: ${query}`;
+    void emitFeedEvent({
+      source: "gmail",
+      title: "Messages Archived",
+      summary,
+      dedupKey: `email-archive:${Date.now()}`,
+    }).catch((err) => {
+      log.warn({ err }, "Failed to emit email archive feed event");
+    });
     if (result.truncated) {
       return ok(
         `${summary}\n\nNote: this operation was capped at 5000 messages. Additional messages matching the query may remain in the inbox. Run the command again to archive more.`,