@vellumai/assistant 0.12.2-staging.1 → 0.12.2-staging.2

package/src/runtime/routes/acp-claude-auth-routes.ts

@@ -18,7 +18,7 @@
  *   has landed.
  * POST /v1/acp/claude/auth/exchange — complete a manual/cloud flow: accept the
  *   pasted `code#state` (or a raw code + state), exchange it, and store the
- *   Claude OAuth token.
+ *   Claude OAuth token set (access token plus any refresh token and expiry).
  *
  * `handleStartAuth` picks loopback vs. manual: a containerized host, or a client
  * that sets `preferManual` because its browser can't reach the daemon's
@@ -126,7 +126,11 @@ async function handleStartLocalAuth(): Promise<StartResponse> {
   // can react. Runs in the background — the web client opens `authorize_url`.
   void flow.completion
     .then(async (result) => {
-      await storeAcpClaudeToken(result.tokens.accessToken);
+      await storeAcpClaudeToken({
+        accessToken: result.tokens.accessToken,
+        refreshToken: result.tokens.refreshToken,
+        expiresIn: result.tokens.expiresIn,
+      });
       pendingFlows.mark(flow.state, "connected");
       log.info("ACP Claude local OAuth flow connected");
     })
@@ -216,7 +220,11 @@ async function handleExchange(args: RouteHandlerArgs): Promise<{ ok: true }> {
       pending.codeVerifier,
       state,
     );
-    await storeAcpClaudeToken(result.tokens.accessToken);
+    await storeAcpClaudeToken({
+      accessToken: result.tokens.accessToken,
+      refreshToken: result.tokens.refreshToken,
+      expiresIn: result.tokens.expiresIn,
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     pendingFlows.mark(state, "error", { error: message });

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

@@ -181,7 +181,7 @@ function workspaceAppItem(a: AppDefinition): AppListItem {
     description: a.description,
     icon: a.icon,
     createdAt: a.createdAt,
-    updatedAt: a.updatedAt,
+    updatedAt: appContentUpdatedAt(getAppDirPath(a.id), a.updatedAt),
     version: a.version ?? "1.0.0",
     contentId: computeContentId(a.name),
     origin: "workspace",
@@ -203,13 +203,28 @@ function pluginAppItem(app: EnumeratedApp): AppListItem {
     id: app.id,
     name: app.name,
     createdAt: mtime,
-    updatedAt: mtime,
+    updatedAt: appContentUpdatedAt(app.sourcePath, mtime),
     version: "1.0.0",
     contentId: computeContentId(app.name),
     origin: `plugin:${pluginName}`,
   };
 }
 
+/** The newest persisted metadata or compiled-output revision for an app. */
+function appContentUpdatedAt(
+  sourcePath: string,
+  metadataUpdatedAt: number,
+): number {
+  try {
+    return Math.max(
+      metadataUpdatedAt,
+      statSync(join(sourcePath, "dist")).mtimeMs,
+    );
+  } catch {
+    return metadataUpdatedAt;
+  }
+}
+
 function getAppDataResult(
   method: string,
   appId: string,

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

@@ -34,7 +34,6 @@ import { credentialKey } from "../../security/credential-key.js";
 import {
   deleteSecureKeyAsync,
   getActiveBackendInfoAsync,
-  getSecureKeyAsync,
   getSecureKeyResultAsync,
 } from "../../security/secure-keys.js";
 import {
@@ -561,9 +560,7 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 
   const key = credentialKey(service, field);
   const affectedConnections = assertCredentialNotInUse(key, force === true);
-  const existing = await getSecureKeyAsync(key);
-  const deleteResult =
-    existing != null ? await deleteSecureKeyAsync(key) : "not-found";
+  const deleteResult = await deleteSecureKeyAsync(key);
 
   if (deleteResult === "error") {
     throw new InternalError(

package/src/runtime/routes/oauth-commands-routes.ts

@@ -66,6 +66,7 @@ interface PlatformConnectionEntry {
   id: string;
   account_label?: string;
   scopes_granted?: string[];
+  provider_params?: Record<string, string> | null;
   status?: string;
 }
 
@@ -574,6 +575,9 @@ async function handleStatus({ queryParams = {} }: RouteHandlerArgs) {
       account: c.account_label ?? null,
       grantedScopes: c.scopes_granted ?? [],
       status: c.status ?? "ACTIVE",
+      // Values the provider scopes the connection by (QuickBooks' realm id),
+      // so a caller can address resources the proxy's base URL does not.
+      providerParams: c.provider_params ?? {},
     }));
 
     return {
@@ -1060,6 +1064,8 @@ async function handleManagedConnect({ body = {} }: RouteHandlerArgs) {
     provider: string;
     scopes?: string[];
     redirect_after_connect?: string;
+    /** Per-tenant providers (Shopify): the customer's own host. */
+    tenant_host?: string;
   };
 
   if (!b.provider) {
@@ -1076,6 +1082,13 @@ async function handleManagedConnect({ body = {} }: RouteHandlerArgs) {
   }
   reqBody.redirect_after_connect =
     b.redirect_after_connect ?? "/account/oauth/complete";
+  // Only forwarded when present: the platform validates it against the
+  // provider's pattern and rejects per-tenant providers that omit it.
+  const tenantHost =
+    typeof b.tenant_host === "string" ? b.tenant_host.trim() : "";
+  if (tenantHost) {
+    reqBody.tenant_host = tenantHost;
+  }
 
   const response = await client.fetch(startPath, {
     method: "POST",
@@ -1122,6 +1135,7 @@ async function handleManagedConnectPoll({
       id: e.id,
       account_label: e.account_label ?? null,
       scopes_granted: e.scopes_granted ?? [],
+      provider_params: e.provider_params ?? {},
     })),
   };
 }

package/src/runtime/routes/oauth-providers.ts

@@ -397,6 +397,13 @@ export const oauthProviderSummarySchema = z.object({
   supports_managed_mode: z.boolean(),
   managed_service_is_paid: z.boolean(),
   feature_flag: z.string().nullable(),
+  tenant_host: z
+    .object({
+      pattern: z.string(),
+      label: z.string(),
+      placeholder: z.string(),
+    })
+    .nullable(),
   acts_as: z.enum(["user", "assistant"]),
 });
 

package/src/tools/computer-use/definitions.ts

@@ -569,7 +569,7 @@ export const computerUseObserveTool = {
       include_screenshot: {
         type: "boolean",
         description:
-          "Force a screenshot with this observation. The accessibility tree is returned every step; ask for pixels whenever the tree is not enough to act on, such as a canvas, a game, a custom-drawn view, a window with few or unlabeled controls, or a question about layout.",
+          "Force a screenshot with this observation. The accessibility tree is returned every step and actions always return a screenshot of their result; ask for pixels on an observation whenever the tree is not enough to act on, such as a canvas, a game, a custom-drawn view, a window with few or unlabeled controls, or a question about layout.",
       },
       full_tree: {
         type: "boolean",

package/src/tools/ui-surface/channel-variants.ts

@@ -1,68 +1,19 @@
 /**
- * Per-conversation wire projections of the UI surface tool definitions.
+ * Conversation-stable wire projections of the UI surface tool definitions.
  *
- * Slack renders exactly one surface — the task_progress card (everything else
- * is rejected at execution; see `isSlackTaskProgressUiException` in
- * `daemon/conversation-surfaces.ts`) — so Slack conversations get a `ui_show`
- * variant documenting only that shape instead of the full multi-surface docs.
- * Activation-rail conversations additionally get the `activation_moment`
- * telemetry param, which no other conversation pays schema tokens for (the
- * emit path is gated on `isActivationSession` regardless).
+ * `ui_show`, `ui_update`, and `ui_dismiss` keep one definition across every
+ * channel and across live vs clientless turns. Channel renderers enforce the
+ * surfaces they can display at execution. Clientless calls persist surface
+ * content for the next capable client that opens the conversation.
  *
- * Projection contract: shared definition objects are never mutated (variants
- * are module-level constants swapped in via spread-copy), and the projected
- * set is a pure function of per-conversation-stable state, so a
- * conversation's tools+system prompt-cache prefix stays stable across turns.
+ * `activation_moment` is the remaining schema projection. It applies only to
+ * activation-rail conversations, whose marker is written before the first
+ * tool resolution, so the extra property is stable for that conversation's
+ * lifetime. It must not vary by channel or turn presence.
  */
 
 import type { ToolDefinition } from "../../providers/types.js";
 import { ACTIVATION_MOMENT_PARAMS } from "../../telemetry/activation-funnel.js";
-import { TASK_PROGRESS_TEMPLATE_SHAPE } from "./surface-shape-docs.js";
-
-const SLACK_UI_SHOW_DESCRIPTION = `Show a live task-progress card for the current work — the only surface this channel renders. data: { template: "task_progress", templateData: ${TASK_PROGRESS_TEMPLATE_SHAPE} }. Show it early on multi-step turns and advance step statuses via ui_update as work progresses.`;
-
-const SLACK_UI_SHOW_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    surface_type: {
-      type: "string",
-      enum: ["card"],
-      description: "Always card on this channel",
-    },
-    title: {
-      type: "string",
-      description: "Optional surface title",
-    },
-    data: {
-      type: "object",
-      description:
-        'Card data: { template: "task_progress", templateData: { title, status, steps } }',
-    },
-  },
-  required: ["surface_type", "data"],
-};
-
-/**
- * Swap UI surface tool definitions for channel-appropriate variants. Returns
- * the input array unchanged (same identity) for channels without a variant.
- */
-export function projectUiToolsForChannel(
-  definitions: ToolDefinition[],
-  channel: string | undefined,
-): ToolDefinition[] {
-  if (channel !== "slack") {
-    return definitions;
-  }
-  return definitions.map((def) =>
-    def.name === "ui_show"
-      ? {
-          ...def,
-          description: SLACK_UI_SHOW_DESCRIPTION,
-          input_schema: SLACK_UI_SHOW_INPUT_SCHEMA,
-        }
-      : def,
-  );
-}
 
 const ACTIVATION_MOMENT_PROPERTY = {
   type: "string",
@@ -73,7 +24,7 @@ const ACTIVATION_MOMENT_PROPERTY = {
 
 /**
  * Add the optional `activation_moment` param to ui_show's schema. Applied
- * only for activation-rail conversations (`isActivationSession`) — the rail
+ * only for activation-rail conversations (`isActivationSession`). The rail
  * bootstrap prompt instructs the tagging, and the daemon's emit path reads
  * the tag from tool input independently of this schema.
  */

package/src/watch/watch-retro.ts

@@ -61,14 +61,12 @@ const WATCH_RETRO_WAKE_SOURCE = "watch-retro";
  * under the `watch_retro` template, which the client draws as a paged card: the
  * record on the first page, one question per page after it.
  *
- * **The daemon appends the card; the model never reaches `ui_show`.** This wake
- * is `clientless`, and `conversation-tool-setup` gates the whole `ui_surface`
- * family on a client being present, so `ui_show` is absent from this turn's
- * tool set rather than merely denied. A retrospective told to call it can only
- * report that it cannot. `watch_retro_report` is an ordinary tool and passes
- * that gate, and the surface is appended here, the way the memory
- * retrospective's `skill_card` is appended by the daemon rather than requested
- * by the model.
+ * **The daemon appends the card; the model calls `watch_retro_report`.** This
+ * wake is `clientless`. `ui_show` stays on the wire so background surfaces can
+ * persist, but this flow still reports through `watch_retro_report` so the
+ * daemon can append the card after the turn ends. The memory retrospective's
+ * `skill_card` is appended the same way: the daemon writes the surface, the
+ * model does not request it.
  *
  * **The append waits for the turn to end.** A `ui_surface` row written mid-turn
  * can land between a persisted `tool_use` and its `tool_result`, an ordering