@vellumai/assistant 0.7.3 → 0.8.1

package/src/daemon/handlers/config-model.ts

@@ -1,38 +1,16 @@
+import { resolveCallSiteConfig } from "../../config/llm-resolver.js";
 import {
   getConfig,
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import {
-  setLlmDefaultField,
-  setServiceField,
-} from "../../config/raw-config-utils.js";
-import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
+import { setServiceField } from "../../config/raw-config-utils.js";
 import { providerForImageModelPrefix } from "../../media/types.js";
 import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
-import {
-  isModelInCatalog,
-  PROVIDER_CATALOG,
-} from "../../providers/model-catalog.js";
-import { getProviderDefaultModel } from "../../providers/model-intents.js";
-import {
-  getConfiguredProviders,
-  isProviderAvailable,
-} from "../../providers/provider-availability.js";
-import { initializeProviders } from "../../providers/registry.js";
-import {
-  conversationEntries,
-  deleteConversation,
-} from "../conversation-store.js";
+import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
+import { getConfiguredProviders } from "../../providers/provider-availability.js";
 import { CONFIG_RELOAD_DEBOUNCE_MS, log } from "./shared.js";
 
-/** Reverse lookup: model ID → provider, derived from PROVIDER_CATALOG. */
-const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
-  PROVIDER_CATALOG.flatMap((provider) =>
-    provider.models.map(({ id }) => [id, provider.id]),
-  ),
-);
-
 // ---------------------------------------------------------------------------
 // Shared business logic (transport-agnostic)
 // ---------------------------------------------------------------------------
@@ -85,10 +63,11 @@ export function projectProviderForWire(
 /** Return current model configuration. */
 export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
-  const provider = config.llm.default.provider;
+  const resolved = resolveCallSiteConfig("mainAgent", config.llm);
+  const provider = resolved.provider;
 
   return {
-    model: config.llm.default.model,
+    model: resolved.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
     availableModels: PROVIDER_CATALOG.find(
@@ -99,7 +78,7 @@ export async function getModelInfo(): Promise<ModelInfo> {
 }
 
 /**
- * Minimal interface for the side-effects needed by setModel / setImageGenModel.
+ * Minimal interface for the side-effects needed by setImageGenModel.
  * Keeps the business logic decoupled from transport-specific server context.
  */
 export interface ModelSetContext {
@@ -109,103 +88,6 @@ export interface ModelSetContext {
   debounceTimers: { schedule(key: string, fn: () => void, ms: number): void };
 }
 
-/**
- * Set the active model. Returns the resulting ModelInfo, or throws on failure.
- * The caller is responsible for sending the response to the client.
- *
- * When `explicitProvider` is supplied, it takes precedence over automatic
- * provider inference from the model ID. If the provider changes and the
- * current model doesn't belong to the new provider's catalog, the model
- * is auto-reset to the provider's default.
- */
-export async function setModel(
-  modelId: string,
-  ctx: ModelSetContext,
-  explicitProvider?: string,
-): Promise<ModelInfo> {
-  const validProviders = new Set<string>(VALID_INFERENCE_PROVIDERS);
-
-  // Validate explicit provider against allowlist
-  if (explicitProvider && !validProviders.has(explicitProvider)) {
-    throw new Error(
-      `Invalid provider "${explicitProvider}". Valid providers: ${[...validProviders].join(", ")}`,
-    );
-  }
-
-  // Resolve provider: explicit > MODEL_TO_PROVIDER lookup > current
-  const current = getConfig();
-  const resolvedProvider =
-    explicitProvider ??
-    MODEL_TO_PROVIDER[modelId] ??
-    current.llm.default.provider;
-
-  // Auto-reset model when provider changes and current modelId doesn't
-  // belong to the new provider's catalog.
-  if (
-    resolvedProvider !== current.llm.default.provider &&
-    !isModelInCatalog(resolvedProvider, modelId)
-  ) {
-    modelId = getProviderDefaultModel(resolvedProvider);
-  }
-
-  // No-op guard: skip expensive reinitialization when nothing changed
-  if (
-    modelId === current.llm.default.model &&
-    resolvedProvider === current.llm.default.provider
-  ) {
-    return await getModelInfo();
-  }
-
-  // Validate provider availability (secure key, env var, or managed proxy) before switching
-  if (!(await isProviderAvailable(resolvedProvider))) {
-    // Return current model_info so the client resyncs its optimistic state
-    return await getModelInfo();
-  }
-
-  // Use raw config to avoid persisting env-var API keys to disk
-  const raw = loadRawConfig();
-  setLlmDefaultField(raw, "model", modelId);
-  setLlmDefaultField(raw, "provider", resolvedProvider);
-
-  // Suppress the file watcher callback — setModel already does
-  // the full reload sequence; a redundant watcher-triggered reload
-  // would incorrectly evict sessions created after this method returns.
-  const wasSuppressed = ctx.suppressConfigReload;
-  ctx.setSuppressConfigReload(true);
-  try {
-    saveRawConfig(raw);
-  } catch (err) {
-    ctx.setSuppressConfigReload(wasSuppressed);
-    throw err;
-  }
-  ctx.debounceTimers.schedule(
-    "__suppress_reset__",
-    () => {
-      ctx.setSuppressConfigReload(false);
-    },
-    CONFIG_RELOAD_DEBOUNCE_MS,
-  );
-
-  // Re-initialize provider with the new model so LLM calls use it
-  const config = getConfig();
-  await initializeProviders(config);
-
-  // Evict idle conversations immediately; mark busy ones as stale so they
-  // get recreated with the new provider once they finish processing.
-  for (const [id, conversation] of conversationEntries()) {
-    if (!conversation.isProcessing()) {
-      conversation.dispose();
-      deleteConversation(id);
-    } else {
-      conversation.markStale();
-    }
-  }
-
-  ctx.updateConfigFingerprint();
-
-  return await getModelInfo();
-}
-
 /**
  * Set the image generation model. Throws on failure.
  */

package/src/daemon/handlers/config-slack-channel.ts

@@ -54,6 +54,7 @@ const SLACK_INJECTION_TEMPLATES = [
 /** Ensure the bot token credential has injection templates for the proxy. */
 function ensureBotTokenInjectionTemplates(): void {
   upsertCredentialMetadata("slack_channel", "bot_token", {
+    allowedTools: ["bash"],
     allowedDomains: ["slack.com"],
     injectionTemplates: SLACK_INJECTION_TEMPLATES,
   });
@@ -62,6 +63,7 @@ function ensureBotTokenInjectionTemplates(): void {
 /** Ensure the user token credential has injection templates for the proxy. */
 function ensureUserTokenInjectionTemplates(): void {
   upsertCredentialMetadata("slack_channel", "user_token", {
+    allowedTools: ["bash"],
     allowedDomains: ["slack.com"],
     injectionTemplates: SLACK_INJECTION_TEMPLATES,
   });
@@ -209,7 +211,9 @@ export async function setSlackChannelConfig(
       botToken,
     );
     if (!stored) {
-      return currentErrorSnapshot("Failed to store bot token in secure storage");
+      return currentErrorSnapshot(
+        "Failed to store bot token in secure storage",
+      );
     }
 
     ensureBotTokenInjectionTemplates();
@@ -262,8 +266,7 @@ export async function setSlackChannelConfig(
           data.team_id !== metadata.teamId
         ) {
           shouldClear = true;
-          clearReason =
-            "User token from a different workspace was removed.";
+          clearReason = "User token from a different workspace was removed.";
         }
       } catch (err) {
         // Transient failure (DNS error, network blip, connection reset,
@@ -310,7 +313,9 @@ export async function setSlackChannelConfig(
       appToken,
     );
     if (!stored) {
-      return currentErrorSnapshot("Failed to store app token in secure storage");
+      return currentErrorSnapshot(
+        "Failed to store app token in secure storage",
+      );
     }
 
     upsertCredentialMetadata("slack_channel", "app_token", {});
@@ -344,9 +349,7 @@ export async function setSlackChannelConfig(
       userTeamId = data.team_id;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      return currentErrorSnapshot(
-        `Failed to validate user token: ${message}`,
-      );
+      return currentErrorSnapshot(`Failed to validate user token: ${message}`);
     }
 
     // Cross-check: if a bot token has already been configured, the user token

package/src/daemon/handlers/config-vercel.ts

@@ -59,7 +59,9 @@ export async function setVercelConfig(
   }
 
   upsertCredentialMetadata("vercel", "api_token", {
-    allowedTools: ["deploy", "publish_page"],
+    allowedTools: ["publish_page", "unpublish_page"],
+    allowedDomains: [],
+    injectionTemplates: null,
   });
 
   log.info("Vercel API token stored successfully");

package/src/daemon/handlers/shared.ts

@@ -63,6 +63,20 @@ export interface HistoryToolCall {
   approvalReason?: string;
   /** Snapshot of the auto-approve threshold at execution time. */
   riskThreshold?: string;
+  /**
+   * Display-only regex ladder for the rule editor (narrowest → broadest).
+   * Persisted on tool_use blocks by `annotatePersistedAssistantMessage` so
+   * historical chips render the same ladder as live tool_result events.
+   */
+  riskScopeOptions?: Array<{ pattern: string; label: string }>;
+  /** Minimatch save patterns for the rule editor (narrowest → broadest). */
+  riskAllowlistOptions?: Array<{
+    label: string;
+    description: string;
+    pattern: string;
+  }>;
+  /** Directory scope ladder for the rule editor. */
+  riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
 }
 
 export interface HistorySurface {
@@ -368,6 +382,18 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
         entry.approvalReason = block._approvalReason;
       if (typeof block._riskThreshold === "string")
         entry.riskThreshold = block._riskThreshold;
+      // Read back the 3 risk-option arrays persisted by
+      // `annotatePersistedAssistantMessage`. Validate the array shape only
+      // — element shapes are best-effort (we trust our own writer).
+      if (Array.isArray(block._riskScopeOptions))
+        entry.riskScopeOptions =
+          block._riskScopeOptions as HistoryToolCall["riskScopeOptions"];
+      if (Array.isArray(block._riskAllowlistOptions))
+        entry.riskAllowlistOptions =
+          block._riskAllowlistOptions as HistoryToolCall["riskAllowlistOptions"];
+      if (Array.isArray(block._riskDirectoryScopeOptions))
+        entry.riskDirectoryScopeOptions =
+          block._riskDirectoryScopeOptions as HistoryToolCall["riskDirectoryScopeOptions"];
       toolCalls.push(entry);
       if (id) pendingToolUses.set(id, entry);
       contentOrder.push(`tool:${toolCalls.length - 1}`);

package/src/daemon/handlers/skills.ts

@@ -691,6 +691,65 @@ export async function getSkill(
   return { skill: detail };
 }
 
+export function getSkillLocalDetail(
+  skillId: string,
+): {
+  ok: true;
+  id: string;
+  name: string;
+  description: string;
+  emoji: string | null;
+  source: string;
+  state: string;
+  directoryPath: string;
+  featureFlag: string | null;
+  includes: string[] | null;
+  activationHints: string[] | null;
+  avoidWhen: string[] | null;
+  toolManifest: { valid: boolean; toolCount: number; toolNames: string[] } | null;
+  installMeta: Record<string, unknown> | null;
+  config: { enabled: boolean; envKeys: string[]; configKeys: string[] } | null;
+} | { ok: false; error: string; status: 404 | 500 } {
+  try {
+    const catalog = loadSkillCatalog();
+    const config = getConfig();
+    const resolved = resolveSkillStates(catalog, config);
+    const match = resolved.find((r) => r.summary.id === skillId);
+    if (!match) {
+      return { ok: false, error: `Skill "${skillId}" not found. Run 'assistant skills list' to see available skills.`, status: 404 };
+    }
+    const { summary, state, configEntry } = match;
+    const installMeta = readInstallMeta(summary.directoryPath);
+    return {
+      ok: true,
+      id: summary.id,
+      name: summary.displayName,
+      description: summary.description,
+      emoji: summary.emoji ?? null,
+      source: summary.source,
+      state,
+      directoryPath: summary.directoryPath,
+      featureFlag: summary.featureFlag ?? null,
+      includes: summary.includes ?? null,
+      activationHints: summary.activationHints ?? null,
+      avoidWhen: summary.avoidWhen ?? null,
+      toolManifest: summary.toolManifest
+        ? { valid: summary.toolManifest.valid, toolCount: summary.toolManifest.toolCount, toolNames: summary.toolManifest.toolNames }
+        : null,
+      installMeta: installMeta ? (installMeta as unknown as Record<string, unknown>) : null,
+      config: configEntry
+        ? {
+            enabled: configEntry.enabled !== false,
+            envKeys: configEntry.env ? Object.keys(configEntry.env) : [],
+            configKeys: configEntry.config ? Object.keys(configEntry.config) : [],
+          }
+        : null,
+    };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err), status: 500 };
+  }
+}
+
 // ─── Skill file listing ──────────────────────────────────────────────────────
 
 // `SkillFileEntry` lives in `../../skills/catalog-files.ts` to keep a single
@@ -1017,6 +1076,8 @@ export async function installSkill(spec: {
   slug: string;
   version?: string;
   origin?: "clawhub" | "skillssh";
+  catalogOnly?: boolean;
+  overwrite?: boolean;
   contactId?: string;
 }): Promise<
   { success: true; skillId: string } | { success: false; error: string }
@@ -1078,10 +1139,14 @@ export async function installSkill(spec: {
         const vellumCatalog = await getCatalog();
         const catalogEntry = vellumCatalog.find((s) => s.id === spec.slug);
         if (catalogEntry) {
+          // Default `overwrite` to true at the handler boundary to preserve
+          // pre-existing HTTP API behaviour. CLI callers always pass an
+          // explicit boolean (`opts.overwrite ?? false`) so the CLI surface
+          // still defaults to non-destructive installs.
           await installSkillLocally(
             spec.slug,
             catalogEntry,
-            true,
+            spec.overwrite ?? true,
             spec.contactId,
           );
 
@@ -1090,13 +1155,19 @@ export async function installSkill(spec: {
           return { success: true, skillId: spec.slug };
         }
       } catch (err) {
-        // If catalog lookup/install fails, fall through to community registries
+        if (spec.catalogOnly) {
+          return { success: false, error: `Failed to install catalog skill "${spec.slug}"` };
+        }
         log.warn(
           { err, skillId: spec.slug },
           "Vellum catalog install failed, falling back to community registry",
         );
       }
 
+    if (spec.catalogOnly) {
+      return { success: false, error: `Skill "${spec.slug}" not found in the Vellum catalog` };
+    }
+
     // skills.sh install path: route here when origin is explicitly "skillssh"
     // or when the slug looks like a skills.sh multi-segment format (owner/repo/skill)
     if (
@@ -1104,11 +1175,14 @@ export async function installSkill(spec: {
       (spec.origin !== "clawhub" && looksLikeSkillsShSlug(spec.slug))
     ) {
       const resolved = resolveSkillSource(spec.slug);
+      // Default `overwrite` to true at the handler boundary to preserve
+      // pre-existing HTTP API behaviour (same rationale as the catalog
+      // install path above).
       await installExternalSkill(
         resolved.owner,
         resolved.repo,
         resolved.skillSlug,
-        true /* overwrite */,
+        spec.overwrite ?? true,
         resolved.ref ?? spec.version,
         spec.contactId,
       );
@@ -1209,6 +1283,10 @@ export async function uninstallSkill(
       state: "uninstalled",
     });
 
+    // Without this, an uninstalled skill remains queryable in v2 until the
+    // next incidental seed event (enable/disable/install).
+    maybeSeedMemoryV2Skills(getConfig());
+
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1250,6 +1328,7 @@ export async function checkSkillUpdates(): Promise<
 
 export async function searchSkills(
   query: string,
+  limit: number = 25,
 ): Promise<
   | { success: true; skills: SlimSkillResponse[] }
   | { success: false; error: string }
@@ -1290,8 +1369,8 @@ export async function searchSkills(
 
     // Search both community registries in parallel (non-fatal on failure)
     const [clawhubResult, skillsshResult] = await Promise.allSettled([
-      clawhubSearch(query),
-      searchSkillsRegistry(query, 25),
+      clawhubSearch(query, { limit }),
+      searchSkillsRegistry(query, limit),
     ]);
 
     let clawhubSkills: SlimSkillResponse[] = [];

package/src/daemon/history-repair.ts

@@ -68,11 +68,14 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
-      // Ensure every server_tool_use has a paired web_search_tool_result
-      // in the same assistant message (handles interrupted streams).
-      // Synthetic results are inserted IMMEDIATELY AFTER their corresponding
-      // server_tool_use block — not appended to the end — so that
-      // ensureToolPairing's split at tool_use boundaries cannot separate them.
+      // Pair server-side tool blocks within the same assistant message.
+      // Server tools (e.g. web_search) emit server_tool_use + matching
+      // web_search_tool_result. Either side can go missing — the synthetic
+      // result is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
+      // appended to the end) so ensureToolPairing's split at tool_use
+      // boundaries cannot separate the pair. An orphan
+      // web_search_tool_result (no preceding server_tool_use) is downgraded
+      // to text — Anthropic rejects the request otherwise.
       const serverToolIds = new Set(
         cleanedContent
           .filter(
@@ -91,11 +94,35 @@ export function repairHistory(messages: Message[]): RepairResult {
           orphanedServerIds.add(id);
         }
       }
+      const orphanedWebSearchResultIds = new Set<string>();
+      for (const id of matchedServerIds) {
+        if (!serverToolIds.has(id)) {
+          orphanedWebSearchResultIds.add(id);
+        }
+      }
 
       let repairedContent: ContentBlock[];
-      if (orphanedServerIds.size > 0) {
+      if (orphanedServerIds.size > 0 || orphanedWebSearchResultIds.size > 0) {
         repairedContent = [];
         for (const block of cleanedContent) {
+          if (
+            block.type === "web_search_tool_result" &&
+            orphanedWebSearchResultIds.has(
+              (block as { tool_use_id: string }).tool_use_id,
+            )
+          ) {
+            repairedContent.push(
+              downgradeResult(
+                block as {
+                  type: "web_search_tool_result";
+                  tool_use_id: string;
+                  content: unknown;
+                },
+              ),
+            );
+            stats.orphanToolResultsDowngraded++;
+            continue;
+          }
           repairedContent.push(block);
           if (
             block.type === "server_tool_use" &&

package/src/daemon/host-app-control-proxy.ts

@@ -15,9 +15,11 @@
  * session at a time, and that session is bound to a specific target app.
  * The lock is module-level (`activeAppControlSession`) because the session
  * targets the user's actual desktop application, which is a host-wide
- * resource. It is acquired on a successful `app_control_start` (storing
- * `(conversationId, app)`) and released when the owning proxy's
- * `dispose()` fires.
+ * resource. It is acquired optimistically when `app_control_start` is
+ * dispatched (storing `(conversationId, app)`) so that the synchronous
+ * guard and the asynchronous host round-trip cannot race; it is released
+ * when the host returns a non-running state, the dispatch fails, or the
+ * owning proxy's `dispose()` fires.
  *
  * `app_control_start` is the only tool that can acquire the lock — the
  * user's medium-risk approval at start time is the consent boundary. All
@@ -144,12 +146,12 @@ function checkNonStartAuthorization(
   // except `stop`, and `stop` short-circuits in conversation-surfaces and
   // does not reach this method in production. A stop reaching here would
   // be a defensive bug — surface it explicitly rather than dispatch.
-  const requestedApp = (input as { app?: string }).app;
-  if (requestedApp == null) {
+  const requestedApp = (input as { app?: unknown }).app;
+  if (typeof requestedApp !== "string") {
     return {
       content:
-        "Tool input missing required 'app' field; cannot validate against " +
-        "the active app-control session.",
+        "Tool input missing required string 'app' field; cannot validate " +
+        "against the active app-control session.",
       isError: true,
     };
   }
@@ -222,6 +224,8 @@ export class HostAppControlProxy extends HostProxyBase<
     input: HostAppControlInput,
     conversationId: string,
     signal: AbortSignal,
+    sourceActorPrincipalId?: string,
+    targetClientId?: string,
   ): Promise<ToolExecutionResult> {
     if (signal.aborted) {
       return { content: "Aborted", isError: true };
@@ -235,7 +239,7 @@ export class HostAppControlProxy extends HostProxyBase<
     if (input.tool === "start") {
       if (
         activeAppControlSession != null &&
-        activeAppControlSession.conversationId !== conversationId
+        activeAppControlSession.conversationId !== this.conversationId
       ) {
         return {
           content:
@@ -245,8 +249,21 @@ export class HostAppControlProxy extends HostProxyBase<
           isError: true,
         };
       }
+      // Acquire optimistically to close the TOCTOU window between this
+      // synchronous guard and the asynchronous `dispatchRequest` below. Two
+      // concurrent starts from different conversations would otherwise both
+      // see `activeAppControlSession == null` and both pass the guard. The
+      // lock is released below if dispatch fails or the host returns a
+      // non-running state.
+      activeAppControlSession = {
+        conversationId: this.conversationId,
+        app: input.app,
+      };
     } else {
-      const sessionError = checkNonStartAuthorization(input, conversationId);
+      const sessionError = checkNonStartAuthorization(
+        input,
+        this.conversationId,
+      );
       if (sessionError != null) {
         return sessionError;
       }
@@ -258,9 +275,14 @@ export class HostAppControlProxy extends HostProxyBase<
         input,
         conversationId,
         signal,
+        undefined,
+        targetClientId,
       );
       return this.handleSuccess(input, payload);
     } catch (err) {
+      if (input.tool === "start") {
+        this.releaseSessionIfHeld();
+      }
       if (err instanceof HostProxyRequestError) {
         if (err.reason === "timeout") {
           log.warn({ toolName }, "Host app-control proxy request timed out");
@@ -279,6 +301,12 @@ export class HostAppControlProxy extends HostProxyBase<
     }
   }
 
+  private releaseSessionIfHeld(): void {
+    if (activeAppControlSession?.conversationId === this.conversationId) {
+      activeAppControlSession = undefined;
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Result handling
   // ---------------------------------------------------------------------------
@@ -304,13 +332,12 @@ export class HostAppControlProxy extends HostProxyBase<
       }
     }
 
-    // Store the exact `app` form for validation against subsequent
-    // non-start tool calls.
-    if (input.tool === "start" && payload.state === "running") {
-      activeAppControlSession = {
-        conversationId: this.conversationId,
-        app: input.app,
-      };
+    // The optimistic lock acquired in `request()` for `start` stays held
+    // only when the host confirms the session is running. Non-running
+    // outcomes (missing/minimized) release it so a retry or another
+    // conversation can acquire.
+    if (input.tool === "start" && payload.state !== "running") {
+      this.releaseSessionIfHeld();
     }
 
     return this.formatResult(payload, stuck);
@@ -382,8 +409,6 @@ export class HostAppControlProxy extends HostProxyBase<
    */
   override dispose(): void {
     super.dispose();
-    if (activeAppControlSession?.conversationId === this.conversationId) {
-      activeAppControlSession = undefined;
-    }
+    this.releaseSessionIfHeld();
   }
 }