@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/runtime/routes/app-management-routes.ts

@@ -19,6 +19,12 @@ import { join } from "node:path";
 
 import { z } from "zod";
 
+import {
+  type AppPin,
+  listAppPins,
+  removeAppPin,
+  updateAppPin,
+} from "../../apps/app-pin-store.js";
 import {
   type AppDefinition,
   type AppOrigin,
@@ -58,6 +64,7 @@ import {
   NotFoundError,
   PayloadTooLargeError,
 } from "./errors.js";
+import { parseBody } from "./parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("app-management-routes");
@@ -80,17 +87,66 @@ function getSharedAppsDir(): string {
 // Extracted business logic
 // ---------------------------------------------------------------------------
 
-interface AppListItem {
-  id: string;
-  name: string;
-  description?: string;
-  icon?: string;
-  createdAt: number;
-  updatedAt: number;
-  version: string;
-  contentId: string;
-  /** "workspace" or "plugin:<name>" — identifies where the app comes from. */
-  origin: string;
+/**
+ * One entry in the app list. Declared as the schema the route publishes, so the
+ * wire contract and the type the handlers build against cannot drift apart.
+ */
+const appListItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  version: z.string(),
+  contentId: z.string(),
+  origin: z
+    .string()
+    .describe('"workspace" or "plugin:<name>": where the app comes from'),
+  pinSortPosition: z
+    .number()
+    .optional()
+    .describe("Sidebar order, ascending. Absent when the app is not pinned"),
+  pinColor: z
+    .string()
+    .optional()
+    .describe("Pin colour id; absent when no colour is set"),
+});
+
+type AppListItem = z.infer<typeof appListItemSchema>;
+
+/**
+ * The pin route's body. `RouteDefinition.requestBody` is a codegen signal and
+ * does not validate, so the handler parses against this too; declaring it once
+ * keeps what is advertised and what is enforced from drifting apart.
+ */
+const appPinBodySchema = z
+  .object({
+    pinned: z
+      .boolean()
+      .optional()
+      .describe("Pin (true) or unpin (false). Omit to leave unchanged."),
+    color: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Colour id, or null to clear. Omit to leave unchanged."),
+  })
+  .refine(
+    (value) => value.pinned !== undefined || value.color !== undefined,
+    "pinned or color is required",
+  );
+
+/** Merge an app's pin, if it has one, onto its list entry. */
+function withPin(item: AppListItem, pin: AppPin | undefined): AppListItem {
+  if (!pin) {
+    return item;
+  }
+  return {
+    ...item,
+    pinSortPosition: pin.sortPosition,
+    ...(pin.color !== undefined ? { pinColor: pin.color } : {}),
+  };
 }
 
 function workspaceAppItem(a: AppDefinition): AppListItem {
@@ -578,17 +634,23 @@ async function importBundle(
 // ---------------------------------------------------------------------------
 
 function handleListApps({ queryParams }: RouteHandlerArgs) {
+  const pinsById = new Map(listAppPins().map((pin) => [pin.appId, pin]));
+  const pinned = (item: AppListItem): AppListItem =>
+    withPin(item, pinsById.get(item.id));
+
   const conversationId = queryParams?.conversationId;
   if (conversationId) {
     // Conversation scoping is a workspace-app concept; plugin apps are not
     // associated with conversations, so they are omitted from this view.
     return {
-      apps: listAppsByConversation(conversationId).map(workspaceAppItem),
+      apps: listAppsByConversation(conversationId).map((app) =>
+        pinned(workspaceAppItem(app)),
+      ),
     };
   }
   const apps: AppListItem[] = [
-    ...listApps().map(workspaceAppItem),
-    ...listPluginApps().map(pluginAppItem),
+    ...listApps().map((app) => pinned(workspaceAppItem(app))),
+    ...listPluginApps().map((app) => pinned(pluginAppItem(app))),
   ];
   return { apps };
 }
@@ -818,10 +880,50 @@ function handleDeleteApp({ pathParams, headers }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
   assertNotPluginApp(appId, "delete a plugin app");
   deleteApp(appId);
+  /* `deleteApp` cannot do this itself: it is filesystem-level and runs where no
+     migrated database exists. Deletions that skip this, and plugin apps that
+     leave with their plugin, are converged by `apps/app-pin-reconciler.ts`. */
+  removeAppPin(appId);
   publishAppsChanged(getOriginClientId(headers));
   return { success: true };
 }
 
+/**
+ * Pin, unpin, or recolour an app. Plugin apps are pinnable: a pin says nothing
+ * about the app's content, so `assertNotPluginApp` does not apply here.
+ */
+/** Every app id this workspace has, plugin apps included. */
+function existingAppIds(): string[] {
+  return [
+    ...listApps().map((app) => app.id),
+    ...listPluginApps().map((app) => app.id),
+  ];
+}
+
+function handlePinApp({ pathParams, body = {}, headers }: RouteHandlerArgs) {
+  const appId = pathParams?.id as string;
+  const { pinned, color } = parseBody(appPinBodySchema, body);
+  const existing = existingAppIds();
+  /* A pin only means anything against an app that exists: the list starts from
+     the real apps, so a pin for anything else could never be read back.
+     Unpinning is exempt, since that is how a client clears state left over from
+     an app that has since gone. */
+  if (pinned === true && !existing.includes(appId)) {
+    throw new NotFoundError(`App not found: ${appId}`);
+  }
+  const pin = updateAppPin(appId, {
+    ...(pinned === undefined ? {} : { pinned }),
+    ...(color === undefined ? {} : { color }),
+  });
+  publishAppsChanged(getOriginClientId(headers));
+  return {
+    success: true,
+    appId,
+    pinSortPosition: pin?.sortPosition ?? null,
+    pinColor: pin?.color ?? null,
+  };
+}
+
 function handleGetPreview({ pathParams }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
   const preview = getAppPreview(appId);
@@ -887,21 +989,7 @@ export const ROUTES: RouteDefinition[] = [
         description: "Filter apps by conversation ID",
       },
     ],
-    responseBody: z.object({
-      apps: z.array(
-        z.object({
-          id: z.string(),
-          name: z.string(),
-          description: z.string().optional(),
-          icon: z.string().optional(),
-          createdAt: z.number(),
-          updatedAt: z.number(),
-          version: z.string(),
-          contentId: z.string(),
-          origin: z.string(),
-        }),
-      ),
-    }),
+    responseBody: z.object({ apps: z.array(appListItemSchema) }),
   },
   {
     operationId: "apps_open_bundle",
@@ -1146,6 +1234,29 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["apps"],
     responseBody: z.object({ success: z.boolean() }),
   },
+  {
+    operationId: "apps_pin",
+    endpoint: "apps/:id/pin",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    handler: handlePinApp,
+    summary: "Pin or unpin an app",
+    description:
+      "Pin an app to the sidebar, unpin it, or set the colour it is tinted " +
+      "with. Pin state is read back from the app list as `pinSortPosition` " +
+      "and `pinColor`.",
+    tags: ["apps"],
+    requestBody: appPinBodySchema,
+    responseBody: z.object({
+      success: z.boolean(),
+      appId: z.string(),
+      pinSortPosition: z.number().nullable(),
+      pinColor: z.string().nullable(),
+    }),
+  },
   {
     operationId: "apps_preview_get",
     endpoint: "apps/:id/preview",

package/src/runtime/routes/channel-availability-routes.ts

@@ -35,6 +35,7 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 const BASE_AVAILABLE_CHANNELS: readonly ChannelId[] = [
   "slack",
   "telegram",
+  "discord",
   "phone",
 ] as const;
 

package/src/runtime/routes/channel-readiness-routes.ts

@@ -14,6 +14,11 @@ import {
   getInviteAdapterRegistry,
   resolveAdapterHandle,
 } from "../channel-invite-transport.js";
+import {
+  CHANNEL_HEALTHS,
+  CHECK_KINDS,
+  SETUP_STATUSES,
+} from "../channel-readiness-types.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 async function enrichSnapshots(
@@ -32,6 +37,7 @@ async function enrichSnapshots(
         channel: s.channel,
         ready: s.ready,
         setupStatus: s.setupStatus,
+        health: s.health,
         checkedAt: s.checkedAt,
         stale: s.stale,
         reasons: s.reasons,
@@ -89,15 +95,21 @@ const readinessCheckSchema = z.object({
   name: z.string(),
   passed: z.boolean(),
   message: z.string().nullable().optional(),
+  // `passed` alone cannot say "I could not tell", and dropping this at the
+  // boundary is why a client cannot distinguish a channel that is broken from
+  // one whose state could not be established.
+  indeterminate: z.boolean().optional(),
+  kind: z.enum(CHECK_KINDS).optional(),
 });
 
 const readinessSnapshotSchema = z.object({
   channel: z.enum(CHANNEL_IDS),
   ready: z.boolean(),
-  setupStatus: z.string().nullable().optional(),
+  setupStatus: z.enum(SETUP_STATUSES).nullable().optional(),
+  health: z.enum(CHANNEL_HEALTHS).optional(),
   checkedAt: z.number().nullable().optional(),
   stale: z.boolean().optional(),
-  reasons: z.array(z.string()).optional(),
+  reasons: z.array(z.object({ code: z.string(), text: z.string() })).optional(),
   localChecks: z.array(readinessCheckSchema).optional(),
   remoteChecks: z.array(readinessCheckSchema).optional(),
   channelHandle: z.string().nullable().optional(),

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

@@ -66,6 +66,7 @@ import {
   getEmbeddingConfigInfo,
   setEmbeddingConfig,
 } from "../../daemon/handlers/config-embeddings.js";
+import { dropTunnelRecordsForNewUrl } from "../../daemon/handlers/config-ingress.js";
 import {
   getModelInfo,
   type ModelSetContext,
@@ -1525,6 +1526,10 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
 
   const raw = loadRawConfig();
   const patch = body as Record<string, unknown>;
+  const patchedIngressUrl = readPlainObject(patch.ingress)?.publicBaseUrl;
+  if (patchedIngressUrl !== undefined) {
+    dropTunnelRecordsForNewUrl(readPlainObject(raw.ingress), patchedIngressUrl);
+  }
   deepMergeOverwrite(raw, patch);
   scrubRemovedServiceModes(raw);
   seedSttProviderForSparseBlock(raw);
@@ -1615,6 +1620,11 @@ async function handleSetConfig({ body }: RouteHandlerArgs) {
         readPlainObject(readPlainObject(raw.llm)?.profiles)?.[managedEntryName],
       )
     : undefined;
+  // `assistant config set ingress.publicBaseUrl <url>`, what the webhook
+  // diagnostics tell users to run, retargets ingress like the settings route.
+  if (path === "ingress.publicBaseUrl") {
+    dropTunnelRecordsForNewUrl(readPlainObject(raw.ingress), value);
+  }
   setNestedValue(raw, path, value);
   if (
     managedEntryName &&

package/src/runtime/routes/guardian-approval-interception.ts

@@ -5,8 +5,6 @@
  * This module is the top-level dispatcher. It delegates plain-text messages to
  * the conversational engine in guardian-text-engine-strategy.ts.
  */
-import type { KnownBlock } from "@slack/types";
-
 import { audienceForReader } from "../../channels/message-audience.js";
 import type { ChannelId } from "../../channels/types.js";
 import type { TrustContext } from "../../daemon/trust-context-types.js";
@@ -48,7 +46,7 @@ export interface ApprovalInterceptionParams {
   approvalCopyGenerator?: ApprovalCopyGenerator;
   approvalConversationGenerator?: ApprovalConversationGenerator;
   /** Original approval message timestamp (Slack ts) for editing after resolution. */
-  approvalMessageTs?: string;
+  approvalMessageId?: string;
 }
 
 import type { ApprovalInterceptionResult } from "./approval-interception-types.js";
@@ -79,7 +77,7 @@ export async function handleApprovalInterception(
     assistantId,
     approvalCopyGenerator,
     approvalConversationGenerator,
-    approvalMessageTs,
+    approvalMessageId,
   } = params;
 
   // Slack emoji reactions are handled by the guardian decision
@@ -245,11 +243,11 @@ export async function handleApprovalInterception(
           );
 
           // Edit the original Slack approval message to remove stale buttons
-          if (sourceChannel === "slack" && approvalMessageTs) {
-            editStaleSlackApprovalMessage({
+          if (approvalMessageId) {
+            editStaleApprovalMessage({
               replyCallbackUrl,
               chatId: conversationExternalId,
-              messageTs: approvalMessageTs,
+              messageId: approvalMessageId,
               assistantId,
               conversationId,
             });
@@ -264,7 +262,7 @@ export async function handleApprovalInterception(
       if (result.applied) {
         // Edit the original Slack approval message to show the decision
         // and remove stale action buttons.
-        if (sourceChannel === "slack" && approvalMessageTs) {
+        if (approvalMessageId) {
           const decisionOutcome: "approved" | "denied" =
             cbDecision.action === "reject" ? "denied" : "approved";
           const statusEmoji =
@@ -273,11 +271,11 @@ export async function handleApprovalInterception(
             decisionOutcome === "approved" ? "Approved" : "Denied";
           editChannelMessage(replyCallbackUrl, {
             chatId: conversationExternalId,
-            messageId: approvalMessageTs,
+            messageId: approvalMessageId,
             text: `${statusEmoji} ${statusLabel}`,
           }).catch((err) => {
             log.error(
-              { err, conversationId, messageTs: approvalMessageTs },
+              { err, conversationId, messageTs: approvalMessageId },
               "Failed to edit Slack approval message after decision",
             );
           });
@@ -291,11 +289,11 @@ export async function handleApprovalInterception(
       // Race condition: request was already resolved between the stale check
       // above and the decision attempt.
       // Edit the original Slack approval message to remove stale buttons
-      if (sourceChannel === "slack" && approvalMessageTs) {
-        editStaleSlackApprovalMessage({
+      if (approvalMessageId) {
+        editStaleApprovalMessage({
           replyCallbackUrl,
           chatId: conversationExternalId,
-          messageTs: approvalMessageTs,
+          messageId: approvalMessageId,
           assistantId,
           conversationId,
         });
@@ -374,39 +372,32 @@ export async function handleApprovalInterception(
 // ---------------------------------------------------------------------------
 
 /**
- * Fire-and-forget: edit a stale Slack approval message to indicate it has
- * been resolved and remove the action buttons. Used when a button click
- * arrives for an already-resolved approval.
+ * Fire-and-forget: mark a stale approval message as resolved and drop its
+ * action buttons. Used when a button click arrives for an approval that was
+ * already decided.
+ *
+ * Says the message is settled and leaves each channel to render that. Slack
+ * reads it as a context block, and a channel with no equivalent shows the
+ * text plainly.
  */
-function editStaleSlackApprovalMessage(params: {
+function editStaleApprovalMessage(params: {
   replyCallbackUrl: string;
   chatId: string;
-  messageTs: string;
+  messageId: string;
   assistantId: string;
   conversationId: string;
 }): void {
-  const statusText = "This approval request has been resolved.";
-  const blocks: KnownBlock[] = [
-    {
-      type: "section",
-      text: { type: "mrkdwn", text: statusText },
-    },
-    {
-      type: "context",
-      elements: [{ type: "mrkdwn", text: statusText }],
-    },
-  ];
   editChannelMessage(params.replyCallbackUrl, {
     chatId: params.chatId,
-    messageId: params.messageTs,
-    text: statusText,
-    blocks,
+    messageId: params.messageId,
+    text: "This approval request has been resolved.",
+    emphasis: "muted",
   }).catch((err) => {
     log.error(
       {
         err,
         conversationId: params.conversationId,
-        messageTs: params.messageTs,
+        messageId: params.messageId,
       },
       "Failed to edit stale Slack approval message",
     );

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

@@ -112,6 +112,24 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
     });
   }
 
+  // Conversation-agnostic observation (see `runtime/host-observe.ts`): the
+  // request was raised outside any turn, so there is no conversation and no CU
+  // proxy to format the observation. Hand the raw fields to the waiting caller.
+  if (peeked.conversationId === undefined) {
+    const interaction = pendingInteractions.resolve(requestId, "answered");
+    interaction?.rpcResolve?.({
+      axTree,
+      axDiff,
+      screenshot,
+      screenshotWidthPx,
+      screenshotHeightPx,
+      screenWidthPt,
+      screenHeightPt,
+      executionError,
+    });
+    return { accepted: true };
+  }
+
   const conversation = findConversation(peeked.conversationId);
   if (!conversation) {
     pendingInteractions.resolve(requestId, "cancelled");

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

@@ -158,6 +158,7 @@ async function getDetailedHealth() {
     capabilities: {
       memoryOptOut: true,
       retryLastTurn: true,
+      appPins: true,
     },
     ...(profiler ? { profiler } : {}),
     ...migrationHealthFields,
@@ -282,6 +283,7 @@ const cesHealthSchema = z.object({
 const healthCapabilitiesSchema = z.object({
   memoryOptOut: z.boolean(),
   retryLastTurn: z.boolean(),
+  appPins: z.boolean(),
 });
 
 const healthDiskSchema = z.object({

package/src/runtime/routes/inbound-message-handler.ts

@@ -39,7 +39,6 @@ import {
 import { getDiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
 import { classifyDiskPressureTurnPolicy } from "../../daemon/disk-pressure-policy.js";
 import { processMessage } from "../../daemon/process-message.js";
-import { mapChatTypeToConversationType } from "../../daemon/trust-context.js";
 import type { TrustContext } from "../../daemon/trust-context-types.js";
 import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import type { Message as ProviderMessage } from "../../messaging/provider-types.js";
@@ -1030,7 +1029,11 @@ export async function handleChannelInbound({
     sourceMetadata.chatType.trim().length > 0
       ? sourceMetadata.chatType.trim()
       : undefined;
-  trustCtx.conversationType = mapChatTypeToConversationType(sourceChatType);
+  // Decided by the sending channel, which is the only side that knows what its
+  // own surfaces mean. The daemon reads the answer rather than re-deriving it
+  // from a vocabulary where `channel` means a public room on Slack and a
+  // broadcast feed on Telegram.
+  trustCtx.conversationType = sourceMetadata?.conversationType;
 
   // Preserve locale from sourceMetadata so the model can greet in the user's language
   const sourceLanguageCode =
@@ -1092,8 +1095,8 @@ export async function handleChannelInbound({
     // cleanup. When a Slack block_actions payload is forwarded, the gateway
     // sets sourceMetadata.messageId to the ts of the message containing
     // the button. This lets us edit the message after resolution.
-    const approvalMessageTs =
-      sourceChannel === "slack" && typeof sourceMetadata?.messageId === "string"
+    const approvalMessageId =
+      typeof sourceMetadata?.messageId === "string"
         ? sourceMetadata.messageId
         : undefined;
 
@@ -1109,7 +1112,7 @@ export async function handleChannelInbound({
       assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       approvalCopyGenerator,
       approvalConversationGenerator,
-      approvalMessageTs,
+      approvalMessageId,
     });
 
     if (approvalResult.handled) {
@@ -1199,10 +1202,10 @@ export async function handleChannelInbound({
       // instead of a silent no-op (JARVIS-299).
       // No channel check: a transport without `edit` declines the call, so a
       // channel gains this the moment it can revise a sent message.
-      if (replyCallbackUrl && approvalMessageTs) {
+      if (replyCallbackUrl && approvalMessageId) {
         editChannelMessage(replyCallbackUrl, {
           chatId: conversationExternalId,
-          messageId: approvalMessageTs,
+          messageId: approvalMessageId,
           text: "This approval request has been resolved.",
         }).catch((err) => {
           log.error(