@vellumai/assistant 0.4.44 → 0.4.45

package/src/runtime/routes/settings-routes.ts

@@ -1,34 +1,17 @@
 /**
  * HTTP route handlers for settings, identity/avatar, voice config,
- * OAuth connect, Twitter auth, and workspace files.
+ * OAuth connect, and workspace files.
  *
- * Migrated from IPC handlers:
- *   - handlers/config-voice.ts (voice_config_update)
- *   - handlers/avatar.ts (generate_avatar)
- *   - handlers/oauth-connect.ts (oauth_connect_start)
- *   - handlers/twitter-auth.ts (twitter_auth_start, twitter_auth_status)
- *   - handlers/workspace-files.ts (workspace_files_list, workspace_file_read)
+ * Handles settings, identity/avatar, voice config,
+ * OAuth connect, and workspace files.
  *   - handlers/config-tools.ts (tool_names_list, tool_permission_simulate, env_vars_request)
  */
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import {
-  getPlatformAssistantId,
-  getPlatformBaseUrl,
-} from "../../config/env.js";
-import {
-  getNestedValue,
-  invalidateConfigCache,
-  loadConfig,
-  loadRawConfig,
-  saveRawConfig,
-  setNestedValue,
-} from "../../config/loader.js";
 import { loadSkillCatalog } from "../../config/skills.js";
 import { normalizeActivationKey } from "../../daemon/handlers/config-voice.js";
-import { getPublicBaseUrl } from "../../inbound/public-ingress-urls.js";
 import { orchestrateOAuthConnect } from "../../oauth/connect-orchestrator.js";
 import {
   getProviderProfile,
@@ -50,7 +33,6 @@ import {
 import { getAllTools, getTool } from "../../tools/registry.js";
 import { isSideEffectTool } from "../../tools/side-effects.js";
 import { setAvatarTool } from "../../tools/system/avatar-generator.js";
-import { ConfigError } from "../../util/errors.js";
 import { pathExists } from "../../util/fs.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -69,9 +51,8 @@ function handleVoiceConfigUpdate(activationKey: string): Response {
   if (!result.ok) {
     return httpError("BAD_REQUEST", result.reason, 400);
   }
-  // The broadcast to IPC clients happens via the IPC handler. The HTTP
-  // route validates and returns the canonical value; the caller (client)
-  // applies the setting locally.
+  // The HTTP route validates and returns the canonical value; the caller
+  // (client) applies the setting locally.
   return Response.json({ ok: true, activationKey: result.value });
 }
 
@@ -258,228 +239,7 @@ async function handleOAuthConnectStart(body: {
 }
 
 // ---------------------------------------------------------------------------
-// Twitter auth
-// ---------------------------------------------------------------------------
-
-function sanitizeTwitterAuthError(message: string): string {
-  const lower = message.toLowerCase();
-  if (lower.includes("timed out")) {
-    return "Twitter authentication timed out. Please try again.";
-  }
-  if (lower.includes("user_cancelled") || lower.includes("cancelled")) {
-    return "Twitter authentication was cancelled.";
-  }
-  if (lower.includes("denied") || lower.includes("invalid_grant")) {
-    return "Twitter denied the authorization request. Please try again.";
-  }
-  return "Twitter authentication failed. Please try again.";
-}
-
-async function handleTwitterAuthStart(): Promise<Response> {
-  try {
-    assertMetadataWritable();
-  } catch {
-    return httpError(
-      "UNPROCESSABLE_ENTITY",
-      "Credential metadata file has an unrecognized version. Cannot store OAuth credentials.",
-      422,
-    );
-  }
-
-  try {
-    const raw = loadRawConfig();
-    const mode =
-      (getNestedValue(raw, "twitter.integrationMode") as string | undefined) ??
-      "local_byo";
-    if (mode === "managed") {
-      const apiKey = getSecureKey("credential:vellum:assistant_api_key");
-      if (!apiKey) {
-        return Response.json(
-          {
-            ok: false,
-            error:
-              "An AssistantAPIKey is required for managed Twitter. Run assistant setup.",
-            errorCode: "managed_missing_api_key",
-          },
-          { status: 400 },
-        );
-      }
-      return Response.json(
-        {
-          ok: false,
-          error:
-            "Managed Twitter authentication is handled through the Vellum platform. Open Settings to connect.",
-          errorCode: "managed_auth_via_platform",
-        },
-        { status: 400 },
-      );
-    }
-    if (mode !== "local_byo") {
-      return httpError(
-        "BAD_REQUEST",
-        'Twitter integration mode must be "local_byo" to use this flow.',
-        400,
-      );
-    }
-
-    const clientId = getSecureKey("credential:integration:twitter:client_id");
-    if (!clientId) {
-      return httpError(
-        "BAD_REQUEST",
-        "No Twitter client credentials configured. Please set up your Client ID first.",
-        400,
-      );
-    }
-
-    const clientSecret =
-      getSecureKey("credential:integration:twitter:client_secret") || undefined;
-
-    let config;
-    try {
-      config = loadConfig();
-    } catch (err) {
-      const detail = err instanceof ConfigError ? err.message : String(err);
-      return httpError(
-        "INTERNAL_ERROR",
-        `Unable to load config: ${detail}`,
-        500,
-      );
-    }
-
-    try {
-      getPublicBaseUrl(config);
-    } catch {
-      return httpError(
-        "BAD_REQUEST",
-        "Set ingress.publicBaseUrl (or INGRESS_PUBLIC_BASE_URL) so OAuth callbacks can route through /webhooks/oauth/callback on the gateway.",
-        400,
-      );
-    }
-
-    let authUrl: string | undefined;
-
-    const result = await orchestrateOAuthConnect({
-      service: "integration:twitter",
-      clientId,
-      clientSecret,
-      isInteractive: true,
-      openUrl: (url: string) => {
-        authUrl = url;
-      },
-      allowedTools: ["twitter_post"],
-    });
-
-    if (!result.success) {
-      log.error(
-        { err: result.error },
-        "Twitter OAuth orchestrator returned error",
-      );
-      return httpError(
-        "INTERNAL_ERROR",
-        result.safeError
-          ? result.error
-          : sanitizeTwitterAuthError(result.error),
-        500,
-      );
-    }
-
-    if (result.deferred) {
-      return Response.json({
-        ok: true,
-        deferred: true,
-        authUrl: result.authUrl,
-      });
-    }
-
-    // Persist accountInfo to config
-    if (result.accountInfo) {
-      try {
-        const raw2 = loadRawConfig();
-        setNestedValue(raw2, "twitter.accountInfo", result.accountInfo);
-        saveRawConfig(raw2);
-        invalidateConfigCache();
-      } catch {
-        // Non-fatal
-      }
-    }
-
-    return Response.json({
-      ok: true,
-      accountInfo: result.accountInfo,
-      ...(authUrl ? { authUrl } : {}),
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, "Twitter OAuth flow failed");
-    return httpError("INTERNAL_ERROR", sanitizeTwitterAuthError(message), 500);
-  }
-}
-
-function handleTwitterAuthStatus(): Response {
-  try {
-    const accessToken = getSecureKey(
-      "credential:integration:twitter:access_token",
-    );
-    const raw = loadRawConfig();
-    const mode =
-      (getNestedValue(raw, "twitter.integrationMode") as
-        | "local_byo"
-        | "managed"
-        | undefined) ?? "local_byo";
-    const accountInfo = getNestedValue(raw, "twitter.accountInfo") as
-      | string
-      | undefined;
-
-    // Managed prerequisites
-    const integrationModeManaged = mode === "managed";
-    const assistantApiKeyPresent = !!getSecureKey(
-      "credential:vellum:assistant_api_key",
-    );
-    const platformBaseUrlFromEnv = getPlatformBaseUrl();
-    const platformBaseUrlFromConfig = (
-      raw?.platform as Record<string, unknown> | undefined
-    )?.baseUrl as string | undefined;
-    const platformAssistantIdResolvable = !!(
-      (platformBaseUrlFromEnv || platformBaseUrlFromConfig) &&
-      (getSecureKey("credential:vellum:platform_assistant_id") ||
-        getPlatformAssistantId())
-    );
-
-    const managedPrerequisites = {
-      integrationModeManaged,
-      assistantApiKeyPresent,
-      platformAssistantIdResolvable,
-    };
-    const managedAvailable =
-      integrationModeManaged &&
-      assistantApiKeyPresent &&
-      platformAssistantIdResolvable;
-
-    // Local client configured
-    const localClientConfigured = !!getSecureKey(
-      "credential:integration:twitter:client_id",
-    );
-
-    // In managed mode, connected is always false (auth goes through platform)
-    const connected = mode === "managed" ? false : !!accessToken;
-
-    return Response.json({
-      connected,
-      accountInfo: accountInfo ?? undefined,
-      mode,
-      managedAvailable,
-      managedPrerequisites,
-      localClientConfigured,
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, "Failed to get Twitter auth status");
-    return httpError("INTERNAL_ERROR", message, 500);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Workspace files (IPC-style list/read)
+// Workspace files (list/read)
 // ---------------------------------------------------------------------------
 
 const WORKSPACE_FILES = ["IDENTITY.md", "SOUL.md", "USER.md", "skills/"];
@@ -813,21 +573,7 @@ export function settingsRouteDefinitions(): RouteDefinition[] {
       },
     },
 
-    // Twitter auth
-    {
-      endpoint: "integrations/twitter/auth/start",
-      method: "POST",
-      policyKey: "integrations/twitter/auth/start",
-      handler: async () => handleTwitterAuthStart(),
-    },
-    {
-      endpoint: "integrations/twitter/auth/status",
-      method: "GET",
-      policyKey: "integrations/twitter/auth/status",
-      handler: () => handleTwitterAuthStatus(),
-    },
-
-    // Workspace files (IPC-style list/read -- distinct from workspace-routes.ts tree/file)
+    // Workspace files (list/read -- distinct from workspace-routes.ts tree/file)
     {
       endpoint: "workspace-files",
       method: "GET",

package/src/runtime/routes/skills-routes.ts

@@ -1,7 +1,7 @@
 /**
  * Route handlers for skill management operations.
  *
- * These HTTP routes expose the same business logic as the IPC skill handlers,
+ * These HTTP routes expose the same business logic as the skill handlers,
  * using the standalone functions extracted in `../../daemon/handlers/skills.ts`.
  */
 
@@ -173,12 +173,13 @@ export function skillRouteDefinitions(deps: SkillRouteDeps): RouteDefinition[] {
         if (!body.sourceText || typeof body.sourceText !== "string") {
           return httpError("BAD_REQUEST", "sourceText is required", 400);
         }
-        const result = await draftSkill(
-          { sourceText: body.sourceText },
-          ctx(),
-        );
+        const result = await draftSkill({ sourceText: body.sourceText }, ctx());
         if (!result.success) {
-          return httpError("INTERNAL_ERROR", result.error ?? "Draft failed", 500);
+          return httpError(
+            "INTERNAL_ERROR",
+            result.error ?? "Draft failed",
+            500,
+          );
         }
         return Response.json(result);
       },

package/src/runtime/routes/subagents-routes.ts

@@ -2,7 +2,7 @@
  * Route handlers for subagent operations.
  *
  * Exposes subagent detail, abort, and message operations over HTTP,
- * sharing business logic with the IPC handlers in
+ * sharing business logic with the handlers in
  * `daemon/handlers/subagents.ts`.
  */
 import { getMessages } from "../../memory/conversation-crud.js";
@@ -14,7 +14,7 @@ import type { RouteDefinition } from "../http-router.js";
 const log = getLogger("subagents-routes");
 
 // ---------------------------------------------------------------------------
-// Shared business logic (used by both IPC handlers and HTTP routes)
+// Shared business logic (used by both message handlers and HTTP routes)
 // ---------------------------------------------------------------------------
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -167,7 +167,7 @@ export function subagentRouteDefinitions(): RouteDefinition[] {
         const manager = getSubagentManager();
         const aborted = manager.abort(
           params.id,
-          () => {}, // No IPC send callback needed for HTTP
+          () => {}, // No send callback needed for HTTP
           sessionId,
         );
 
@@ -219,13 +219,7 @@ export function subagentRouteDefinitions(): RouteDefinition[] {
 
         const result = await manager.sendMessage(params.id, body.content);
 
-        if (result === "queue_full") {
-          return httpError(
-            "CONFLICT",
-            `Subagent "${params.id}" message queue is full. Please wait for current messages to be processed.`,
-            409,
-          );
-        } else if (result === "empty") {
+        if (result === "empty") {
           return httpError(
             "BAD_REQUEST",
             "Message content is empty or whitespace-only.",

package/src/runtime/routes/surface-action-routes.ts

@@ -62,11 +62,7 @@ export async function handleSurfaceAction(
     : findSessionBySurfaceId?.(surfaceId);
 
   if (!session) {
-    return httpError(
-      "NOT_FOUND",
-      "No active session found",
-      404,
-    );
+    return httpError("NOT_FOUND", "No active session found", 404);
   }
 
   try {
@@ -115,11 +111,7 @@ export async function handleSurfaceUndo(
     : findSessionBySurfaceId?.(surfaceId);
 
   if (!session) {
-    return httpError(
-      "NOT_FOUND",
-      "No active session found",
-      404,
-    );
+    return httpError("NOT_FOUND", "No active session found", 404);
   }
 
   if (!session.handleSurfaceUndo) {
@@ -132,10 +124,7 @@ export async function handleSurfaceUndo(
 
   try {
     session.handleSurfaceUndo(surfaceId);
-    log.info(
-      { sessionId, surfaceId },
-      "Surface undo handled via HTTP",
-    );
+    log.info({ sessionId, surfaceId }, "Surface undo handled via HTTP");
     return Response.json({ ok: true });
   } catch (err) {
     log.error(

package/src/runtime/routes/surface-content-routes.ts

@@ -5,7 +5,10 @@
  * session's in-memory surface state. Used by clients to re-hydrate surfaces
  * whose data was stripped during memory compaction.
  */
-import type { SurfaceData, SurfaceType } from "../../daemon/message-types/surfaces.js";
+import type {
+  SurfaceData,
+  SurfaceType,
+} from "../../daemon/message-types/surfaces.js";
 import { getLogger } from "../../util/logger.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
@@ -53,12 +56,20 @@ export function surfaceContentRouteDefinitions(deps: {
 
         const sessionId = url.searchParams.get("sessionId");
         if (!sessionId) {
-          return httpError("BAD_REQUEST", "sessionId query parameter is required", 400);
+          return httpError(
+            "BAD_REQUEST",
+            "sessionId query parameter is required",
+            400,
+          );
         }
 
         const surfaceId = params.surfaceId;
         if (!surfaceId) {
-          return httpError("BAD_REQUEST", "surfaceId path parameter is required", 400);
+          return httpError(
+            "BAD_REQUEST",
+            "surfaceId path parameter is required",
+            400,
+          );
         }
 
         const session = deps.findSession(sessionId);
@@ -73,7 +84,10 @@ export function surfaceContentRouteDefinitions(deps: {
         // Look up the surface in the session's in-memory state.
         const stored = session.surfaceState.get(surfaceId);
         if (stored) {
-          log.info({ sessionId, surfaceId }, "Surface content served from surfaceState");
+          log.info(
+            { sessionId, surfaceId },
+            "Surface content served from surfaceState",
+          );
           return Response.json({
             surfaceId,
             surfaceType: stored.surfaceType,
@@ -88,7 +102,10 @@ export function surfaceContentRouteDefinitions(deps: {
           (s) => s.surfaceId === surfaceId,
         );
         if (turnSurface) {
-          log.info({ sessionId, surfaceId }, "Surface content served from currentTurnSurfaces");
+          log.info(
+            { sessionId, surfaceId },
+            "Surface content served from currentTurnSurfaces",
+          );
           return Response.json({
             surfaceId,
             surfaceType: turnSurface.surfaceType,

package/src/runtime/routes/work-items-routes.ts

@@ -2,7 +2,7 @@
  * Route handlers for work item (task queue) operations.
  *
  * Exposes all work item CRUD and lifecycle operations over HTTP,
- * sharing business logic with the IPC handlers in
+ * sharing business logic with the handlers in
  * `daemon/handlers/work-items.ts`.
  */
 import type { ServerMessage } from "../../daemon/message-protocol.js";
@@ -195,7 +195,7 @@ function extractToolHighlights(
 }
 
 // ---------------------------------------------------------------------------
-// Shared business logic functions (exported for IPC handler reuse)
+// Shared business logic functions (exported for handler reuse)
 // ---------------------------------------------------------------------------
 
 export interface WorkItemOutputResult {
@@ -283,8 +283,7 @@ export function getWorkItemOutput(id: string): WorkItemOutputResult {
   if (!summary && msgs.length > 0) {
     const toolHighlights = extractToolHighlights(msgs, 10);
     if (toolHighlights.length > 0) {
-      summary =
-        "Task completed. Tool outcomes:\n" + toolHighlights.join("\n");
+      summary = "Task completed. Tool outcomes:\n" + toolHighlights.join("\n");
       highlights = toolHighlights.slice(0, 5);
     }
   }
@@ -458,10 +457,7 @@ export function workItemRouteDefinitions(
         // Don't allow overwriting a cancelled status
         if (body.status !== undefined) {
           const existing = getWorkItem(params.id);
-          if (
-            existing?.status === "cancelled" &&
-            body.status !== "cancelled"
-          ) {
+          if (existing?.status === "cancelled" && body.status !== "cancelled") {
             return Response.json({ item: existing });
           }
         }
@@ -497,7 +493,11 @@ export function workItemRouteDefinitions(
       handler: ({ params }) => {
         const existing = getWorkItem(params.id);
         if (!existing) {
-          return httpError("NOT_FOUND", `Work item not found: ${params.id}`, 404);
+          return httpError(
+            "NOT_FOUND",
+            `Work item not found: ${params.id}`,
+            404,
+          );
         }
         if (existing.status !== "awaiting_review") {
           return httpError(
@@ -580,9 +580,16 @@ export function workItemRouteDefinitions(
       handler: async ({ req, params }) => {
         const body = (await req.json()) as { approvedTools?: string[] };
         if (!Array.isArray(body.approvedTools)) {
-          return httpError("BAD_REQUEST", "approvedTools array is required", 400);
+          return httpError(
+            "BAD_REQUEST",
+            "approvedTools array is required",
+            400,
+          );
         }
-        const result = approveWorkItemPermissions(params.id, body.approvedTools);
+        const result = approveWorkItemPermissions(
+          params.id,
+          body.approvedTools,
+        );
         if (!result.success) {
           return httpError("NOT_FOUND", result.error!, 404);
         }
@@ -620,11 +627,7 @@ export function workItemRouteDefinitions(
         }
 
         if (workItem.status === "running") {
-          return httpError(
-            "CONFLICT",
-            "Work item is already running",
-            409,
-          );
+          return httpError("CONFLICT", "Work item is already running", 409);
         }
 
         const NON_RUNNABLE_STATUSES: readonly string[] = ["archived"];
@@ -755,10 +758,7 @@ export function workItemRouteDefinitions(
             if (session) {
               (session as { headlessLock: boolean }).headlessLock = false;
             }
-            log.error(
-              { err, workItemId },
-              "work_item_run_task (HTTP) failed",
-            );
+            log.error({ err, workItemId }, "work_item_run_task (HTTP) failed");
             updateWorkItem(workItemId, {
               status: "failed",
               lastRunStatus: "failed",
@@ -797,11 +797,7 @@ export function workItemRouteDefinitions(
             { err, workItemId: params.id },
             "GET /v1/work-items/:id/output failed",
           );
-          return httpError(
-            "INTERNAL_ERROR",
-            "Failed to load task output",
-            500,
-          );
+          return httpError("INTERNAL_ERROR", "Failed to load task output", 500);
         }
       },
     },

package/src/runtime/routes/workspace-routes.test.ts

@@ -657,9 +657,9 @@ describe("POST /v1/workspace/rename", () => {
     const res = await handler(ctx);
     expect(res.status).toBe(200);
     expect(existsSync(srcDir)).toBe(false);
-    expect(
-      existsSync(join(testWorkspaceDir, "dir-renamed", "child.txt")),
-    ).toBe(true);
+    expect(existsSync(join(testWorkspaceDir, "dir-renamed", "child.txt"))).toBe(
+      true,
+    );
   });
 
   test("rejects missing source with 404", async () => {

package/src/runtime/routes/workspace-utils.ts

@@ -45,7 +45,7 @@ export function resolveWorkspacePath(relativePath: string): string | undefined {
     }
 
     let ancestor = resolved;
-     
+
     while (true) {
       const parent = resolve(ancestor, "..");
       if (parent === ancestor) break; // reached filesystem root

package/src/runtime/telegram-streaming-delivery.ts

@@ -44,6 +44,9 @@ export class TelegramStreamingDelivery {
       case "assistant_text_delta":
         this.onTextDelta(msg.text);
         break;
+      case "tool_use_preview_start":
+        // Early preview of tool use — ignored by Telegram; full tool_use_start follows.
+        break;
       case "tool_use_start":
         // Flush buffer and send an edit so the message is up-to-date before the tool runs
         if (this.buffer.length > 0 && this.currentMessageId) {

package/src/runtime/verification-outbound-actions.ts

@@ -4,7 +4,7 @@
  * These pure functions encapsulate the business logic for starting, resending,
  * and cancelling outbound verification flows (Telegram, voice, Slack).
  * They return transport-agnostic result objects and are consumed by both the
- * IPC handler (config-channels.ts) and the HTTP route layer (channel-verification-routes.ts).
+ * message handler (config-channels.ts) and the HTTP route layer (channel-verification-routes.ts).
  */
 
 import { createHash, randomBytes } from "node:crypto";
@@ -99,7 +99,7 @@ export interface CancelOutboundParams {
 
 /**
  * Transport-agnostic result object returned by outbound actions.
- * Maps 1:1 with the fields in ChannelVerificationSessionResponse minus the IPC
+ * Maps 1:1 with the fields in ChannelVerificationSessionResponse minus the
  * `type` discriminant.
  */
 export interface OutboundActionResult {

package/src/schedule/integration-status.ts

@@ -15,12 +15,6 @@ const INTEGRATION_PROBES: IntegrationProbe[] = [
     isConnected: () =>
       !!getSecureKey("credential:integration:gmail:access_token"),
   },
-  {
-    name: "Twitter",
-    category: "social",
-    isConnected: () =>
-      !!getSecureKey("credential:integration:twitter:access_token"),
-  },
   {
     name: "Slack",
     category: "messaging",