@vellumai/assistant 0.4.11 → 0.4.13

package/src/daemon/session-agent-loop-handlers.ts

@@ -53,6 +53,8 @@ export interface EventHandlerState {
   firstTextDeltaEmitted: boolean;
   /** Tracks whether a thinking delta has been emitted this turn for activity state transitions. */
   firstThinkingDeltaEmitted: boolean;
+  /** Name of the last completed tool, used to generate contextual statusText. */
+  lastCompletedToolName: string | undefined;
 }
 
 /** Immutable context shared across event handlers within a single agent loop run. */
@@ -92,6 +94,7 @@ export function createEventHandlerState(): EventHandlerState {
     currentTurnToolNames: [],
     firstTextDeltaEmitted: false,
     firstThinkingDeltaEmitted: false,
+    lastCompletedToolName: undefined,
   };
 }
 
@@ -130,6 +133,29 @@ function truncateForIpc(value: string, maxChars: number, suffix: string): string
   return value.slice(0, maxChars - suffix.length) + suffix;
 }
 
+// ── Friendly Tool Names ──────────────────────────────────────────────
+
+const TOOL_FRIENDLY_NAMES: Record<string, string> = {
+  bash: 'command',
+  web_search: 'web search',
+  web_fetch: 'web fetch',
+  file_read: 'file read',
+  file_write: 'file write',
+  file_edit: 'file edit',
+  browser_navigate: 'browser',
+  browser_click: 'browser',
+  browser_type: 'browser',
+  browser_screenshot: 'browser',
+  browser_scroll: 'browser',
+  browser_wait: 'browser',
+  app_create: 'app',
+  app_update: 'app',
+};
+
+function friendlyToolName(name: string): string {
+  return TOOL_FRIENDLY_NAMES[name] ?? name.replace(/_/g, ' ');
+}
+
 // ── Individual Handlers ──────────────────────────────────────────────
 
 export function handleTextDelta(
@@ -158,7 +184,18 @@ export function handleThinkingDelta(
 ): void {
   if (!state.firstThinkingDeltaEmitted) {
     state.firstThinkingDeltaEmitted = true;
-    deps.ctx.emitActivityState('thinking', 'thinking_delta', 'assistant_turn', deps.reqId);
+    const lastToolName = state.lastCompletedToolName;
+    // Only emit an activity state when a tool just completed, so we can
+    // show "Processing <tool> results". When no tool has completed yet
+    // (e.g. right after confirmation_resolved), skip the emission entirely
+    // so the client preserves its current status text (e.g. "Resuming
+    // after approval"). Even omitting statusText from the message would
+    // cause the client to clear it, since the client overwrites
+    // assistantStatusText for every assistant_activity_state event.
+    if (lastToolName) {
+      const statusText = `Processing ${friendlyToolName(lastToolName)} results`;
+      deps.ctx.emitActivityState('thinking', 'thinking_delta', 'assistant_turn', deps.reqId, statusText);
+    }
   }
   if (!deps.ctx.streamThinking) return;
   emitLlmCallStartedIfNeeded(state, deps);
@@ -172,7 +209,8 @@ export function handleToolUse(
 ): void {
   state.toolUseIdToName.set(event.id, event.name);
   state.currentTurnToolNames.push(event.name);
-  deps.ctx.emitActivityState('tool_running', 'tool_use_start', 'assistant_turn', deps.reqId);
+  const statusText = `Running ${friendlyToolName(event.name)}`;
+  deps.ctx.emitActivityState('tool_running', 'tool_use_start', 'assistant_turn', deps.reqId, statusText);
   deps.onEvent({ type: 'tool_use_start', toolName: event.name, input: event.input, sessionId: deps.ctx.conversationId });
 }
 
@@ -274,6 +312,9 @@ export function handleToolResult(
     }
   }
 
+  // Track last completed tool for contextual statusText on next thinking phase
+  state.lastCompletedToolName = state.toolUseIdToName.get(event.toolUseId);
+
   // Reset so that the next LLM exchange (think → stream) after this tool
   // call re-emits the activity state transitions.
   state.firstTextDeltaEmitted = false;

package/src/daemon/session-agent-loop.ts

@@ -98,6 +98,7 @@ export interface AgentLoopSessionContext {
   currentPage?: string;
   readonly surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
+  surfaceActionRequestIds: Set<string>;
   currentTurnSurfaces: Array<{ surfaceId: string; surfaceType: SurfaceType; title?: string; data: SurfaceData; actions?: Array<{ id: string; label: string; style?: string }>; display?: string }>;
 
   workingDir: string;
@@ -135,6 +136,7 @@ export interface AgentLoopSessionContext {
     reason: 'message_dequeued' | 'thinking_delta' | 'first_text_delta' | 'tool_use_start' | 'confirmation_requested' | 'confirmation_resolved' | 'message_complete' | 'generation_cancelled' | 'error_terminal',
     anchor?: 'assistant_turn' | 'user_turn' | 'global',
     requestId?: string,
+    statusText?: string,
   ): void;
   emitConfirmationStateChanged(params: import('./ipc-contract/messages.js').ConfirmationStateChanged extends { type: infer _ } ? Omit<import('./ipc-contract/messages.js').ConfirmationStateChanged, 'type'> : never): void;
 
@@ -839,6 +841,7 @@ export async function runAgentLoopImpl(
 
     ctx.abortController = null;
     ctx.processing = false;
+    ctx.surfaceActionRequestIds.delete(ctx.currentRequestId ?? '');
     ctx.currentRequestId = undefined;
     ctx.currentActiveSurfaceId = undefined;
     ctx.allowedToolNames = undefined;

package/src/daemon/session-lifecycle.ts

@@ -70,6 +70,7 @@ export interface AbortContext {
   prompter: PermissionPrompter;
   secretPrompter: SecretPrompter;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
+  surfaceActionRequestIds: Set<string>;
   surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>;
   readonly queue: MessageQueue;
 }
@@ -159,6 +160,7 @@ export function abortSession(ctx: AbortContext): void {
     ctx.prompter.dispose();
     ctx.secretPrompter.dispose();
     ctx.pendingSurfaceActions.clear();
+    ctx.surfaceActionRequestIds.clear();
     ctx.surfaceState.clear();
     unregisterWatchNotifiers(ctx.conversationId);
     for (const queued of ctx.queue) {
@@ -186,6 +188,7 @@ export function disposeSession(ctx: DisposeContext): void {
   ctx.surfaceUndoStacks.clear();
   ctx.currentTurnSurfaces = [];
   ctx.pendingSurfaceActions.clear();
+  ctx.surfaceActionRequestIds.clear();
   ctx.surfaceState.clear();
   ctx.lastSurfaceAction.clear();
   ctx.workspaceTopLevelContext = null;

package/src/daemon/session-process.ts

@@ -92,6 +92,7 @@ export interface ProcessSessionContext {
     reason: 'message_dequeued' | 'thinking_delta' | 'first_text_delta' | 'tool_use_start' | 'confirmation_requested' | 'confirmation_resolved' | 'message_complete' | 'generation_cancelled' | 'error_terminal',
     anchor?: 'assistant_turn' | 'user_turn' | 'global',
     requestId?: string,
+    statusText?: string,
   ): void;
 }
 

package/src/daemon/session-surfaces.ts

@@ -4,7 +4,7 @@ import {
   findSeededHomeBaseApp,
   getPrebuiltHomeBasePreview,
 } from '../home-base/prebuilt/seed.js';
-import { getApp, updateApp } from '../memory/app-store.js';
+import { getApp, getAppPreview, updateApp } from '../memory/app-store.js';
 import type { ToolExecutionResult } from '../tools/types.js';
 import { getLogger } from '../util/logger.js';
 import { isPlainObject } from '../util/object.js';
@@ -133,6 +133,8 @@ export interface SurfaceSessionContext {
   lastSurfaceAction: Map<string, { actionId: string; data?: Record<string, unknown> }>;
   surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>;
   surfaceUndoStacks: Map<string, string[]>;
+  /** Request IDs that originated from surface action button clicks (not regular user messages). */
+  surfaceActionRequestIds: Set<string>;
   currentTurnSurfaces: Array<{
     surfaceId: string;
     surfaceType: SurfaceType;
@@ -393,24 +395,19 @@ export function handleSurfaceAction(ctx: SurfaceSessionContext, surfaceId: strin
       ? data.prompt.trim()
       : '';
 
-  // Build a human-readable summary for confirmation surfaces so the LLM
-  // clearly understands the user's decision instead of parsing raw JSON.
-  let fallbackContent: string;
-  if (pending.surfaceType === 'confirmation') {
-    const summary = buildCompletionSummary('confirmation', actionId, data);
-    fallbackContent = `[User action on confirmation surface: ${summary}]`;
-  } else {
-    fallbackContent = JSON.stringify({
-      surfaceAction: true,
-      surfaceId,
-      surfaceType: pending.surfaceType,
-      actionId,
-      data: data ?? {},
-    });
+  // Build a human-readable summary so the LLM clearly understands the
+  // user's decision instead of parsing raw JSON.
+  const summary = buildCompletionSummary(pending.surfaceType, actionId, data);
+  let fallbackContent = `[User action on ${pending.surfaceType} surface: ${summary}]`;
+  // Append structured data so the LLM has access to IDs/values it needs
+  // to act on (e.g. selectedIds for archiving).
+  if (data && Object.keys(data).length > 0) {
+    fallbackContent += `\n\nAction data: ${JSON.stringify(data)}`;
   }
   const content = prompt || fallbackContent;
 
   const requestId = uuid();
+  ctx.surfaceActionRequestIds.add(requestId);
   const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
 
   // Echo the user's prompt to the client so it appears in the chat UI
@@ -534,13 +531,15 @@ export function buildCompletionSummary(surfaceType: string | undefined, actionId
   }
   if (surfaceType === 'list' && data) {
     const selectedIds = data.selectedIds as string[] | undefined;
-    if (selectedIds?.length === 1) return `Selected: ${selectedIds[0]}`;
-    if (selectedIds?.length) return `Selected ${selectedIds.length} items`;
+    const actionSuffix = actionId ? ` (action: ${actionId})` : '';
+    if (selectedIds?.length === 1) return `Selected: ${selectedIds[0]}${actionSuffix}`;
+    if (selectedIds?.length) return `Selected ${selectedIds.length} items${actionSuffix}`;
   }
   if (surfaceType === 'table' && data) {
     const selectedIds = data.selectedIds as string[] | undefined;
-    if (selectedIds?.length === 1) return `Selected 1 row`;
-    if (selectedIds?.length) return `Selected ${selectedIds.length} rows`;
+    const actionSuffix = actionId ? ` (action: ${actionId})` : '';
+    if (selectedIds?.length === 1) return `Selected 1 row${actionSuffix}`;
+    if (selectedIds?.length) return `Selected ${selectedIds.length} rows${actionSuffix}`;
   }
   return actionId.charAt(0).toUpperCase() + actionId.slice(1);
 }
@@ -608,6 +607,7 @@ export async function surfaceProxyResolver(
         message: 'File upload dialog displayed and the user can see it. The uploaded file data will arrive as a follow-up message. Do not output any waiting message — just stop here.',
       }),
       isError: false,
+      yieldToUser: true,
     };
   }
 
@@ -668,6 +668,7 @@ export async function surfaceProxyResolver(
           message: 'Surface displayed and the user can see it. Their response will arrive as a follow-up message. Do not output any waiting message — just stop here.',
         }),
         isError: false,
+        yieldToUser: true,
       };
     }
     return { content: JSON.stringify({ surfaceId }), isError: false };
@@ -772,11 +773,12 @@ export async function surfaceProxyResolver(
       // un-clickable fallback chip) after session restart.
       : { title: app.name, subtitle: app.description };
 
+    const storedPreview = getAppPreview(app.id);
     const surfaceData: DynamicPageSurfaceData = {
       html: app.htmlDefinition,
       appId: app.id,
       appType: app.appType,
-      preview: preview ?? defaultPreview,
+      preview: { ...defaultPreview, ...preview, ...(storedPreview ? { previewImage: storedPreview } : {}) },
     };
     const surfaceId = uuid();
     ctx.surfaceState.set(surfaceId, {

package/src/daemon/session-tool-setup.ts

@@ -113,6 +113,7 @@ export function createToolExecutor(
       guardianTrustClass: ctx.guardianContext?.trustClass ?? 'guardian',
       executionChannel: ctx.guardianContext?.sourceChannel,
       callSessionId: ctx.callSessionId,
+      triggeredBySurfaceAction: ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? '') ?? false,
       requesterExternalUserId: ctx.guardianContext?.requesterExternalUserId,
       requesterChatId: ctx.guardianContext?.requesterChatId,
       onOutput,

package/src/daemon/session.ts

@@ -146,6 +146,7 @@ export class Session {
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ assistantId?: string;
   /** @internal */ commandIntent?: { type: string; payload?: string; languageCode?: string };
+  /** @internal */ surfaceActionRequestIds = new Set<string>();
   /** @internal */ pendingSurfaceActions = new Map<string, { surfaceType: SurfaceType }>();
   /** @internal */ lastSurfaceAction = new Map<string, { actionId: string; data?: Record<string, unknown> }>();
   /** @internal */ surfaceState = new Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>();
@@ -205,7 +206,7 @@ export class Session {
       if (state === 'pending') {
         this.emitActivityState('awaiting_confirmation', 'confirmation_requested', 'assistant_turn');
       } else if (state === 'timed_out') {
-        this.emitActivityState('thinking', 'confirmation_resolved', 'assistant_turn');
+        this.emitActivityState('thinking', 'confirmation_resolved', 'assistant_turn', undefined, 'Resuming after timeout');
       }
     });
     this.secretPrompter = new SecretPrompter(sendToClient);
@@ -520,7 +521,7 @@ export class Session {
       ...(emissionContext?.causedByRequestId ? { causedByRequestId: emissionContext.causedByRequestId } : {}),
       ...(emissionContext?.decisionText ? { decisionText: emissionContext.decisionText } : {}),
     });
-    this.emitActivityState('thinking', 'confirmation_resolved', 'assistant_turn');
+    this.emitActivityState('thinking', 'confirmation_resolved', 'assistant_turn', undefined, 'Resuming after approval');
   }
 
   handleSecretResponse(requestId: string, value?: string, delivery?: 'store' | 'transient_send'): void {
@@ -540,6 +541,7 @@ export class Session {
     reason: AssistantActivityState['reason'],
     anchor: AssistantActivityState['anchor'] = 'assistant_turn',
     requestId?: string,
+    statusText?: string,
   ): void {
     this.activityVersion++;
     const msg: ServerMessage = {
@@ -550,6 +552,7 @@ export class Session {
       anchor,
       requestId,
       reason,
+      ...(statusText ? { statusText } : {}),
     } as ServerMessage;
     this.sendToClient(msg);
     this.onStateSignal?.(msg);

package/src/messaging/outreach-classifier.ts

@@ -12,6 +12,7 @@ const log = getLogger('outreach-classifier');
 const MODEL_INTENT = 'latency-optimized' as const;
 const TIMEOUT_MS = 30_000;
 const BATCH_SIZE = 100;
+const CLASSIFY_CONCURRENCY = 3;
 
 export type OutreachType = 'sales' | 'recruiting' | 'marketing' | 'other';
 
@@ -128,12 +129,18 @@ async function classifyBatch(emails: EmailMetadata[]): Promise<OutreachClassific
 export async function classifyOutreach(emails: EmailMetadata[]): Promise<OutreachClassification[]> {
   if (emails.length === 0) return [];
 
-  const results: OutreachClassification[] = [];
-
+  // Split into batches
+  const batches: EmailMetadata[][] = [];
   for (let i = 0; i < emails.length; i += BATCH_SIZE) {
-    const batch = emails.slice(i, i + BATCH_SIZE);
-    const batchResults = await classifyBatch(batch);
-    results.push(...batchResults);
+    batches.push(emails.slice(i, i + BATCH_SIZE));
+  }
+
+  // Process batches with bounded concurrency
+  const results: OutreachClassification[] = [];
+  for (let i = 0; i < batches.length; i += CLASSIFY_CONCURRENCY) {
+    const concurrentBatches = batches.slice(i, i + CLASSIFY_CONCURRENCY);
+    const batchResults = await Promise.all(concurrentBatches.map((batch) => classifyBatch(batch)));
+    for (const r of batchResults) results.push(...r);
   }
 
   return results;

package/src/messaging/provider-types.ts

@@ -10,6 +10,7 @@ export interface Conversation {
   memberCount?: number;
   topic?: string;
   isArchived?: boolean;
+  isPrivate?: boolean;
   metadata?: Record<string, unknown>;
 }
 
@@ -99,6 +100,10 @@ export interface SenderDigestResult {
   senders: SenderDigestEntry[];
   totalScanned: number;
   queryUsed: string;
+  /** True when pagination was stopped because the scan cap was reached but more messages exist. */
+  truncated?: boolean;
+  /** Resume token for sequential scanning — present when truncated is true. */
+  nextPageToken?: string;
 }
 
 export interface ArchiveResult {

package/src/messaging/provider.ts

@@ -41,7 +41,7 @@ export interface MessagingProvider {
   markRead?(token: string, conversationId: string, messageId?: string): Promise<void>;
 
   /** Scan messages and group by sender for bulk cleanup (e.g. newsletter decluttering). */
-  senderDigest?(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number }): Promise<SenderDigestResult>;
+  senderDigest?(token: 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>;
 

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

@@ -195,13 +195,14 @@ export const gmailMessagingProvider: MessagingProvider = {
     await gmail.modifyMessage(token, messageId, { removeLabelIds: ['UNREAD'] });
   },
 
-  async senderDigest(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number }): Promise<SenderDigestResult> {
-    const maxMessages = Math.min(options?.maxMessages ?? 500, 2000);
+  async senderDigest(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number; pageToken?: string }): Promise<SenderDigestResult> {
+    const maxMessages = Math.min(options?.maxMessages ?? 2000, 2000);
     const maxSenders = options?.maxSenders ?? 30;
-    const maxIdsPerSender = 1000;
+    const maxIdsPerSender = 2000;
 
     const allMessageIds: string[] = [];
-    let pageToken: string | undefined;
+    let pageToken: string | undefined = options?.pageToken;
+    let truncated = false;
 
     while (allMessageIds.length < maxMessages) {
       const pageSize = Math.min(100, maxMessages - allMessageIds.length);
@@ -213,6 +214,11 @@ export const gmailMessagingProvider: MessagingProvider = {
       if (!pageToken) break;
     }
 
+    // If we stopped because we hit the cap but there were still more pages, flag truncation
+    if (allMessageIds.length >= maxMessages && pageToken) {
+      truncated = true;
+    }
+
     if (allMessageIds.length === 0) {
       return { senders: [], totalScanned: 0, queryUsed: query };
     }
@@ -283,7 +289,7 @@ export const gmailMessagingProvider: MessagingProvider = {
       hasMore: s.hasMore,
     }));
 
-    return { senders, totalScanned: allMessageIds.length, queryUsed: query };
+    return { senders, totalScanned: allMessageIds.length, queryUsed: query, ...(truncated ? { truncated, nextPageToken: pageToken } : {}) };
   },
 
   async archiveByQuery(token: string, query: string): Promise<ArchiveResult> {

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

@@ -33,6 +33,7 @@ export class GmailApiError extends Error {
 
 const MAX_RETRIES = 3;
 const INITIAL_BACKOFF_MS = 1000;
+const REQUEST_TIMEOUT_MS = 30_000;
 
 function isRetryable(status: number): boolean {
   return status === 429 || (status >= 500 && status < 600);
@@ -57,6 +58,7 @@ async function request<T>(token: string, path: string, options?: GmailRequestOpt
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     const resp = await fetch(url, {
       ...options,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
       headers: {
         Authorization: `Bearer ${token}`,
         'Content-Type': 'application/json',

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

@@ -60,6 +60,7 @@ function mapConversation(conv: SlackConversation): Conversation {
     memberCount: conv.num_members,
     topic: conv.topic?.value || undefined,
     isArchived: conv.is_archived,
+    isPrivate: conv.is_private ?? conv.is_group ?? false,
     metadata: conv.is_im ? { dmUserId: conv.user } : undefined,
   };
 }

package/src/messaging/providers/slack/client.ts

@@ -10,6 +10,7 @@ import type {
   SlackAuthTestResponse,
   SlackChatDeleteResponse,
   SlackConversationHistoryResponse,
+  SlackConversationInfoResponse,
   SlackConversationLeaveResponse,
   SlackConversationMarkResponse,
   SlackConversationRepliesResponse,
@@ -95,6 +96,13 @@ export async function listConversations(
   });
 }
 
+export async function conversationInfo(
+  token: string,
+  channel: string,
+): Promise<SlackConversationInfoResponse> {
+  return request<SlackConversationInfoResponse>(token, 'conversations.info', { channel });
+}
+
 export async function conversationHistory(
   token: string,
   channel: string,

package/src/messaging/providers/slack/types.ts

@@ -20,6 +20,7 @@ export interface SlackConversation {
   is_group?: boolean;
   is_im?: boolean;
   is_mpim?: boolean;
+  is_private?: boolean;
   is_archived?: boolean;
   is_member?: boolean;
   topic?: { value: string };
@@ -108,6 +109,10 @@ export interface SlackSearchMatch {
   thread_ts?: string;
 }
 
+export interface SlackConversationInfoResponse extends SlackApiResponse {
+  channel: SlackConversation;
+}
+
 export interface SlackConversationsOpenResponse extends SlackApiResponse {
   channel: { id: string };
 }

package/src/runtime/http-errors.ts

@@ -16,16 +16,17 @@
  * internal assistant-layer errors.
  */
 export type HttpErrorCode =
-  | 'BAD_REQUEST'
-  | 'UNAUTHORIZED'
-  | 'FORBIDDEN'
-  | 'NOT_FOUND'
-  | 'CONFLICT'
-  | 'GONE'
-  | 'RATE_LIMITED'
-  | 'UNPROCESSABLE_ENTITY'
-  | 'INTERNAL_ERROR'
-  | 'SERVICE_UNAVAILABLE';
+  | "BAD_REQUEST"
+  | "UNAUTHORIZED"
+  | "FORBIDDEN"
+  | "NOT_FOUND"
+  | "CONFLICT"
+  | "GONE"
+  | "RATE_LIMITED"
+  | "UNPROCESSABLE_ENTITY"
+  | "INTERNAL_ERROR"
+  | "NOT_IMPLEMENTED"
+  | "SERVICE_UNAVAILABLE";
 
 // ── Response type ────────────────────────────────────────────────────────────
 
@@ -79,15 +80,27 @@ export function httpError(
  */
 export function httpErrorCodeFromStatus(status: number): HttpErrorCode {
   switch (status) {
-    case 400: return 'BAD_REQUEST';
-    case 401: return 'UNAUTHORIZED';
-    case 403: return 'FORBIDDEN';
-    case 404: return 'NOT_FOUND';
-    case 409: return 'CONFLICT';
-    case 410: return 'GONE';
-    case 422: return 'UNPROCESSABLE_ENTITY';
-    case 429: return 'RATE_LIMITED';
-    case 503: return 'SERVICE_UNAVAILABLE';
-    default:  return 'INTERNAL_ERROR';
+    case 400:
+      return "BAD_REQUEST";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+      return "NOT_FOUND";
+    case 409:
+      return "CONFLICT";
+    case 410:
+      return "GONE";
+    case 422:
+      return "UNPROCESSABLE_ENTITY";
+    case 429:
+      return "RATE_LIMITED";
+    case 501:
+      return "NOT_IMPLEMENTED";
+    case 503:
+      return "SERVICE_UNAVAILABLE";
+    default:
+      return "INTERNAL_ERROR";
   }
 }