@vellumai/assistant 0.4.45 → 0.4.48

package/src/media/avatar-router.ts

@@ -1,33 +1,42 @@
-/**
- * Avatar generation router.
- * Tries managed platform path if available, falls back to local Gemini.
- */
-
 import { getConfig } from "../config/loader.js";
+import {
+  buildManagedBaseUrl,
+  resolveManagedProxyContext,
+} from "../providers/managed-proxy/context.js";
 import { ConfigError, ProviderError } from "../util/errors.js";
-import { getLogger } from "../util/logger.js";
-import type { AvatarGenerationResult } from "./avatar-types.js";
-import { generateImage } from "./gemini-image-service.js";
 import {
-  generateManagedAvatar,
-  isManagedAvailable,
-} from "./managed-avatar-client.js";
+  generateImage,
+  type ImageGenCredentials,
+} from "./gemini-image-service.js";
 
-const log = getLogger("avatar-router");
-
-async function generateLocal(
+export async function generateAvatar(
   prompt: string,
-  correlationId?: string,
-): Promise<AvatarGenerationResult> {
+): Promise<{ imageBase64: string; mimeType: string }> {
   const config = getConfig();
   const geminiKey = config.apiKeys.gemini ?? process.env.GEMINI_API_KEY;
-  if (!geminiKey) {
+
+  let credentials: ImageGenCredentials | undefined;
+  if (geminiKey) {
+    credentials = { type: "direct", apiKey: geminiKey };
+  } else {
+    const managedBaseUrl = buildManagedBaseUrl("vertex");
+    if (managedBaseUrl) {
+      const ctx = resolveManagedProxyContext();
+      credentials = {
+        type: "managed-proxy",
+        assistantApiKey: ctx.assistantApiKey,
+        baseUrl: managedBaseUrl,
+      };
+    }
+  }
+
+  if (!credentials) {
     throw new ConfigError(
       "Gemini API key is not configured. Set it via `config set apiKeys.gemini <key>` or the GEMINI_API_KEY environment variable.",
     );
   }
 
-  const result = await generateImage(geminiKey, {
+  const result = await generateImage(credentials, {
     prompt,
     mode: "generate",
     model: config.imageGenModel,
@@ -36,7 +45,7 @@ async function generateLocal(
   const image = result.images[0];
   if (!image) {
     throw new ProviderError(
-      "Local Gemini image generation returned no images.",
+      "Gemini image generation returned no images.",
       "gemini",
     );
   }
@@ -44,48 +53,5 @@ async function generateLocal(
   return {
     imageBase64: image.dataBase64,
     mimeType: image.mimeType,
-    pathUsed: "local",
-    correlationId,
   };
 }
-
-export async function routedGenerateAvatar(
-  prompt: string,
-  options?: { correlationId?: string; model?: string },
-): Promise<AvatarGenerationResult> {
-  const correlationId = options?.correlationId;
-  const model = options?.model;
-
-  // Try managed platform path if available, fall back to local Gemini
-  if (isManagedAvailable()) {
-    try {
-      const managed = await generateManagedAvatar(prompt, {
-        correlationId,
-        model,
-      });
-      return {
-        imageBase64: managed.image.data_base64,
-        mimeType: managed.image.mime_type,
-        pathUsed: "managed",
-        correlationId: managed.correlation_id,
-        model,
-      };
-    } catch (err) {
-      const config = getConfig();
-      const geminiKey = config.apiKeys.gemini ?? process.env.GEMINI_API_KEY;
-      if (!geminiKey) {
-        log.warn(
-          { err: err instanceof Error ? err.message : String(err) },
-          "Managed avatar generation failed and no local Gemini key configured; re-throwing",
-        );
-        throw err;
-      }
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "Managed avatar generation failed, falling back to local Gemini",
-      );
-    }
-  }
-
-  return generateLocal(prompt, correlationId);
-}

package/src/media/gemini-image-service.ts

@@ -13,6 +13,21 @@ export interface ImageGenerationRequest {
   variants?: number;
 }
 
+/** Credentials for direct Gemini API access. */
+export interface DirectCredentials {
+  type: "direct";
+  apiKey: string;
+}
+
+/** Credentials for managed proxy access via Vertex AI. */
+export interface ManagedProxyCredentials {
+  type: "managed-proxy";
+  assistantApiKey: string;
+  baseUrl: string;
+}
+
+export type ImageGenCredentials = DirectCredentials | ManagedProxyCredentials;
+
 export interface GeneratedImage {
   mimeType: string;
   dataBase64: string;
@@ -64,7 +79,7 @@ export function mapGeminiError(error: unknown): string {
 // --- Core function ---
 
 export async function generateImage(
-  apiKey: string,
+  credentials: ImageGenCredentials,
   request: ImageGenerationRequest,
 ): Promise<ImageGenerationResult> {
   const model =
@@ -74,7 +89,18 @@ export async function generateImage(
 
   const variants = Math.max(1, Math.min(request.variants ?? 1, MAX_VARIANTS));
 
-  const client = new GoogleGenAI({ apiKey });
+  const client =
+    credentials.type === "managed-proxy"
+      ? new GoogleGenAI({
+          vertexai: true,
+          project: "proxy",
+          location: "us-central1",
+          httpOptions: {
+            baseUrl: credentials.baseUrl,
+            headers: { Authorization: `Bearer ${credentials.assistantApiKey}` },
+          },
+        })
+      : new GoogleGenAI({ apiKey: credentials.apiKey });
 
   // Build contents array — append a title request so the model's text
   // response contains a short filename-safe title for the generated image.

package/src/memory/canonical-guardian-store.ts

@@ -551,7 +551,7 @@ export function listPendingCanonicalGuardianRequestsByDestinationConversation(
  * This bridges inbound guardian replies (which arrive on a specific chat)
  * back to their canonical request records. Unlike the conversation-based
  * variant, this uses the chat-level addressing that channel transports
- * (Telegram, SMS) natively provide — critical for voice-originated
+ * (Telegram) natively provide — critical for voice-originated
  * `pending_question` requests that lack `guardianExternalUserId`.
  */
 export function listPendingCanonicalGuardianRequestsByDestinationChat(

package/src/memory/guardian-action-store.ts

@@ -44,7 +44,7 @@ export type FollowupState =
   | "completed"
   | "declined"
   | "failed";
-export type FollowupAction = "call_back" | "message_back" | "decline";
+export type FollowupAction = "call_back" | "decline";
 
 export interface GuardianActionRequest {
   id: string;

package/src/memory/schema/guardian.ts

@@ -27,7 +27,7 @@ export const guardianActionRequests = sqliteTable(
     followupState: text("followup_state").notNull().default("none"), // none | awaiting_guardian_choice | dispatching | completed | declined | failed
     lateAnswerText: text("late_answer_text"),
     lateAnsweredAt: integer("late_answered_at"),
-    followupAction: text("followup_action"), // call_back | message_back | decline
+    followupAction: text("followup_action"), // call_back | decline
     followupCompletedAt: integer("followup_completed_at"),
     toolName: text("tool_name"), // tool identity for tool-approval requests
     inputDigest: text("input_digest"), // canonical SHA-256 digest of tool input

package/src/messaging/provider.ts

@@ -5,6 +5,7 @@
  * implementing one adapter file + an OAuth setup skill.
  */
 
+import type { OAuthConnection } from "../oauth/connection.js";
 import type {
   ArchiveResult,
   ConnectionInfo,
@@ -29,23 +30,25 @@ export interface MessagingProvider {
 
   // ── Universal operations (every platform must implement) ──────────
 
-  testConnection(token: string): Promise<ConnectionInfo>;
+  testConnection(
+    connectionOrToken: OAuthConnection | string,
+  ): Promise<ConnectionInfo>;
   listConversations(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     options?: ListOptions,
   ): Promise<Conversation[]>;
   getHistory(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     conversationId: string,
     options?: HistoryOptions,
   ): Promise<Message[]>;
   search(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     query: string,
     options?: SearchOptions,
   ): Promise<SearchResult>;
   sendMessage(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     conversationId: string,
     text: string,
     options?: SendOptions,
@@ -54,30 +57,33 @@ export interface MessagingProvider {
   // ── Optional operations (platforms implement what they support) ───
 
   getThreadReplies?(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     conversationId: string,
     threadId: string,
     options?: HistoryOptions,
   ): Promise<Message[]>;
   markRead?(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     conversationId: string,
     messageId?: string,
   ): Promise<void>;
 
   /** Scan messages and group by sender for bulk cleanup (e.g. newsletter decluttering). */
   senderDigest?(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     query: string,
     options?: { maxMessages?: number; maxSenders?: number; pageToken?: string },
   ): Promise<SenderDigestResult>;
   /** Archive messages matching a search query. */
-  archiveByQuery?(token: string, query: string): Promise<ArchiveResult>;
+  archiveByQuery?(
+    connectionOrToken: OAuthConnection | string,
+    query: string,
+  ): Promise<ArchiveResult>;
 
   /**
    * Override the default credential check used by getConnectedProviders().
    * When present, the registry calls this instead of looking for
-   * credential:${credentialService}:access_token. Useful for providers
+   * credential/{credentialService}/access_token. Useful for providers
    * that don't use OAuth (e.g. Telegram bot tokens stored under a
    * non-standard key).
    */

package/src/messaging/providers/gmail/adapter.ts

@@ -5,6 +5,7 @@
  * and implements the MessagingProvider interface.
  */
 
+import type { OAuthConnection } from "../../../oauth/connection.js";
 import type { MessagingProvider } from "../../provider.js";
 import type {
   ArchiveResult,
@@ -94,8 +95,11 @@ export const gmailMessagingProvider: MessagingProvider = {
     "unsubscribe",
   ]),
 
-  async testConnection(token: string): Promise<ConnectionInfo> {
-    const profile = await gmail.getProfile(token);
+  async testConnection(
+    connectionOrToken: OAuthConnection | string,
+  ): Promise<ConnectionInfo> {
+    const connection = connectionOrToken as OAuthConnection;
+    const profile = await gmail.getProfile(connection);
     return {
       connected: true,
       user: profile.emailAddress,
@@ -108,11 +112,12 @@ export const gmailMessagingProvider: MessagingProvider = {
   },
 
   async listConversations(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     _options?: ListOptions,
   ): Promise<Conversation[]> {
+    const connection = connectionOrToken as OAuthConnection;
     // Gmail "conversations" are modeled as labels with unread counts
-    const labels = await gmail.listLabels(token);
+    const labels = await gmail.listLabels(connection);
     const conversations: Conversation[] = [];
 
     for (const label of labels) {
@@ -151,14 +156,15 @@ export const gmailMessagingProvider: MessagingProvider = {
   },
 
   async getHistory(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     conversationId: string,
     options?: HistoryOptions,
   ): Promise<Message[]> {
+    const connection = connectionOrToken as OAuthConnection;
     // conversationId is a label ID — list messages in that label
     const limit = options?.limit ?? 50;
     const listResult = await gmail.listMessages(
-      token,
+      connection,
       undefined,
       limit,
       undefined,
@@ -168,7 +174,7 @@ export const gmailMessagingProvider: MessagingProvider = {
     if (!listResult.messages?.length) return [];
 
     const messages = await gmail.batchGetMessages(
-      token,
+      connection,
       listResult.messages.map((m) => m.id),
       "full",
     );
@@ -177,19 +183,20 @@ export const gmailMessagingProvider: MessagingProvider = {
   },
 
   async search(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     query: string,
     options?: SearchOptions,
   ): Promise<SearchResult> {
+    const connection = connectionOrToken as OAuthConnection;
     const count = options?.count ?? 20;
-    const listResult = await gmail.listMessages(token, query, count);
+    const listResult = await gmail.listMessages(connection, query, count);
 
     if (!listResult.messages?.length) {
       return { total: 0, messages: [], hasMore: false };
     }
 
     const messages = await gmail.batchGetMessages(
-      token,
+      connection,
       listResult.messages.map((m) => m.id),
       "full",
     );
@@ -203,16 +210,17 @@ export const gmailMessagingProvider: MessagingProvider = {
   },
 
   async sendMessage(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     conversationId: string,
     text: string,
     options?: SendOptions,
   ): Promise<SendResult> {
+    const connection = connectionOrToken as OAuthConnection;
     // conversationId is the recipient email for Gmail
     const to = conversationId;
     const subject = options?.subject ?? "";
     const msg = await gmail.sendMessage(
-      token,
+      connection,
       to,
       subject,
       text,
@@ -228,15 +236,16 @@ export const gmailMessagingProvider: MessagingProvider = {
   },
 
   async getThreadReplies(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     _conversationId: string,
     threadId: string,
     options?: HistoryOptions,
   ): Promise<Message[]> {
+    const connection = connectionOrToken as OAuthConnection;
     // Get all messages in a Gmail thread
     const limit = options?.limit ?? 50;
     const listResult = await gmail.listMessages(
-      token,
+      connection,
       `thread:${threadId}`,
       limit,
     );
@@ -244,7 +253,7 @@ export const gmailMessagingProvider: MessagingProvider = {
     if (!listResult.messages?.length) return [];
 
     const messages = await gmail.batchGetMessages(
-      token,
+      connection,
       listResult.messages.map((m) => m.id),
       "full",
     );
@@ -253,19 +262,23 @@ export const gmailMessagingProvider: MessagingProvider = {
   },
 
   async markRead(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     _conversationId: string,
     messageId?: string,
   ): Promise<void> {
+    const connection = connectionOrToken as OAuthConnection;
     if (!messageId) return;
-    await gmail.modifyMessage(token, messageId, { removeLabelIds: ["UNREAD"] });
+    await gmail.modifyMessage(connection, messageId, {
+      removeLabelIds: ["UNREAD"],
+    });
   },
 
   async senderDigest(
-    token: string,
+    connectionOrToken: OAuthConnection | string,
     query: string,
     options?: { maxMessages?: number; maxSenders?: number; pageToken?: string },
   ): Promise<SenderDigestResult> {
+    const connection = connectionOrToken as OAuthConnection;
     const maxMessages = Math.min(options?.maxMessages ?? 5000, 5000);
     const maxSenders = options?.maxSenders ?? 30;
     const maxIdsPerSender = 5000;
@@ -285,7 +298,7 @@ export const gmailMessagingProvider: MessagingProvider = {
       }
       const pageSize = Math.min(100, maxMessages - allMessageIds.length);
       const listResp = await gmail.listMessages(
-        token,
+        connection,
         query,
         pageSize,
         pageToken,
@@ -295,7 +308,7 @@ export const gmailMessagingProvider: MessagingProvider = {
       allMessageIds.push(...ids);
       fetchPromises.push(
         gmail.batchGetMessages(
-          token,
+          connection,
           ids,
           "metadata",
           metadataHeaders,
@@ -409,7 +422,11 @@ export const gmailMessagingProvider: MessagingProvider = {
     };
   },
 
-  async archiveByQuery(token: string, query: string): Promise<ArchiveResult> {
+  async archiveByQuery(
+    connectionOrToken: OAuthConnection | string,
+    query: string,
+  ): Promise<ArchiveResult> {
+    const connection = connectionOrToken as OAuthConnection;
     const maxMessages = 5000;
     const batchModifyLimit = 1000;
 
@@ -419,7 +436,7 @@ export const gmailMessagingProvider: MessagingProvider = {
 
     while (allMessageIds.length < maxMessages) {
       const listResp = await gmail.listMessages(
-        token,
+        connection,
         query,
         Math.min(500, maxMessages - allMessageIds.length),
         pageToken,
@@ -441,7 +458,7 @@ export const gmailMessagingProvider: MessagingProvider = {
 
     for (let i = 0; i < allMessageIds.length; i += batchModifyLimit) {
       const chunk = allMessageIds.slice(i, i + batchModifyLimit);
-      await gmail.batchModifyMessages(token, chunk, {
+      await gmail.batchModifyMessages(connection, chunk, {
         removeLabelIds: ["INBOX"],
       });
     }