@vellumai/assistant 0.8.0 → 0.8.2

package/src/runtime/routes/host-browser-routes.ts

@@ -10,15 +10,22 @@ import {
   markTargetInvalidated,
   publishCdpEvent,
 } from "../../browser-session/events.js";
-import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
+import {
+  enforceSameActorOrThrow,
+  SAME_ACTOR_FORBIDDEN_DESCRIPTION,
+} from "../auth/same-actor.js";
+import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
 import * as pendingInteractions from "../pending-interactions.js";
-import { BadRequestError, ConflictError, NotFoundError } from "./errors.js";
+import {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  NotFoundError,
+} from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 /**
- * Result of attempting to resolve a host browser result frame. Used by both
- * the HTTP endpoint and the WS relay path so they share the same validation
- * and resolution semantics.
+ * Result of attempting to resolve a host browser result frame.
  *
  * Success → the pending interaction was consumed and the conversation was
  * notified.
@@ -30,8 +37,8 @@ export type HostBrowserResultResolution =
   | { ok: true }
   | {
       ok: false;
-      code: "BAD_REQUEST" | "NOT_FOUND" | "CONFLICT";
-      status: 400 | 404 | 409;
+      code: "BAD_REQUEST" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT";
+      status: 400 | 403 | 404 | 409;
       message: string;
     };
 
@@ -40,22 +47,26 @@ export type HostBrowserResultResolution =
  * the pending interaction by requestId, validates its kind is
  * `host_browser`, and forwards the response to the owning conversation.
  *
- * NOTE: The WebSocket `host_browser_result` frame path does NOT go
- * through this function — it is handled by `HostBrowserProxy.resolveResult`
- * directly, which only consults `pendingInteractions` and does not
- * currently perform a kind check. That asymmetry is pre-existing; if
- * the WS path is ever opened to less-trusted clients, it should adopt
- * the same kind-check guard added here.
+ * Same-actor binding: when the pending interaction has a
+ * `targetClientId` (set by the proxy at request time when an actor is
+ * known), the submitting client must (a) identify itself via
+ * `x-vellum-client-id` matching the captured target, and (b) the
+ * submitting actor's principal must match the actor captured for that
+ * client at registration time. Mirrors the host-cu / host-bash result
+ * routes.
  *
  * This function does NOT perform auth — callers are expected to have
  * already authenticated the caller (the HTTP route uses
  * `requireBoundGuardian`).
  */
-export function resolveHostBrowserResultByRequestId(frame: {
-  requestId?: unknown;
-  content?: unknown;
-  isError?: unknown;
-}): HostBrowserResultResolution {
+export function resolveHostBrowserResultByRequestId(
+  frame: {
+    requestId?: unknown;
+    content?: unknown;
+    isError?: unknown;
+  },
+  headers?: Record<string, string | undefined>,
+): HostBrowserResultResolution {
   const { requestId, content, isError } = frame;
 
   if (!requestId || typeof requestId !== "string") {
@@ -86,11 +97,60 @@ export function resolveHostBrowserResultByRequestId(frame: {
     };
   }
 
+  // Validate submitting client matches the targeted client (if any).
+  if (peeked.targetClientId != null) {
+    const headerMap = headers ?? {};
+    const submittingClientId =
+      headerMap["x-vellum-client-id"]?.trim() || undefined;
+    if (!submittingClientId) {
+      return {
+        ok: false,
+        code: "BAD_REQUEST",
+        status: 400,
+        message:
+          "x-vellum-client-id header is missing for a targeted host browser request.",
+      };
+    }
+    if (submittingClientId !== peeked.targetClientId) {
+      return {
+        ok: false,
+        code: "FORBIDDEN",
+        status: 403,
+        message: `Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}"). The targeted client must submit the result.`,
+      };
+    }
+
+    // Defense-in-depth: require the submitting actor's principal id to match
+    // the actor principal id captured when the target client opened its SSE
+    // stream. This prevents a different authenticated user with knowledge of
+    // both the requestId and target clientId from submitting a result on
+    // behalf of the targeted client.
+    const submittingActorPrincipalId = resolveActorPrincipalIdForLocalGuardian(
+      headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
+    );
+    try {
+      enforceSameActorOrThrow({
+        sourceActorPrincipalId: submittingActorPrincipalId,
+        targetActorPrincipalId: peeked.targetActorPrincipalId,
+        targetClientId: peeked.targetClientId,
+        op: "host_browser",
+      });
+    } catch (err) {
+      // enforceSameActorOrThrow throws ForbiddenError on rejection.
+      return {
+        ok: false,
+        code: "FORBIDDEN",
+        status: 403,
+        message: err instanceof Error ? err.message : "Same-actor check failed",
+      };
+    }
+  }
+
   const normalizedContent = typeof content === "string" ? content : "";
   const normalizedIsError = typeof isError === "boolean" ? isError : false;
 
-  const proxy = HostBrowserProxy.instance;
-  proxy.resolveResult(requestId, {
+  const interaction = pendingInteractions.resolve(requestId);
+  interaction?.rpcResolve?.({
     content: normalizedContent,
     isError: normalizedIsError,
   });
@@ -188,13 +248,18 @@ export function resolveHostBrowserSessionInvalidated(frame: {
 // POST /v1/host-browser-result
 // ---------------------------------------------------------------------------
 
-function handleHostBrowserResult({ body }: RouteHandlerArgs) {
+function handleHostBrowserResult({ body, headers }: RouteHandlerArgs) {
   if (!body || typeof body !== "object") {
     throw new BadRequestError("Request body is required");
   }
 
-  const resolution = resolveHostBrowserResultByRequestId(body);
+  const resolution = resolveHostBrowserResultByRequestId(
+    body,
+    headers as Record<string, string | undefined> | undefined,
+  );
   if (!resolution.ok) {
+    if (resolution.code === "FORBIDDEN")
+      throw new ForbiddenError(resolution.message);
     if (resolution.code === "NOT_FOUND")
       throw new NotFoundError(resolution.message);
     if (resolution.code === "CONFLICT")
@@ -260,6 +325,22 @@ export const ROUTES: RouteDefinition[] = [
     responseBody: z.object({
       accepted: z.boolean(),
     }),
+    additionalResponses: {
+      "400": {
+        description:
+          "x-vellum-client-id header is missing for a targeted host browser request.",
+      },
+      "403": {
+        description: SAME_ACTOR_FORBIDDEN_DESCRIPTION,
+      },
+      "404": {
+        description: "No pending browser request for the given requestId.",
+      },
+      "409": {
+        description:
+          "Pending interaction kind is not host_browser (mismatched proxy ID space).",
+      },
+    },
     handler: handleHostBrowserResult,
   },
   {

package/src/runtime/routes/http-adapter.ts

@@ -35,6 +35,7 @@ export function routeDefinitionsToHTTPRoutes(
   return routes.map((r) => ({
     endpoint: r.endpoint,
     method: r.method,
+    operationId: r.operationId,
     policyKey:
       r.policyKey ?? r.endpoint.replace(/\/:[^/]+/g, "").replace(/^:/, ""),
     pathParams: r.pathParams,
@@ -47,6 +48,7 @@ export function routeDefinitionsToHTTPRoutes(
     responseStatus:
       typeof r.responseStatus === "string" ? r.responseStatus : undefined,
     additionalResponses: r.additionalResponses,
+    logging: r.logging,
     handler: async ({ req, url, params, authContext }) => {
       try {
         if (r.requireGuardian) {

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

@@ -449,6 +449,10 @@ export const ROUTES: RouteDefinition[] = [
       "Returns runtime health including version, disk, memory, CPU, and migration status.",
     tags: ["system"],
     responseBody: detailedHealthSchema,
+    // Clients (notably the macOS app) poll this every few seconds; the
+    // first handful of 200s confirm the route works and every line after
+    // is just noise. Non-2xx still logs.
+    logging: { silenceSuccessAfter: 5 },
   },
   {
     operationId: "healthz",
@@ -461,6 +465,7 @@ export const ROUTES: RouteDefinition[] = [
       "Alias for /v1/health. Returns runtime health including version, disk, memory, CPU, and migration status.",
     tags: ["system"],
     responseBody: detailedHealthSchema,
+    logging: { silenceSuccessAfter: 5 },
   },
   {
     operationId: "identity",

package/src/runtime/routes/image-generation-routes.ts

@@ -0,0 +1,99 @@
+import { getConfig } from "../../config/loader.js";
+import { resolveImageGenCredentials } from "../../media/image-credentials.js";
+import {
+  generateImage,
+  mapImageGenError,
+  providerForModel,
+} from "../../media/image-service.js";
+import { BadRequestError, InternalError, UnprocessableEntityError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+async function handleImageGenerationGenerate(
+  args: RouteHandlerArgs,
+): Promise<unknown> {
+  const { prompt, mode, sourceImages, model, variants } = args.body ?? {};
+
+  // Validate prompt
+  if (typeof prompt !== "string" || !prompt.trim()) {
+    throw new BadRequestError("prompt must be a non-empty string");
+  }
+
+  // Validate / default mode
+  const resolvedMode: "generate" | "edit" =
+    mode === "edit" ? "edit" : "generate";
+
+  // Validate edit mode requirements
+  if (
+    resolvedMode === "edit" &&
+    (!sourceImages ||
+      !Array.isArray(sourceImages) ||
+      (sourceImages as unknown[]).length === 0)
+  ) {
+    throw new BadRequestError("Edit mode requires at least one source image");
+  }
+
+  // Resolve config
+  const config = getConfig();
+  const svc = config.services["image-generation"];
+
+  // Derive provider from explicit model override when supplied
+  const provider = providerForModel(model, svc.provider);
+
+  // Resolve credentials
+  const { credentials, errorHint } = await resolveImageGenCredentials({
+    provider,
+    mode: svc.mode,
+  });
+
+  if (!credentials) {
+    throw new UnprocessableEntityError(
+      errorHint ?? "No credentials available for image generation",
+    );
+  }
+
+  // Clamp variants to 1-4
+  const clampedVariants = Math.max(1, Math.min(Number(variants) || 1, 4));
+
+  // Generate image
+  try {
+    const result = await generateImage(provider, credentials, {
+      prompt,
+      mode: resolvedMode,
+      sourceImages: sourceImages as
+        | Array<{ mimeType: string; dataBase64: string }>
+        | undefined,
+      model: (model as string | undefined) ?? svc.model,
+      variants: clampedVariants,
+    });
+
+    return {
+      images: result.images,
+      text: result.text,
+      resolvedModel: result.resolvedModel,
+    };
+  } catch (error) {
+    const errorMessage = mapImageGenError(provider, error);
+    throw new InternalError(errorMessage);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "image_generation_generate",
+    endpoint: "image-generation/generate",
+    method: "POST",
+    summary: "Generate or edit images using AI",
+    description:
+      "Calls the configured image-generation provider (Gemini or OpenAI) to produce one or more images.",
+    tags: ["image-generation"],
+    handler: handleImageGenerationGenerate,
+  },
+];

package/src/runtime/routes/inbound-conversation.ts

@@ -1,16 +1,23 @@
 /**
  * Channel conversation deletion handler.
  */
-import { deleteConversationKey } from "../../memory/conversation-key-store.js";
-import { deleteBindingByChannelChat } from "../../memory/external-conversation-store.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
+import {
+  deleteConversationKey,
+  getOrCreateConversation,
+} from "../../memory/conversation-key-store.js";
+import { buildScopedConversationKey } from "../../memory/delivery-crud.js";
+import {
+  deleteBindingByChannelChat,
+  deleteBindingByChannelChatThread,
+} from "../../memory/external-conversation-store.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteHandlerArgs } from "./types.js";
 
 export function handleDeleteConversation({ body = {} }: RouteHandlerArgs) {
-  const { sourceChannel, conversationExternalId } = body as {
+  const { sourceChannel, conversationExternalId, sourceThreadId } = body as {
     sourceChannel?: string;
     conversationExternalId?: string;
+    sourceThreadId?: string;
   };
 
   if (!sourceChannel || typeof sourceChannel !== "string") {
@@ -20,14 +27,27 @@ export function handleDeleteConversation({ body = {} }: RouteHandlerArgs) {
     throw new BadRequestError("conversationExternalId is required");
   }
 
-  const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
+  const normalizedThreadId = sourceThreadId?.trim() || undefined;
 
-  const scopedKey = `asst:${assistantId}:${sourceChannel}:${conversationExternalId}`;
+  const scopedKey = buildScopedConversationKey(
+    sourceChannel,
+    conversationExternalId,
+    normalizedThreadId,
+  );
   deleteConversationKey(scopedKey);
-  if (assistantId === DAEMON_INTERNAL_ASSISTANT_ID) {
-    const legacyKey = `${sourceChannel}:${conversationExternalId}`;
+  const legacyKey = `${sourceChannel}:${conversationExternalId}`;
+  if (!normalizedThreadId) {
     deleteConversationKey(legacyKey);
     deleteBindingByChannelChat(sourceChannel, conversationExternalId);
+  } else {
+    if (sourceChannel === "slack") {
+      getOrCreateConversation(scopedKey);
+    }
+    deleteBindingByChannelChatThread(
+      sourceChannel,
+      conversationExternalId,
+      normalizedThreadId,
+    );
   }
 
   return { ok: true };