@vellumai/assistant 0.6.4 → 0.6.5

package/src/daemon/conversation.ts

@@ -24,7 +24,7 @@ import type {
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import type { Speed } from "../config/schemas/inference.js";
+import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
 import {
   ContextWindowManager,
   type ContextWindowResult,
@@ -47,6 +47,7 @@ import { getHookManager } from "../hooks/manager.js";
 import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
+  getConversationOriginChannel,
   updateConversationContextWindow,
   updateConversationHostAccess,
 } from "../memory/conversation-crud.js";
@@ -62,19 +63,22 @@ import {
 } from "../permissions/v2-consent-policy.js";
 import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import { resolveModelIntent } from "../providers/model-intents.js";
-import type { Message, ModelIntent } from "../providers/types.js";
+import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import * as approvalOverrides from "../runtime/conversation-approval-overrides.js";
+import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { ToolExecutor } from "../tools/executor.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import type { AbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import type { AssistantAttachmentDraft } from "./assistant-attachments.js";
-import { runAgentLoopImpl } from "./conversation-agent-loop.js";
+import {
+  runAgentLoopImpl,
+  trackCompactionOutcome,
+} from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
 import {
   regenerate as regenerateImpl,
@@ -190,6 +194,19 @@ export class Conversation {
   /** @internal */ contextWindowManager: ContextWindowManager;
   /** @internal */ contextCompactedMessageCount = 0;
   /** @internal */ contextCompactedAt: number | null = null;
+  /**
+   * Tracks consecutive compaction failures (summary LLM call threw). In-memory
+   * only — resets to 0 on process restart, which is the intended "one free
+   * retry after restart" behavior. Reset to 0 on any successful compaction.
+   */
+  /** @internal */ consecutiveCompactionFailures = 0;
+  /**
+   * When the circuit breaker is open, this timestamp (ms since epoch) marks
+   * when auto-compaction is allowed to resume. Set to `Date.now() + 1h` after
+   * 3 consecutive failures; cleared on a successful compaction. User-initiated
+   * compaction (`force: true`) bypasses the breaker regardless.
+   */
+  /** @internal */ compactionCircuitOpenUntil: number | null = null;
   /** @internal */ currentRequestId?: string;
   /** @internal */ hasNoClient = false;
   /** @internal */ isSubagent = false;
@@ -238,6 +255,7 @@ export class Conversation {
     languageCode?: string;
   };
   /** @internal */ surfaceActionRequestIds = new Set<string>();
+  /** @internal */ approvedViaPromptThisTurn = false;
   /** @internal */ pendingSurfaceActions = new Map<
     string,
     { surfaceType: SurfaceType }
@@ -265,6 +283,28 @@ export class Conversation {
     string,
     Record<string, unknown>
   >();
+  /**
+   * Pending standalone UI requests keyed by surfaceId.
+   * Daemon-driven surfaces that block the caller until user response or timeout.
+   * @internal
+   */
+  pendingStandaloneSurfaces = new Map<
+    string,
+    {
+      resolve: (result: InteractiveUiResult) => void;
+      timer: ReturnType<typeof setTimeout>;
+      surfaceType: SurfaceType;
+    }
+  >();
+  /**
+   * Short-lived tombstone set of recently-completed standalone surface IDs.
+   * Prevents late client actions from falling through to the LLM path.
+   * @internal
+   */
+  recentlyCompletedStandaloneSurfaces = new Map<
+    string,
+    ReturnType<typeof setTimeout>
+  >();
   /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
@@ -338,7 +378,6 @@ export class Conversation {
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
     cacheTtl?: "5m" | "1h",
-    modelIntent?: ModelIntent,
     modelOverride?: string,
   ) {
     this.conversationId = conversationId;
@@ -386,7 +425,10 @@ export class Conversation {
         );
       }
     });
-    this.secretPrompter = new SecretPrompter(sendToClient);
+    this.secretPrompter = new SecretPrompter(
+      sendToClient,
+      broadcastToAllClients,
+    );
 
     // Register watch/call notifiers (reads ctx properties lazily)
     registerConversationNotifiers(conversationId, this);
@@ -424,7 +466,7 @@ export class Conversation {
     );
 
     const config = getConfig();
-    this.streamThinking = config.thinking.streamThinking ?? false;
+    this.streamThinking = config.llm.default.thinking.streamThinking ?? false;
 
     // CES (Credential Execution Service) — use the shared server-level client.
     // The CES sidecar accepts exactly one bootstrap connection, so the
@@ -441,13 +483,10 @@ export class Conversation {
     const hasSystemPromptOverride = systemPrompt !== buildSystemPrompt();
     this.hasSystemPromptOverride = hasSystemPromptOverride;
 
-    // If an explicit modelOverride is supplied, use it verbatim. Otherwise,
-    // if modelIntent is set, resolve it against the active provider's
-    // intent → model mapping. The AgentLoop passes the resulting string
-    // through to `providerConfig.model` on every turn.
-    const resolvedModel: string | undefined =
-      modelOverride ??
-      (modelIntent ? resolveModelIntent(provider.name, modelIntent) : undefined);
+    // If an explicit modelOverride is supplied, use it verbatim. Otherwise
+    // leave the model unset and let `RetryProvider`'s call-site resolver pick
+    // it up from `llm.default` / `llm.callSites.<id>` on every turn.
+    const resolvedModel: string | undefined = modelOverride;
 
     const resolveSystemPromptCallback = (
       _history: import("../providers/types.js").Message[],
@@ -477,16 +516,17 @@ export class Conversation {
     };
 
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
-    const resolvedSpeed = speedOverride ?? config.speed;
+    const resolvedSpeed = speedOverride ?? config.llm.default.speed;
+    const llmDefault = config.llm.default;
 
     this.agentLoop = new AgentLoop(
       provider,
       systemPrompt,
       {
         maxTokens,
-        maxInputTokens: config.contextWindow.maxInputTokens,
-        thinking: config.thinking,
-        effort: config.effort,
+        maxInputTokens: llmDefault.contextWindow.maxInputTokens,
+        thinking: llmDefault.thinking,
+        effort: llmDefault.effort,
         ...(fastModeEnabled && resolvedSpeed === "fast"
           ? { speed: resolvedSpeed }
           : {}),
@@ -500,7 +540,7 @@ export class Conversation {
     this.contextWindowManager = new ContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
-      config: config.contextWindow,
+      config: llmDefault.contextWindow,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
     });
 
@@ -724,6 +764,35 @@ export class Conversation {
 
   dispose(): void {
     approvalOverrides.clearMode(this.conversationId);
+    // Cancel all pending standalone surfaces so callers get a clean
+    // cancellation instead of hanging forever. Emit dismiss notifications
+    // to the client so surfaces don't remain visually active if the client
+    // reconnects after dispose.
+    const emitDispose =
+      this.broadcastToAllClients ?? this.sendToClient.bind(this);
+    for (const [surfaceId, entry] of this.pendingStandaloneSurfaces) {
+      clearTimeout(entry.timer);
+      try {
+        emitDispose({
+          type: "ui_surface_dismiss",
+          conversationId: this.conversationId,
+          surfaceId,
+        });
+      } catch {
+        // Best-effort: the client may already be disconnected during dispose.
+      }
+      entry.resolve({
+        status: "cancelled",
+        surfaceId,
+        cancellationReason: "resolver_unavailable",
+      });
+    }
+    this.pendingStandaloneSurfaces.clear();
+    // Clear tombstone timers to prevent dangling references after dispose.
+    for (const timer of this.recentlyCompletedStandaloneSurfaces.values()) {
+      clearTimeout(timer);
+    }
+    this.recentlyCompletedStandaloneSurfaces.clear();
     this.hostBashProxy?.dispose();
     this.hostBrowserProxy?.dispose();
     this.hostCuProxy?.dispose();
@@ -762,6 +831,7 @@ export class Conversation {
     options?: { isInteractive?: boolean },
     displayContent?: string,
     transport?: ConversationTransportMetadata,
+    clientMessageId?: string,
   ): { queued: boolean; requestId: string; rejected?: boolean } {
     return enqueueMessageImpl(
       this,
@@ -775,6 +845,7 @@ export class Conversation {
       options,
       displayContent,
       transport,
+      clientMessageId,
     );
   }
 
@@ -927,7 +998,7 @@ export class Conversation {
    * confirmations in the same conversation that match the decision.
    *
    * - allow_10m / allow_conversation → approve ALL pending in conversation
-   * - always_allow / always_allow_high_risk → approve pattern-matching pending
+   * - always_allow → approve pattern-matching pending
    * - always_deny → deny pattern-matching pending
    * - allow / deny (one-time) → no cascading
    */
@@ -1021,14 +1092,9 @@ export class Conversation {
     }
 
     // Persistent allow: cascade if the pattern matches any allowlist candidate.
-    // "always_allow" must NOT cascade to high-risk pending confirmations —
-    // only "always_allow_high_risk" has consent for those.
-    if (
-      (decision === "always_allow" || decision === "always_allow_high_risk") &&
-      selectedPattern &&
-      details
-    ) {
-      if (decision === "always_allow" && details.riskLevel === "high") {
+    // "always_allow" must NOT cascade to high-risk pending confirmations.
+    if (decision === "always_allow" && selectedPattern && details) {
+      if (details.riskLevel === "high") {
         return null;
       }
       for (const option of details.allowlistOptions) {
@@ -1170,8 +1236,21 @@ export class Conversation {
     const result = await this.contextWindowManager.maybeCompact(
       this.messages,
       this.abortController?.signal ?? undefined,
-      { force: true, lastCompactedAt: this.contextCompactedAt ?? undefined },
+      {
+        force: true,
+        lastCompactedAt: this.contextCompactedAt ?? undefined,
+        conversationOriginChannel:
+          getConversationOriginChannel(this.conversationId) ?? undefined,
+      },
     );
+    // Track circuit-breaker state for user-initiated `/compact` and other
+    // forced paths so a successful forced compaction clears a stuck counter
+    // and a run of forced failures still trips the breaker. `summaryFailed`
+    // is `undefined` on early-return paths (no eligible messages, disabled,
+    // etc.) — skip those so they don't silently reset the counter.
+    if (result.summaryFailed !== undefined) {
+      trackCompactionOutcome(this, result.summaryFailed, this.sendToClient);
+    }
     if (result.compacted) {
       this.messages = result.messages;
       this.contextCompactedMessageCount += result.compactedPersistedMessages;
@@ -1194,6 +1273,14 @@ export class Conversation {
 
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
+    this.secretPrompter.setChannelContext(
+      caps
+        ? {
+            channel: caps.channel,
+            supportsDynamicUi: caps.supportsDynamicUi,
+          }
+        : undefined,
+    );
   }
 
   setTrustContext(ctx: TrustContext | null): void {
@@ -1333,6 +1420,7 @@ export class Conversation {
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
+      callSite?: LLMCallSite;
     },
   ): Promise<void> {
     return runAgentLoopImpl(this, content, userMessageId, onEvent, options);
@@ -1349,7 +1437,7 @@ export class Conversation {
     requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
-    options?: { isInteractive?: boolean },
+    options?: { isInteractive?: boolean; callSite?: LLMCallSite },
     displayContent?: string,
   ): Promise<string> {
     return processMessageImpl(

package/src/daemon/external-skills-bootstrap.ts

@@ -0,0 +1,41 @@
+/**
+ * External skill bootstrap.
+ *
+ * Loads first-party skills that expose **in-process tools** to the daemon.
+ * Importing this module triggers each skill's `register.ts` to run, which
+ * in turn calls `registerExternalTools()` on the assistant-side tool
+ * registry. The daemon's `initializeTools()` then picks the registered
+ * tools up and makes them available to the LLM.
+ *
+ * ## Why the cross-directory import exists
+ *
+ * `CLAUDE.md` and `skills/meet-join/AGENTS.md` establish a general rule
+ * that `assistant/` must not import from `skills/` via relative paths so
+ * that skills stay portable and extractable. For in-process tools this
+ * creates a chicken-and-egg problem: skills need their `register.ts` to
+ * execute before `initializeTools()` runs, but in a `bun --compile`
+ * binary only statically analyzed imports end up in the bundle, and
+ * dynamic imports with variable paths fail inside `/$bunfs/`.
+ *
+ * We resolve the tension by:
+ *
+ *   1. Keeping this file as the **one** place in `assistant/` that
+ *      reaches into `skills/`. Every other import direction (skill ->
+ *      assistant) remains legal and intentional.
+ *   2. Limiting entries to **first-party bundled skills** whose source
+ *      is shipped in the Docker build context and statically compiled
+ *      into the Bun binary. The repo-root `.dockerignore` is the
+ *      allowlist that determines which skill files enter the build
+ *      context; the assistant `Dockerfile` copies `skills/` generically.
+ *   3. Keeping the imports as **side-effect only** so the skill owns
+ *      both the tool list and the feature-flag semantics — this file
+ *      just wires module evaluation into the startup path.
+ *
+ * When a new bundled first-party skill wants to expose in-process tools
+ * to the LLM, add another side-effect import here and extend the
+ * repo-root `.dockerignore` allowlist with the skill's runtime files.
+ * Non-bundled skills (workspace-installed, third-party) never belong in
+ * this file.
+ */
+
+import "../../../skills/meet-join/register.js";

package/src/daemon/guardian-action-generators.ts

@@ -1,5 +1,7 @@
-import { loadConfig } from "../config/loader.js";
+import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { getProvider } from "../providers/registry.js";
+import type { Provider } from "../providers/types.js";
 import {
   buildGuardianActionGenerationPrompt,
   getGuardianActionFallbackMessage,
@@ -18,21 +20,20 @@ import type {
 /**
  * Create the daemon-owned guardian action copy generator that resolves
  * providers and calls `provider.sendMessage` to generate guardian action
- * copy text. Uses `latency-optimized` model intent since these are
- * time-sensitive voice responses.
+ * copy text. Uses the `guardianQuestionCopy` call site so model selection
+ * tracks the unified `llm.callSites` configuration.
  *
  * This keeps all provider awareness in the daemon lifecycle, away from
  * the runtime composer.
  */
 export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator {
   return async (context, options = {}) => {
-    const config = loadConfig();
-    let provider;
-    try {
-      provider = getProvider(config.services.inference.provider);
-    } catch {
-      return null;
-    }
+    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
+    if (!baseProvider) return null;
+    // Wrap so the per-call `callSite` can route to a different provider
+    // transport when `llm.callSites.guardianQuestionCopy.provider` overrides
+    // the default. Without this, callSite only affects request metadata.
+    const provider = wrapWithCallSiteRouting(baseProvider);
 
     const fallbackText =
       options.fallbackText?.trim() || getGuardianActionFallbackMessage(context);
@@ -52,7 +53,7 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
       {
         config: {
           max_tokens: options.maxTokens ?? GUARDIAN_ACTION_COPY_MAX_TOKENS,
-          modelIntent: "latency-optimized",
+          callSite: "guardianQuestionCopy",
         },
         signal: AbortSignal.timeout(
           options.timeoutMs ?? GUARDIAN_ACTION_COPY_TIMEOUT_MS,
@@ -130,8 +131,11 @@ const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
  */
 export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpConversationGenerator {
   return async (context) => {
-    const config = loadConfig();
-    const provider = getProvider(config.services.inference.provider);
+    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
+    if (!baseProvider) {
+      throw new Error("No configured provider available for follow-up conversation");
+    }
+    const provider = wrapWithCallSiteRouting(baseProvider);
 
     const userPrompt = [
       `Original question from the voice call: "${context.questionText}"`,
@@ -146,7 +150,7 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
       {
         config: {
           max_tokens: FOLLOWUP_CONVERSATION_MAX_TOKENS,
-          modelIntent: "latency-optimized",
+          callSite: "guardianQuestionCopy",
         },
         signal: AbortSignal.timeout(FOLLOWUP_CONVERSATION_TIMEOUT_MS),
       },
@@ -188,3 +192,19 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
     return result;
   };
 }
+
+/**
+ * Wrap a base Provider so per-call `callSite` metadata can route the actual
+ * transport to a different provider when `llm.callSites.<id>.provider`
+ * differs from the default. Without this wrapper, only request metadata
+ * reflects the callSite — the HTTP transport stays bound to the default.
+ */
+function wrapWithCallSiteRouting(base: Provider): Provider {
+  return new CallSiteRoutingProvider(base, (name) => {
+    try {
+      return getProvider(name);
+    } catch {
+      return undefined;
+    }
+  });
+}

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

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+
+import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
+import { projectProviderForWire } from "./config-model.js";
+
+/**
+ * Regression guard for the wire contract declared in
+ * `daemon/message-types/conversations.ts#ModelInfo.allProviders`. The
+ * daemon's `PROVIDER_CATALOG` carries richer metadata (capability flags,
+ * pricing, subtitle, setupMode, setupHint, envVar, credentialsGuide), but
+ * clients source that metadata from the bundled `LLMProviderRegistry`
+ * JSON, so only the legacy fields belong on the wire. The Swift generated
+ * DTO declares the same legacy-only shape and silently discards any
+ * extras — this test keeps the daemon honest about what it sends.
+ */
+describe("projectProviderForWire", () => {
+  const LEGACY_WIRE_KEYS = new Set([
+    "id",
+    "displayName",
+    "models",
+    "defaultModel",
+    "apiKeyUrl",
+    "apiKeyPlaceholder",
+  ]);
+
+  test("drops rich catalog fields (subtitle, setupMode, envVar, credentialsGuide, setupHint)", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      const wire = projectProviderForWire(entry);
+      const keys = Object.keys(wire);
+      for (const key of keys) {
+        expect(LEGACY_WIRE_KEYS.has(key)).toBe(true);
+      }
+      expect(keys).not.toContain("subtitle");
+      expect(keys).not.toContain("setupMode");
+      expect(keys).not.toContain("setupHint");
+      expect(keys).not.toContain("envVar");
+      expect(keys).not.toContain("credentialsGuide");
+    }
+  });
+
+  test("drops rich CatalogModel fields (capability flags, pricing, context windows)", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      const wire = projectProviderForWire(entry);
+      for (const model of wire.models) {
+        expect(Object.keys(model).sort()).toEqual(["displayName", "id"]);
+      }
+    }
+  });
+
+  test("preserves legacy wire fields exactly", () => {
+    const anthropic = PROVIDER_CATALOG.find((p) => p.id === "anthropic");
+    expect(anthropic).toBeDefined();
+    const wire = projectProviderForWire(anthropic!);
+    expect(wire.id).toBe(anthropic!.id);
+    expect(wire.displayName).toBe(anthropic!.displayName);
+    expect(wire.defaultModel).toBe(anthropic!.defaultModel);
+    expect(wire.apiKeyUrl).toBe(anthropic!.apiKeyUrl);
+    expect(wire.apiKeyPlaceholder).toBe(anthropic!.apiKeyPlaceholder);
+    expect(wire.models.length).toBe(anthropic!.models.length);
+  });
+
+  test("omits apiKeyUrl/apiKeyPlaceholder when source entry has none (keyless providers)", () => {
+    const ollama = PROVIDER_CATALOG.find((p) => p.id === "ollama");
+    expect(ollama).toBeDefined();
+    // Sanity-check the fixture: ollama is the keyless provider.
+    expect(ollama!.apiKeyUrl).toBeUndefined();
+    expect(ollama!.apiKeyPlaceholder).toBeUndefined();
+
+    const wire = projectProviderForWire(ollama!);
+    expect("apiKeyUrl" in wire).toBe(false);
+    expect("apiKeyPlaceholder" in wire).toBe(false);
+  });
+
+  test("JSON round-trip exposes only the legacy wire keys", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      const wire = projectProviderForWire(entry);
+      const serialized = JSON.parse(JSON.stringify(wire)) as Record<
+        string,
+        unknown
+      >;
+      for (const key of Object.keys(serialized)) {
+        expect(LEGACY_WIRE_KEYS.has(key)).toBe(true);
+      }
+    }
+  });
+});

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

@@ -3,7 +3,10 @@ import {
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import { setServiceField } from "../../config/raw-config-utils.js";
+import {
+  setLlmDefaultField,
+  setServiceField,
+} from "../../config/raw-config-utils.js";
 import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
 import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
 import {
@@ -37,25 +40,64 @@ export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
 // Shared business logic (transport-agnostic)
 // ---------------------------------------------------------------------------
 
+/**
+ * Wire-contract shape for a provider entry in `ModelInfo.allProviders`.
+ * Mirrors the legacy fields declared in `message-types/conversations.ts` —
+ * rich provider metadata (capability flags, pricing, subtitle, setupMode,
+ * setupHint, envVar, credentialsGuide) is sourced by clients from the
+ * bundled `LLMProviderRegistry` JSON, so there is no reason to double-send
+ * it over the wire.
+ */
+export interface WireProviderEntry {
+  id: string;
+  displayName: string;
+  models: Array<{ id: string; displayName: string }>;
+  defaultModel: string;
+  apiKeyUrl?: string;
+  apiKeyPlaceholder?: string;
+}
+
 export interface ModelInfo {
   model: string;
   provider: string;
   configuredProviders?: string[];
   availableModels?: Array<{ id: string; displayName: string }>;
-  allProviders?: ProviderCatalogEntry[];
+  allProviders?: WireProviderEntry[];
+}
+
+/**
+ * Project a rich `ProviderCatalogEntry` to the legacy wire-contract fields.
+ * Keeping the wire payload honest avoids contract drift with
+ * `message-types/conversations.ts` and the generated Swift DTO.
+ */
+export function projectProviderForWire(
+  entry: ProviderCatalogEntry,
+): WireProviderEntry {
+  return {
+    id: entry.id,
+    displayName: entry.displayName,
+    models: entry.models.map((m) => ({ id: m.id, displayName: m.displayName })),
+    defaultModel: entry.defaultModel,
+    ...(entry.apiKeyUrl !== undefined && { apiKeyUrl: entry.apiKeyUrl }),
+    ...(entry.apiKeyPlaceholder !== undefined && {
+      apiKeyPlaceholder: entry.apiKeyPlaceholder,
+    }),
+  };
 }
 
 /** Return current model configuration. */
 export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
-  const provider = config.services.inference.provider;
+  const provider = config.llm.default.provider;
 
   return {
-    model: config.services.inference.model,
+    model: config.llm.default.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
-    availableModels: PROVIDER_CATALOG.find((p) => p.id === provider)?.models,
-    allProviders: PROVIDER_CATALOG,
+    availableModels: PROVIDER_CATALOG.find(
+      (p) => p.id === provider,
+    )?.models?.map((m) => ({ id: m.id, displayName: m.displayName })),
+    allProviders: PROVIDER_CATALOG.map(projectProviderForWire),
   };
 }
 
@@ -102,12 +144,12 @@ export async function setModel(
   const resolvedProvider =
     explicitProvider ??
     MODEL_TO_PROVIDER[modelId] ??
-    current.services.inference.provider;
+    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.services.inference.provider &&
+    resolvedProvider !== current.llm.default.provider &&
     !isModelInCatalog(resolvedProvider, modelId)
   ) {
     modelId = getProviderDefaultModel(resolvedProvider);
@@ -115,8 +157,8 @@ export async function setModel(
 
   // No-op guard: skip expensive reinitialization when nothing changed
   if (
-    modelId === current.services.inference.model &&
-    resolvedProvider === current.services.inference.provider
+    modelId === current.llm.default.model &&
+    resolvedProvider === current.llm.default.provider
   ) {
     return await getModelInfo();
   }
@@ -129,8 +171,8 @@ export async function setModel(
 
   // Use raw config to avoid persisting env-var API keys to disk
   const raw = loadRawConfig();
-  setServiceField(raw, "inference", "model", modelId);
-  setServiceField(raw, "inference", "provider", resolvedProvider);
+  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

package/src/daemon/handlers/conversations.ts

@@ -148,12 +148,19 @@ export function handleConfirmationResponse(
   // Route by requestId to the conversation that originated the prompt, not by
   // the current conversation binding which may have changed since the
   // request was issued (e.g. after a conversation switch).
+  // Normalize legacy decision: older clients may still send
+  // "always_allow_high_risk" via WebSocket for high-risk prompts.
+  const decision =
+    msg.decision === ("always_allow_high_risk" as typeof msg.decision)
+      ? "always_allow"
+      : msg.decision;
+
   for (const [conversationId, conversation] of ctx.conversations) {
     if (conversation.hasPendingConfirmation(msg.requestId)) {
       ctx.touchConversation(conversationId);
       conversation.handleConfirmationResponse(
         msg.requestId,
-        msg.decision,
+        decision,
         msg.selectedPattern,
         msg.selectedScope,
         undefined,
@@ -435,7 +442,7 @@ export function handleUsageRequest(
     totalInputTokens: conversation.totalInputTokens,
     totalOutputTokens: conversation.totalOutputTokens,
     estimatedCost: conversation.totalEstimatedCost,
-    model: config.services.inference.model,
+    model: config.llm.default.model,
   });
 }