@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/daemon/conversation-agent-loop.ts

@@ -733,8 +733,33 @@ export async function runAgentLoopImpl(
   // the `finally` (before processing clears, so the reporter's settled-turn
   // barrier guarantees the stamp ships with the turn event). Unset = the turn
   // replied normally and carries no stamp.
+  const failedOutcomeFromClassification = (classified: {
+    code: string;
+    userMessage: string;
+    errorCategory: string;
+    connectionName?: string;
+    profileName?: string;
+  }): NonNullable<typeof abnormalOutcome> => ({
+    outcome: "failed",
+    failureCode: classified.code,
+    failureMessage: classified.userMessage,
+    failureCategory: classified.errorCategory,
+    ...(classified.connectionName
+      ? { failureConnection: classified.connectionName }
+      : {}),
+    ...(classified.profileName
+      ? { failureProfile: classified.profileName }
+      : {}),
+  });
   let abnormalOutcome:
-    | { outcome: "failed" | "cancelled"; failureCode?: string }
+    | {
+        outcome: "failed" | "cancelled";
+        failureCode?: string;
+        failureMessage?: string;
+        failureCategory?: string;
+        failureConnection?: string;
+        failureProfile?: string;
+      }
     | undefined;
   // True once a replied terminal SSE (message_complete / generation_handoff)
   // has been emitted. Guards the catch block: an error thrown by the
@@ -777,6 +802,10 @@ export async function runAgentLoopImpl(
       try {
         stampTurnOutcome(userMessageId, abnormalOutcome.outcome, {
           failureCode: abnormalOutcome.failureCode,
+          failureMessage: abnormalOutcome.failureMessage,
+          failureCategory: abnormalOutcome.failureCategory,
+          failureConnection: abnormalOutcome.failureConnection,
+          failureProfile: abnormalOutcome.failureProfile,
         });
       } catch (err) {
         rlog.warn(
@@ -858,6 +887,7 @@ export async function runAgentLoopImpl(
       abnormalOutcome = {
         outcome: "failed",
         failureCode: DISK_PRESSURE_ERROR_CODE,
+        failureMessage: message,
       };
       rlog.warn(
         { reason: diskPressureDecision.reason },
@@ -1382,17 +1412,16 @@ export async function runAgentLoopImpl(
       );
       // Exhausted-overflow exit: the reduction ladder is spent and the turn
       // ends without a real reply, so label it failed for telemetry.
-      abnormalOutcome = { outcome: "failed", failureCode: classified.code };
+      abnormalOutcome = failedOutcomeFromClassification(classified);
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
     } else if (
       overflowTerminalReason === "budget_yield_unrecovered" &&
       !abortController.signal.aborted
     ) {
       budgetYieldClassification = budgetYieldUnrecoveredClassification();
-      abnormalOutcome = {
-        outcome: "failed",
-        failureCode: budgetYieldClassification.code,
-      };
+      abnormalOutcome = failedOutcomeFromClassification(
+        budgetYieldClassification,
+      );
       onEvent(
         buildConversationErrorMessage(
           ctx.conversationId,
@@ -1548,6 +1577,16 @@ export async function runAgentLoopImpl(
         ...(state.providerErrorCode
           ? { failureCode: state.providerErrorCode }
           : {}),
+        failureMessage: state.providerErrorUserMessage,
+        ...(state.providerErrorCategory
+          ? { failureCategory: state.providerErrorCategory }
+          : {}),
+        ...(state.providerErrorConnection
+          ? { failureConnection: state.providerErrorConnection }
+          : {}),
+        ...(state.providerErrorProfile
+          ? { failureProfile: state.providerErrorProfile }
+          : {}),
       };
       // Drop any reservation stranded by the failed LLM call. The B3
       // pre-allocation path reserves an empty assistant row at
@@ -1684,9 +1723,23 @@ export async function runAgentLoopImpl(
         tokens: state.lastCallInputTokens,
         maxTokens: resolveCurrentMaxInputTokens(),
       },
+      // When the turn's last LLM call was rerouted to a backup profile, that
+      // profile is what served the tokens being recorded, so it outranks the
+      // conversation's own resolution, which knows nothing about the
+      // reroute. `provider` and `model` on this same row already follow the
+      // backup (via `state.exchangeProviderName` / `state.model`), so
+      // attributing the profile from the primary would write a row that
+      // contradicts itself. `forceOverrideProfile` floats it above the
+      // call-site profile exactly as the fallback dispatch did.
       {
         callSite: turnCallSite,
-        overrideProfile: resolveCurrentOverrideProfile() ?? null,
+        overrideProfile:
+          state.exchangeInferenceProfile ??
+          resolveCurrentOverrideProfile() ??
+          null,
+        ...(state.exchangeInferenceProfile !== undefined
+          ? { forceOverrideProfile: true }
+          : {}),
       },
       turnCronRunId,
     );
@@ -1860,7 +1913,7 @@ export async function runAgentLoopImpl(
         ...turnErrorAttribution(),
       });
       if (!turnReplied) {
-        abnormalOutcome = { outcome: "failed", failureCode: classified.code };
+        abnormalOutcome = failedOutcomeFromClassification(classified);
       }
       onEvent({
         type: "error",
@@ -1975,6 +2028,13 @@ function emitUsage(
   attribution?: {
     callSite: LLMCallSite | null;
     overrideProfile?: string | null;
+    /**
+     * Float `overrideProfile` above the call-site profile, matching how the
+     * dispatch path floated it. Set when the profile being attributed is the
+     * one a reroute actually served under rather than the caller's own
+     * resolution.
+     */
+    forceOverrideProfile?: boolean;
   },
   cronRunId: string | null = null,
 ): void {
@@ -2051,6 +2111,8 @@ export async function applyCompactionResult(
     summaryRawResponses?: unknown[];
     summaryCallSite?: LLMCallSite;
     summaryOverrideProfile?: string | null;
+    summaryActualProvider?: string;
+    summaryActualInferenceProfile?: string;
   },
   onEvent: (msg: AssistantEvent) => void,
   reqId: string | null,
@@ -2125,12 +2187,26 @@ export async function applyCompactionResult(
     result.summaryCacheCreationInputTokens ?? 0,
     result.summaryCacheReadInputTokens ?? 0,
     collapseRawResponses(result.summaryRawResponses),
-    undefined /* providerName */,
+    // The provider that actually served the summary, which follows a fallback
+    // reroute the way `summaryModel` already did. Undefined only where no call
+    // was made, and `emitUsage` then falls back to `ctx.provider.name` exactly
+    // as before.
+    result.summaryActualProvider /* providerName */,
     1 /* llmCallCount */,
     undefined /* contextWindow */,
+    // Same rule as the main-agent row above, applied to the compaction row:
+    // a rerouted summary is attributed to the profile that answered, not to
+    // the one the compactor resolved before the call. The two call sites set
+    // this parameter independently off their own state and never share it.
     {
       callSite: result.summaryCallSite ?? null,
-      overrideProfile: result.summaryOverrideProfile ?? null,
+      overrideProfile:
+        result.summaryActualInferenceProfile ??
+        result.summaryOverrideProfile ??
+        null,
+      ...(result.summaryActualInferenceProfile !== undefined
+        ? { forceOverrideProfile: true }
+        : {}),
     },
     options.cronRunId ?? null,
   );

package/src/daemon/conversation-error.ts

@@ -26,6 +26,7 @@ import {
 } from "../util/errors.js";
 import {
   INSUFFICIENT_CREDITS_PATTERNS,
+  isChatTemplateFailureError,
   isVisionNotSupportedError,
 } from "../util/provider-error-patterns.js";
 
@@ -564,6 +565,9 @@ function classifyCore(
       if (isVisionNotSupportedError(message)) {
         return visionNotSupportedClassification();
       }
+      if (isChatTemplateFailureError(message)) {
+        return requestShapeUnsupportedClassification();
+      }
       // Extract the provider detail after "API error (NNN): " prefix
       const detailMatch = message.match(/API error \(\d+\):\s*(.+)/i);
       const detail = detailMatch?.[1];
@@ -654,6 +658,8 @@ function reasonToClassification(
       return contextTooLargeClassification();
     case "vision_unsupported":
       return visionNotSupportedClassification();
+    case "request_shape_unsupported":
+      return requestShapeUnsupportedClassification();
     // Two producers share this reason: SDK transport failures that never got
     // a response (OpenAI APIConnectionError), and Gemini responses whose empty
     // body reveals a proxy/egress filter intercepting the request. The copy
@@ -908,6 +914,25 @@ function visionNotSupportedClassification(): Omit<
   };
 }
 
+/**
+ * Classification for a request rejected by the endpoint's server-side
+ * chat-template renderer. These endpoints choke on richer request shapes
+ * (tool calls, images, structured message content), so the copy points the
+ * user at a capability mismatch instead of the raw template error.
+ */
+function requestShapeUnsupportedClassification(): Omit<
+  ClassifiedConversationError,
+  "debugDetails"
+> {
+  return {
+    code: "PROVIDER_API",
+    userMessage:
+      "This model's provider couldn't process the request format (tool calls or images may not be supported). Switch to a different model in Settings → Models & Services and try again.",
+    retryable: false,
+    errorCategory: "request_shape_unsupported",
+  };
+}
+
 /**
  * Build a user-facing message that names the exact profile / connection
  * to fix when one is known, falling back to a generic phrase otherwise.

package/src/daemon/conversation-evictor.ts

@@ -74,11 +74,9 @@ export class ConversationEvictor {
     getSubagentManager().abortAllForParent(conversationId);
   }
 
-  /** Protect conversations with running or pending subagents from eviction. */
+  /** Protect conversations with in-flight subagents from eviction. */
   shouldProtect(conversationId: string): boolean {
-    return getSubagentManager()
-      .getChildrenOf(conversationId)
-      .some((c) => c.status === "running" || c.status === "pending");
+    return getSubagentManager().hasActiveChildren(conversationId);
   }
 
   /** Record an access for the given conversation (resets its idle clock). */

package/src/daemon/conversation-runtime-assembly.ts

@@ -745,6 +745,7 @@ export function stripNowScratchpad(messages: Message[]): Message[] {
  */
 export function buildChannelCapabilityBlock(
   caps: ChannelCapabilities,
+  clientOs: string | undefined = caps.clientOS,
 ): string | null {
   // Happy path: desktop with full capabilities and no special context — skip injection.
   if (
@@ -752,7 +753,8 @@ export function buildChannelCapabilityBlock(
     caps.supportsDynamicUi &&
     caps.supportsVoiceInput &&
     !isGroupChatType(caps.chatType) &&
-    caps.clientOS !== "macos"
+    clientOs !== "macos" &&
+    clientOs !== "windows"
   ) {
     return null;
   }
@@ -762,17 +764,24 @@ export function buildChannelCapabilityBlock(
   lines.push(`dashboard_capable: ${caps.dashboardCapable}`);
   lines.push(`supports_dynamic_ui: ${caps.supportsDynamicUi}`);
   lines.push(`supports_voice_input: ${caps.supportsVoiceInput}`);
-  if (caps.clientOS) {
-    lines.push(`client_os: ${caps.clientOS}`);
+  if (clientOs) {
+    lines.push(`client_os: ${clientOs}`);
   }
 
-  if (caps.clientOS === "macos") {
+  if (clientOs === "macos") {
     lines.push("");
     lines.push(
       "On macOS, prefer osascript/CLI via `host_bash` over computer use tools, which take over the user's cursor. Use foreground computer use only when no scripting alternative exists or the user explicitly asks.",
     );
   }
 
+  if (clientOs === "windows") {
+    lines.push("");
+    lines.push(
+      "On Windows, `host_bash` runs PowerShell. Use PowerShell syntax and Windows paths. Prefer PowerShell or CLI automation over foreground computer use when either can complete the task reliably.",
+    );
+  }
+
   if (!caps.dashboardCapable) {
     lines.push("");
     lines.push("CHANNEL CONSTRAINTS:");
@@ -834,8 +843,9 @@ export function buildChannelCapabilityBlock(
 export function injectChannelCapabilityContext(
   message: Message,
   caps: ChannelCapabilities,
+  clientOs?: string,
 ): Message {
-  const block = buildChannelCapabilityBlock(caps);
+  const block = buildChannelCapabilityBlock(caps, clientOs);
   if (block === null) {
     return message;
   }
@@ -2642,8 +2652,10 @@ export async function applyRuntimeInjections(
   if (channelCapabilities) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
-      const channelCapabilityBlock =
-        buildChannelCapabilityBlock(channelCapabilities);
+      const channelCapabilityBlock = buildChannelCapabilityBlock(
+        channelCapabilities,
+        clientOs,
+      );
       if (channelCapabilityBlock !== null) {
         channelCapabilitiesCaptured = channelCapabilityBlock;
         result = [

package/src/daemon/conversation-skill-tools.ts

@@ -24,6 +24,7 @@ import type { ActiveSkillEntry } from "../skills/active-skill-tools.js";
 import { deriveActiveSkills } from "../skills/active-skill-tools.js";
 import { getCachedCatalogSync } from "../skills/catalog-cache.js";
 import { readInstallMeta, touchSkillLastUsed } from "../skills/install-meta.js";
+import { isSkillCompatibleWithPlatform } from "../skills/platform-compatibility.js";
 import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import { recordSkillLoadedEvent } from "../telemetry/skill-loaded-events-store.js";
@@ -381,7 +382,10 @@ export function projectSkillTools(
   for (const id of allCandidateIds) {
     const skill = catalogById.get(id);
     const flagKey = skill ? skillFlagKey(skill) : undefined;
-    if (!flagKey || isAssistantFeatureFlagEnabled(flagKey, config)) {
+    if (
+      (!skill || isSkillCompatibleWithPlatform(skill)) &&
+      (!flagKey || isAssistantFeatureFlagEnabled(flagKey, config))
+    ) {
       activeIds.add(id);
     }
   }

package/src/daemon/conversation-slash.ts

@@ -1,5 +1,5 @@
 import type { InterfaceId } from "../channels/types.js";
-import { getEffectiveProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import {
@@ -148,7 +148,7 @@ async function resolveModelCommand(
   parse: ModelCommandParse,
 ): Promise<SlashResolution> {
   const config = getConfig();
-  const profiles = getEffectiveProfilesForProvider(
+  const profiles = getUserSelectableProfilesForProvider(
     config.llm.profiles,
     config.llm.defaultProvider ?? null,
   );

package/src/daemon/conversation-store.ts

@@ -402,7 +402,9 @@ export function clearAllActiveConversations(): number {
  * Evict in-memory conversations after a config/prompt/skills reload so the next
  * turn rebuilds them against the new config. Idle conversations are disposed and
  * dropped; busy ones are marked stale so they're rebuilt once their current turn
- * finishes. Also used when provider credentials change.
+ * finishes. Conversations with in-flight subagents are left in place so a
+ * reload does not abort those children. Also used when provider credentials
+ * change.
  */
 export function evictConversationsForReload(): void {
   const subagentManager = getSubagentManager();
@@ -413,6 +415,11 @@ export function evictConversationsForReload(): void {
     // would silently drop the queued messages, so mark it stale instead and
     // let it rebuild once the queue has run.
     if (!conversation.isProcessing() && !conversation.hasQueuedMessages()) {
+      // Same protection the TTL/LRU evictor applies: an idle parent still
+      // owns mid-task children, and aborting them here would kill that work.
+      if (subagentManager.hasActiveChildren(id)) {
+        continue;
+      }
       subagentManager.abortAllForParent(id);
       conversation.dispose();
       deleteConversation(id);

package/src/daemon/conversation-tool-setup.ts

@@ -9,6 +9,7 @@
 import type { AssistantEvent } from "../api/index.js";
 import {
   type HostProxyCapability,
+  parseClientOs,
   supportsHostProxy,
 } from "../channels/types.js";
 import { getIsPlatform } from "../config/env-registry.js";
@@ -23,6 +24,7 @@ import { isPluginDisabled } from "../plugins/disabled-state.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
+import { supportsClientOsForSkillTool } from "../tools/client-os.js";
 import type { ToolExecutor } from "../tools/executor.js";
 import {
   getAllPluginToolDefinitions,
@@ -410,6 +412,7 @@ export function createToolExecutor(
       sourceThreadId: turnTrust.sourceThreadId,
       requesterIdentifier: turnTrust.requesterIdentifier,
       requesterDisplayName: turnTrust.requesterDisplayName,
+      requesterContactId: turnTrust.requesterContactId,
       channelConversationType: turnTrust.conversationType,
       // The binding's external chat id is the canonical conversation address
       // for every channel adapter (Slack channel, Telegram chat, …); it keys
@@ -430,6 +433,8 @@ export function createToolExecutor(
       toolUseId,
       isPlatformHosted: getIsPlatform(),
       transportInterface: ctx.transportInterface,
+      clientOs:
+        parseClientOs(ctx.currentTurnClientOs ?? ctx.clientOs) ?? undefined,
       overrideProfile: ctx.currentTurnOverrideProfile,
       cronRunId: ctx.currentTurnCronRunId,
       invokingCallSite: ctx.currentCallSite ?? "mainAgent",
@@ -707,6 +712,32 @@ export const ALLOWLIST_ONLY_TOOL_NAMES = new Set<string>([
   "delete_memory_page",
 ]);
 
+/**
+ * Windows parity gate: skill tools may declare `supported_client_os`; drop
+ * them when the turn's client OS (or pinned OS for wakes) is not listed.
+ */
+function isToolSupportedOnClientOs(name: string, ctx: Conversation): boolean {
+  const supportedClientOs = getTool(name)?.supportedClientOs;
+  if (!supportedClientOs) {
+    return true;
+  }
+  const pin = ctx.toolContextPin;
+  const transportInterface = pin
+    ? pin.transportInterface
+    : ctx.transportInterface;
+  const clientOs = pin
+    ? pin.clientOs
+    : (parseClientOs(ctx.currentTurnClientOs ?? ctx.clientOs) ??
+      (transportInterface === "macos" || transportInterface === "windows"
+        ? transportInterface
+        : undefined));
+  return supportsClientOsForSkillTool(supportedClientOs, name, {
+    clientOs,
+    transportInterface,
+    sourceActorPrincipalId: ctx.getTurnActorPrincipalId?.(),
+  });
+}
+
 /**
  * Determine whether a tool is part of the final exposed tool set for the
  * current turn. This helper mirrors the filtering applied by
@@ -729,6 +760,9 @@ export function isToolActiveForContext(
   const transportInterface = pin
     ? pin.transportInterface
     : ctx.transportInterface;
+  if (!isToolSupportedOnClientOs(name, ctx)) {
+    return false;
+  }
 
   // When the conversation is acting as a subagent, the parent orchestrator
   // restricts the tool list. A tool that isn't on the allowlist is not
@@ -1070,6 +1104,9 @@ export function createResolveToolsCallback(
       if (excluded.has(name)) {
         continue;
       }
+      if (!isToolSupportedOnClientOs(name, ctx)) {
+        continue;
+      }
       turnAllowed.add(name);
     }
     // Record the full resolved inventory durably for read-only queries before

package/src/daemon/conversation.ts

@@ -1917,8 +1917,6 @@ export class Conversation {
     requestId: string,
     decision: UserDecision,
     options?: {
-      selectedPattern?: string;
-      selectedScope?: string;
       decisionContext?: string;
       emissionContext?: {
         source?: ConfirmationStateChangedEvent["source"];
@@ -1937,8 +1935,6 @@ export class Conversation {
     const toolUseId = this.prompter.getToolUseId(requestId);
 
     this.prompter.resolveConfirmation(requestId, decision, {
-      selectedPattern: options?.selectedPattern,
-      selectedScope: options?.selectedScope,
       decisionContext: options?.decisionContext,
     });
 

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+/**
+ * What every channel's connect/disconnect handler answers, whatever the
+ * channel.
+ *
+ * Each channel's own schema extends this with its tail: Slack carries a
+ * workspace and a thread mode, Telegram a webhook secret and registered
+ * commands, Discord nothing. The shape is the same one the readiness probes
+ * have, a declared common part plus a per-channel remainder, and it exists so
+ * a caller can ask "is this connected" without knowing which channel it is.
+ *
+ * `connected` is the field that makes this worth extracting. Holding a
+ * credential and having a working connection are different questions, and a
+ * channel that answered only the first would read as set up while delivering
+ * nothing.
+ */
+export const ChannelConfigResultBaseSchema = z.object({
+  /** Whether the operation itself succeeded. */
+  success: z.boolean(),
+  /** Whether a bot credential is stored, regardless of this call. */
+  hasBotToken: z.boolean(),
+  /** Whether the channel is actually connected, not merely credentialled. */
+  connected: z.boolean(),
+  error: z.string().optional(),
+});
+
+export type ChannelConfigResultBase = z.infer<
+  typeof ChannelConfigResultBaseSchema
+>;