@vellumai/assistant 0.8.2 → 0.8.3

package/src/providers/registry.ts

@@ -1,4 +1,6 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import type { AssistantConfig } from "../config/schema.js";
 import { type LLMConfig } from "../config/schemas/llm.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { ProviderNotConfiguredError } from "../util/errors.js";
@@ -26,6 +28,7 @@ const log = getLogger("provider-registry");
 
 const providers = new Map<string, Provider>();
 const routingSources = new Map<string, "user-key" | "managed-proxy">();
+const OPENAI_COMPATIBLE_ENDPOINTS_FLAG = "openai-compatible-endpoints";
 
 /** Per-connection provider cache, keyed by connection name. */
 const connectionProviders = new Map<string, Provider>();
@@ -69,6 +72,16 @@ export interface ProvidersConfig {
   timeouts?: { providerStreamTimeoutSec?: number };
 }
 
+function isProviderFeatureFlagEnabled(
+  key: string,
+  config: ProvidersConfig,
+): boolean {
+  return isAssistantFeatureFlagEnabled(
+    key,
+    config as unknown as AssistantConfig,
+  );
+}
+
 function resolveModel(config: ProvidersConfig, providerName: string): string {
   const resolved = resolveCallSiteConfig("mainAgent", config.llm);
   const inferenceProvider = resolved.provider;
@@ -130,6 +143,13 @@ export async function initializeProviders(
   ).provider;
 
   for (const entry of PROVIDER_CATALOG) {
+    if (
+      entry.featureFlag &&
+      !isProviderFeatureFlagEnabled(entry.featureFlag, config)
+    ) {
+      continue;
+    }
+
     const isKeyless = entry.setupMode === "keyless";
 
     // Credential resolution: user key first, managed proxy second. Keyless
@@ -202,10 +222,19 @@ export async function resolveProviderFromConnection(
   connection: ProviderConnection,
   config: ProvidersConfig,
 ): Promise<Provider | null> {
+  if (
+    connection.provider === "openai-compatible" &&
+    !isProviderFeatureFlagEnabled(OPENAI_COMPATIBLE_ENDPOINTS_FLAG, config)
+  ) {
+    return null;
+  }
+
   const cached = connectionProviders.get(connection.name);
   if (cached) return cached;
 
-  const authResult = await resolveAuth(connection.auth, connection.provider);
+  const authResult = await resolveAuth(connection.auth, connection.provider, {
+    baseUrl: connection.baseUrl,
+  });
   if (!authResult.ok) {
     const err = authResult.error;
     if (err.code === "not_implemented") {

package/src/runtime/agent-wake.ts

@@ -57,7 +57,11 @@ import {
 } from "../daemon/disk-pressure-policy.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
-import { recordRequestLog } from "../memory/llm-request-log-store.js";
+import {
+  buildProviderErrorResponsePayload,
+  recordRequestLog,
+  setAgentLoopExitReasonOnLatestLog,
+} from "../memory/llm-request-log-store.js";
 import type { TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
@@ -548,6 +552,12 @@ export async function wakeAgentForOpportunity(
       provider?: string;
     };
     const pendingLogs: PendingLog[] = [];
+    // Exit reason deferred alongside pendingLogs. Same drop-on-silent-
+    // wake guarantee: if the wake never goes live, this stays null and
+    // no DB row is touched. Applied after pendingLogs flush in goLive
+    // so the latest-row lookup in `setAgentLoopExitReasonOnLatestLog`
+    // can see the freshly-persisted final usage row.
+    let pendingExitReason: string | null = null;
     const persistLog = (record: PendingLog): void => {
       try {
         recordRequestLog(
@@ -564,6 +574,16 @@ export async function wakeAgentForOpportunity(
         );
       }
     };
+    const persistExitReason = (reason: string): void => {
+      try {
+        setAgentLoopExitReasonOnLatestLog(conversationId, reason);
+      } catch (err) {
+        log.warn(
+          { err, conversationId, source, reason },
+          "agent-wake: failed to persist agent_loop_exit_reason (non-fatal)",
+        );
+      }
+    };
     const safeEmit = (event: AgentEvent): void => {
       try {
         target.emitAgentEvent(event);
@@ -590,6 +610,38 @@ export async function wakeAgentForOpportunity(
           persistLog(record);
         }
       }
+      // Mirror the same recording side-effect for provider-rejected calls.
+      // `handleProviderError` in the daemon dispatcher persists these on the
+      // normal turn path; the wake path owns its own onEvent and bypasses
+      // that dispatcher entirely, so we replicate here. Buffering rules
+      // match the success path: if the wake never goes live (silent no-op),
+      // the rows are dropped so a stale `messageId IS NULL` row doesn't get
+      // mis-backfilled onto an unrelated future assistant message.
+      if (event.type === "provider_error") {
+        const record: PendingLog = {
+          rawRequest: event.rawRequest,
+          rawResponse: buildProviderErrorResponsePayload(event.error),
+          provider: event.actualProvider,
+        };
+        if (mode === "buffering") {
+          pendingLogs.push(record);
+        } else {
+          persistLog(record);
+        }
+      }
+      // Replicates the setAgentLoopExitReasonOnLatestLog side-effect that
+      // `dispatchAgentEvent` does for the normal path. In live mode the
+      // final usage event of the run has already landed its row, so the
+      // latest-row lookup hits the right target. In buffering mode the
+      // reason is stashed and applied in `goLive` after pendingLogs are
+      // persisted, preserving the same ordering guarantee.
+      if (event.type === "agent_loop_exit") {
+        if (mode === "buffering") {
+          pendingExitReason = event.reason;
+        } else {
+          persistExitReason(event.reason);
+        }
+      }
       if (mode === "buffering") {
         buffered.push(event);
         return;
@@ -648,6 +700,14 @@ export async function wakeAgentForOpportunity(
         persistLog(record);
       }
       pendingLogs.length = 0;
+      // Apply the deferred exit reason after pendingLogs are persisted —
+      // the latest-row lookup in `setAgentLoopExitReasonOnLatestLog`
+      // needs the final usage row to already exist. Cleared after use so
+      // an extremely unlikely double-goLive can't double-stamp.
+      if (pendingExitReason !== null) {
+        persistExitReason(pendingExitReason);
+        pendingExitReason = null;
+      }
       mode = "live";
     };
 

package/src/runtime/auth/route-policy.ts

@@ -243,6 +243,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
     endpoint: "integrations/slack/channel/config:DELETE",
     scopes: ["settings.write"],
   },
+  { endpoint: "integrations/a2a/invite", scopes: ["settings.write"] },
   { endpoint: "channel-verification-sessions", scopes: ["settings.write"] },
   {
     endpoint: "channel-verification-sessions:DELETE",
@@ -686,6 +687,18 @@ for (const endpoint of INTERNAL_ENDPOINTS) {
   });
 }
 
+// A2A invite completion: gateway-only (platform-orchestrated)
+registerPolicy("integrations/a2a/invite/complete", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
+// A2A invite redemption: gateway-only (platform-orchestrated)
+registerPolicy("integrations/a2a/invite/redeem", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
 // Admin control-plane endpoints: gateway-only
 registerPolicy("admin/upgrade-broadcast", {
   requiredScopes: ["internal.write"],

package/src/runtime/http-server.ts

@@ -28,6 +28,8 @@ import {
 import { isHttpAuthDisabled } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
+import { createApprovalCopyGenerator } from "../daemon/approval-generators.js";
+import { createGuardianActionCopyGenerator } from "../daemon/guardian-action-generators.js";
 import { processMessage } from "../daemon/process-message.js";
 import { createLiveVoiceSession } from "../live-voice/live-voice-session.js";
 import { LiveVoiceSessionManager } from "../live-voice/live-voice-session-manager.js";
@@ -96,10 +98,8 @@ import { matchSkillRoute } from "./skill-route-registry.js";
 export { isPrivateAddress } from "./middleware/auth.js";
 
 import type {
-  ApprovalConversationGenerator,
   ApprovalCopyGenerator,
   GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
   RuntimeHttpServerOptions,
 } from "./http-types.js";
 
@@ -161,10 +161,8 @@ export class RuntimeHttpServer {
   private port: number;
   private hostname: string;
 
-  private approvalCopyGenerator?: ApprovalCopyGenerator;
-  private approvalConversationGenerator?: ApprovalConversationGenerator;
-  private guardianActionCopyGenerator?: GuardianActionCopyGenerator;
-  private guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator;
+  private readonly approvalCopyGenerator: ApprovalCopyGenerator;
+  private readonly guardianActionCopyGenerator: GuardianActionCopyGenerator;
   private retrySweepTimer: ReturnType<typeof setInterval> | null = null;
   private sweepInProgress = false;
 
@@ -175,11 +173,8 @@ export class RuntimeHttpServer {
     this.port = options.port ?? DEFAULT_PORT;
     this.hostname = options.hostname ?? DEFAULT_HOSTNAME;
 
-    this.approvalCopyGenerator = options.approvalCopyGenerator;
-    this.approvalConversationGenerator = options.approvalConversationGenerator;
-    this.guardianActionCopyGenerator = options.guardianActionCopyGenerator;
-    this.guardianFollowUpConversationGenerator =
-      options.guardianFollowUpConversationGenerator;
+    this.approvalCopyGenerator = createApprovalCopyGenerator();
+    this.guardianActionCopyGenerator = createGuardianActionCopyGenerator();
     this.liveVoiceSessionManager = new LiveVoiceSessionManager({
       createSession: (context) => createLiveVoiceSession(context),
     });
@@ -560,11 +555,7 @@ export class RuntimeHttpServer {
       const endpoint = url.pathname.slice("/v1/".length).replace(/\/$/, "");
       meta = this.router.findLoggingMetadata(req.method, endpoint) ?? undefined;
     }
-    return withRequestLogging(
-      req,
-      () => this.routeRequest(req, server),
-      meta,
-    );
+    return withRequestLogging(req, () => this.routeRequest(req, server), meta);
   }
 
   private async routeRequest(

package/src/runtime/http-types.ts

@@ -14,10 +14,6 @@ import type {
 export type { SlackInboundMessageMetadata };
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { AssistantEventHub } from "./assistant-event-hub.js";
-import type {
-  ApprovalCopyGenerator,
-  GuardianActionCopyGenerator,
-} from "./message-composer-types.js";
 
 export type {
   ApprovalCopyGenerator,
@@ -61,41 +57,6 @@ export type ApprovalConversationGenerator = (
   context: ApprovalConversationContext,
 ) => Promise<ApprovalConversationResult>;
 
-// ---------------------------------------------------------------------------
-// Guardian follow-up conversation flow types
-// ---------------------------------------------------------------------------
-
-/** The disposition returned by the guardian follow-up conversation engine. */
-export type GuardianFollowUpDisposition =
-  | "call_back"
-  | "decline"
-  | "keep_pending";
-
-/** Structured result from a single turn of the guardian follow-up conversation. */
-export interface GuardianFollowUpTurnResult {
-  disposition: GuardianFollowUpDisposition;
-  replyText: string;
-}
-
-/** Input context for the guardian follow-up conversation engine. */
-export interface GuardianFollowUpConversationContext {
-  /** The original question that was asked during the voice call. */
-  questionText: string;
-  /** The guardian's late answer text that initiated the follow-up. */
-  lateAnswerText: string;
-  /** The guardian's latest reply in the follow-up conversation. */
-  guardianReply: string;
-}
-
-/**
- * Daemon-injected function that processes one turn of a guardian follow-up
- * conversation. Classifies the guardian's intent into a structured disposition
- * and produces a natural reply.
- */
-export type GuardianFollowUpConversationGenerator = (
-  context: GuardianFollowUpConversationContext,
-) => Promise<GuardianFollowUpTurnResult>;
-
 export interface RuntimeMessageConversationOptions {
   transport?: {
     channelId: ChannelId;
@@ -173,14 +134,6 @@ export interface RuntimeHttpServerOptions {
   port?: number;
   /** Hostname / IP to bind to. Defaults to '127.0.0.1' (loopback-only). */
   hostname?: string;
-  /** Daemon-injected generator for approval copy (provider-backed). */
-  approvalCopyGenerator?: ApprovalCopyGenerator;
-  /** Daemon-injected generator for conversational approval flow (provider-backed). */
-  approvalConversationGenerator?: ApprovalConversationGenerator;
-  /** Daemon-injected generator for guardian action copy (provider-backed). */
-  guardianActionCopyGenerator?: GuardianActionCopyGenerator;
-  /** Daemon-injected generator for guardian follow-up conversation (provider-backed). */
-  guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator;
 }
 
 export interface RuntimeAttachmentMetadata {

package/src/runtime/routes/__tests__/consolidation-routes.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Asserts `listConsolidationRuns` maps background-conversation rows tagged
+ * with `source = MEMORY_V2_CONSOLIDATION_SOURCE` into the heartbeat-runs
+ * response shape, derives `status` / `finishedAt` / `durationMs` from
+ * **assistant-message presence** (not `lastMessageAt`), and clamps the
+ * `limit` query param.
+ *
+ * Synthetic-field semantics covered here:
+ *   - `id` and `conversationId` both equal the conversation row's id.
+ *   - `scheduledFor` and `startedAt` both equal `conversation.createdAt`
+ *     (no separate schedule timestamp on the row).
+ *   - `finishedAt` is the `createdAt` of the LATEST assistant message,
+ *     NOT `conversation.lastMessageAt` — the kickoff user prompt bumps
+ *     `lastMessageAt` before the agent runs, so it cannot be used as a
+ *     completion signal.
+ *   - `durationMs` is `finishedAt − startedAt` when both are present, else
+ *     null.
+ *   - `status` is `"ok"` when the conversation has at least one assistant
+ *     message (positive evidence the agent emitted output) and `"running"`
+ *     otherwise — including the case where only the kickoff user prompt
+ *     has been persisted.
+ *   - `skipReason` and `error` are always null — the conversation row
+ *     alone cannot distinguish a clean run from a mid-flight crash even
+ *     once assistant output exists.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { createConversation } from "../../../memory/conversation-crud.js";
+import { getDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { rawRun } from "../../../memory/raw-query.js";
+import { ROUTES } from "../consolidation-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+}
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+function insertMessage(
+  conversationId: string,
+  role: string,
+  createdAt: number,
+): void {
+  rawRun(
+    "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+    `msg-${conversationId}-${role}-${createdAt}`,
+    conversationId,
+    role,
+    "x",
+    createdAt,
+  );
+}
+
+interface RunRecord {
+  id: string;
+  scheduledFor: number;
+  startedAt: number | null;
+  finishedAt: number | null;
+  durationMs: number | null;
+  status: "ok" | "running";
+  skipReason: string | null;
+  error: string | null;
+  conversationId: string | null;
+  createdAt: number;
+}
+
+interface ListRunsResponse {
+  runs: RunRecord[];
+}
+
+describe("listConsolidationRuns handler", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only conversations sourced from memory_v2_consolidation", async () => {
+    createConversation({ title: "c1", source: "memory_v2_consolidation" });
+    createConversation({ title: "h1", source: "heartbeat" });
+    createConversation({ title: "u1", source: "user" });
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+  });
+
+  test("synthesizes status='ok' with finishedAt from latest assistant message", async () => {
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET created_at = ? WHERE id = ?",
+      1000,
+      conv.id,
+    );
+    // Kickoff user prompt at t=1100 (bumps lastMessageAt — must NOT be
+    // mistaken for completion).
+    insertMessage(conv.id, "user", 1100);
+    // Agent's first assistant turn at t=2000.
+    insertMessage(conv.id, "assistant", 2000);
+    // Agent's final assistant turn at t=2500.
+    insertMessage(conv.id, "assistant", 2500);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+    const run = result.runs[0]!;
+    expect(run.id).toBe(conv.id);
+    expect(run.conversationId).toBe(conv.id);
+    expect(run.status).toBe("ok");
+    expect(run.scheduledFor).toBe(1000);
+    expect(run.startedAt).toBe(1000);
+    // finishedAt = createdAt of LATEST assistant message (2500), NOT
+    // the conversation's lastMessageAt (which sqlite triggers may or may
+    // not have updated here — irrelevant to this endpoint).
+    expect(run.finishedAt).toBe(2500);
+    expect(run.durationMs).toBe(1500);
+    expect(run.createdAt).toBe(1000);
+  });
+
+  test("synthesizes status='running' when conversation has no assistant message", async () => {
+    createConversation({ title: "c1", source: "memory_v2_consolidation" });
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+    const run = result.runs[0]!;
+    expect(run.status).toBe("running");
+    expect(run.finishedAt).toBeNull();
+    expect(run.durationMs).toBeNull();
+  });
+
+  test("status stays 'running' when only the kickoff user prompt exists (Codex bug regression guard)", async () => {
+    // Regression guard for the original `status from lastMessageAt`
+    // heuristic. `processMessage` persists the background kickoff prompt as
+    // a user message BEFORE the agent runs, which bumps
+    // `conversation.lastMessageAt`. A run that timed out / threw before
+    // emitting any assistant turn must still report status='running' (or
+    // an explicit failure status once one exists) — never 'ok'.
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET created_at = ?, last_message_at = ? WHERE id = ?",
+      1000,
+      1100,
+      conv.id,
+    );
+    insertMessage(conv.id, "user", 1100);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+    const run = result.runs[0]!;
+    expect(run.status).toBe("running");
+    expect(run.finishedAt).toBeNull();
+    expect(run.durationMs).toBeNull();
+  });
+
+  test("skipReason and error are always null (not derivable from conversation row)", async () => {
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    insertMessage(conv.id, "assistant", 2000);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs[0]!.skipReason).toBeNull();
+    expect(result.runs[0]!.error).toBeNull();
+  });
+
+  test("orders runs by createdAt descending", async () => {
+    const a = createConversation({
+      title: "a",
+      source: "memory_v2_consolidation",
+    });
+    const b = createConversation({
+      title: "b",
+      source: "memory_v2_consolidation",
+    });
+    const c = createConversation({
+      title: "c",
+      source: "memory_v2_consolidation",
+    });
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 1000, a.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 3000, b.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 2000, c.id);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs.map((r) => r.id)).toEqual([b.id, c.id, a.id]);
+  });
+
+  test("limit defaults to 20, clamps to [1, 100], and falls back on non-numeric input", async () => {
+    for (let i = 0; i < 5; i++) {
+      createConversation({
+        title: `c${i}`,
+        source: "memory_v2_consolidation",
+      });
+    }
+
+    const handler = findHandler("listConsolidationRuns");
+
+    // Default — all 5 returned (under the 20 default).
+    const def = (await handler({})) as ListRunsResponse;
+    expect(def.runs).toHaveLength(5);
+
+    // Explicit limit honored.
+    const lim2 = (await handler({
+      queryParams: { limit: "2" },
+    })) as ListRunsResponse;
+    expect(lim2.runs).toHaveLength(2);
+
+    // Negative clamps to 1.
+    const neg = (await handler({
+      queryParams: { limit: "-5" },
+    })) as ListRunsResponse;
+    expect(neg.runs).toHaveLength(1);
+
+    // Zero clamps to 1.
+    const zero = (await handler({
+      queryParams: { limit: "0" },
+    })) as ListRunsResponse;
+    expect(zero.runs).toHaveLength(1);
+
+    // Non-numeric falls back to the default (20 → all 5 here).
+    const bad = (await handler({
+      queryParams: { limit: "garbage" },
+    })) as ListRunsResponse;
+    expect(bad.runs).toHaveLength(5);
+  });
+});

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

@@ -71,6 +71,10 @@ import {
   memoryV2ActivationLogs,
   messages,
 } from "../../../memory/schema.js";
+import {
+  createConnection,
+  getConnection,
+} from "../../../providers/inference/connections.js";
 import { ROUTES } from "../conversation-query-routes.js";
 
 // Local subset: this test only exercises a single concept row.
@@ -427,7 +431,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(savedProfile.provider_connection).toBe("personal-openai");
   });
 
-  test("clears provider_connection when omitted from body (UI-owned key)", async () => {
+  test("auto-derives provider_connection when omitted from body (Any active)", async () => {
     // Seed an existing binding so the test starts from a non-empty state.
     (
       rawConfigFixture.llm as {
@@ -441,8 +445,37 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
         provider: "openai",
         model: "gpt-5.5",
         // provider_connection deliberately omitted — the UI cleared the
-        // picker back to "Any active" and the route must wipe the saved
-        // binding, not silently round-trip it.
+        // picker back to "Any active". The route auto-derives an active
+        // connection for the provider to prevent stale inheritance during
+        // config deep-merge.
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    // The canonical "openai-managed" connection exists in the test DB;
+    // the route auto-derives it when the UI omits provider_connection.
+    expect(savedProfile.provider_connection).toBe("openai-managed");
+  });
+
+  test("auto-derives provider_connection for BYOK provider (Any active)", async () => {
+    // Seed a fireworks connection in the DB.
+    createConnection(getDb(), {
+      name: "fireworks",
+      provider: "fireworks",
+      auth: { type: "api_key", credential: "fireworks:api_key" },
+    });
+
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "fireworks",
+        model: "accounts/fireworks/models/llama-v3p1-8b-instruct",
       },
     });
 
@@ -453,7 +486,36 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       }
     ).profiles.custom;
 
-    expect(savedProfile.provider_connection).toBeUndefined();
+    expect(savedProfile.provider).toBe("fireworks");
+    expect(savedProfile.provider_connection).toBe("fireworks");
+  });
+
+  test("auto-creates provider_connection when no connection exists for provider", async () => {
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "openrouter",
+        model: "anthropic/claude-sonnet-4-6",
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider).toBe("openrouter");
+    expect(savedProfile.provider_connection).toBe("openrouter-personal");
+
+    const conn = getConnection(getDb(), "openrouter-personal");
+    expect(conn).not.toBeNull();
+    expect(conn!.provider).toBe("openrouter");
+    expect(conn!.auth).toEqual({
+      type: "api_key",
+      credential: "credential/openrouter/api_key",
+    });
   });
 
   describe("managed profile guard", () => {