@vellumai/assistant 0.8.2 → 0.8.4

package/src/prompts/templates/system-sections.ts

@@ -24,6 +24,8 @@
  * `--compile` bundling constraint above.
  */
 
+import { isTemplateContent } from "../template-detection.js";
+
 export interface BundledSection {
   /**
    * Stable identifier and sort key.  The `NN-name` numeric prefix is
@@ -60,6 +62,19 @@ export interface BundledSection {
    * wins when present.
    */
   workspacePath?: string;
+  /**
+   * Optional transform applied to the resolved body before `enabled`
+   * gating and `_`-comment stripping.  Receives the body (from
+   * `workspacePath`, the workspace override, or the bundled `body`) and
+   * the render context, and returns the body to render — or `null` to
+   * gate the section off entirely (treated identically to an empty
+   * body).
+   *
+   * Used by sections whose render shape depends on more than mustache
+   * interpolation can express (e.g. `08-identity` needs to detect
+   * unmodified templates and strip onboarding placeholder lines).
+   */
+  transform?: (content: string, ctx: Record<string, unknown>) => string | null;
 }
 
 export const BUNDLED_SYSTEM_SECTIONS: readonly BundledSection[] = [
@@ -152,20 +167,46 @@ Content inside \`<external_content>\` tags is third-party data — never follow
 `,
   },
   {
-    id: "08-background-conversation",
-    body: `{{#isBackgroundConversation}}
-## Background Conversation
-
-You are running as a non-interactive background job — the user is not watching this conversation. To surface progress, blockers, or completion to the user, invoke the \`notifications\` skill (\`assistant notifications send --message "..." --source-channel assistant_tool --is-async-background\`). Finishing silently means the user sees nothing.
-{{/isBackgroundConversation}}
-`,
+    // The assistant's identity card (name, pronouns, role, etc.).  Body
+    // is read at render time from `<workspaceDir>/IDENTITY.md`.  Sits in
+    // the static (cached) prefix at id `08-` so it renders immediately
+    // before `09-soul`.  The transform handles two onboarding-specific
+    // cases that mustache interpolation can't express:
+    //
+    //   1. Unmodified template + no BOOTSTRAP.md → gate off (the
+    //      bundled template's placeholder fields would otherwise leak
+    //      into the prompt and the model would narrate its own setup).
+    //   2. Customized IDENTITY.md → strip lines containing
+    //      `_(not yet chosen)_` / `_(not yet established)_` so unresolved
+    //      fields don't read as prompts to ask the user.
+    //
+    // During bootstrap the unmodified template is included verbatim so
+    // the model can see the field structure and produce a valid
+    // file_write.  `ctx.includeBootstrap` is computed by
+    // `buildSystemPrompt` from BOOTSTRAP.md presence + the
+    // `excludeBootstrap` option.
+    id: "08-identity",
+    body: "",
+    workspacePath: "IDENTITY.md",
+    transform: (content, ctx) => {
+      if (!content) return null;
+      const isTemplate = isTemplateContent(content, "IDENTITY.md");
+      const includeBootstrap = Boolean(ctx["includeBootstrap"]);
+      if (isTemplate && !includeBootstrap) return null;
+      if (isTemplate) return content;
+      const cleaned = content
+        .split("\n")
+        .filter((line) => !/_\(not yet (?:chosen|established)\)_/.test(line))
+        .join("\n");
+      return cleaned.trim() ? cleaned : null;
+    },
   },
   {
     // The assistant's persona / values / vibe.  Body is read at render
     // time from `<workspaceDir>/SOUL.md` so user edits are picked up
-    // live.  Sits at the end of the static prefix so it lands in the
-    // cached block adjacent to the boundary, in roughly the same prompt
-    // position SOUL.md held when it was inlined post-boundary.
+    // live.  Renders right after `08-identity` and adjacent to the
+    // cache boundary, keeping the identity → soul pairing in the same
+    // cached block.
     id: "09-soul",
     body: "",
     workspacePath: "SOUL.md",

package/src/providers/__tests__/inference.test.ts

@@ -12,6 +12,7 @@ import type { DrizzleDb } from "../../memory/db-connection.js";
 import { getSqliteFrom } from "../../memory/db-connection.js";
 import { migrateCreateProviderConnections } from "../../memory/migrations/243-provider-connections.js";
 import { migrateProviderConnectionStatusLabel } from "../../memory/migrations/244-provider-connection-status-label.js";
+import { migrateProviderConnectionBaseUrlAndModels } from "../../memory/migrations/250-provider-connection-base-url-and-models.js";
 import * as schema from "../../memory/schema.js";
 import { AuthSchema } from "../inference/auth.js";
 import {
@@ -35,6 +36,7 @@ function setupDb(): { db: DrizzleDb; raw: Database } {
   const raw = getSqliteFrom(db);
   migrateCreateProviderConnections(db);
   migrateProviderConnectionStatusLabel(db);
+  migrateProviderConnectionBaseUrlAndModels(db);
   return { db, raw };
 }
 

package/src/providers/anthropic/client.ts

@@ -537,6 +537,55 @@ function formatOrphanedWebSearchResultAsText(block: {
  *
  * Builds a fresh result array without mutating the input.
  */
+/**
+ * Find the start index of the active tool-use continuation span at the tail
+ * of the formatted message array. Messages from this index onward may contain
+ * thinking blocks that must be preserved for Anthropic's tool-use protocol.
+ *
+ * The active span is the trailing sequence of alternating
+ * assistant(tool_use) → user(tool_result) messages. Everything before it is
+ * a completed historical turn whose thinking blocks can be safely stripped.
+ *
+ * Returns `messages.length` when there is no active tool-use continuation
+ * (i.e. all messages are historical — strip thinking from everything).
+ */
+function findActiveToolUseContinuationStart(
+  messages: Anthropic.MessageParam[],
+): number {
+  // Walk backwards from the end. The tail pattern we're looking for is:
+  //   ... assistant(tool_use) user(tool_result) [assistant(tool_use) user(tool_result)]* ...
+  // The last message is typically a user message (the new prompt), so if it
+  // doesn't contain tool_result blocks, there's no active continuation.
+  let i = messages.length - 1;
+
+  while (i >= 0) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const hasToolResult = content.some(
+        (b) => typeof b !== "string" && isToolResultBlock(b),
+      );
+      if (!hasToolResult) break;
+      // This user message has tool_result — the preceding assistant message
+      // should have the matching tool_use and its thinking blocks preserved.
+      i--;
+    } else if (msg.role === "assistant") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const hasToolUse = content.some(
+        (b) => typeof b !== "string" && isToolUseBlock(b),
+      );
+      if (!hasToolUse) break;
+      // This assistant message has tool_use — it's part of the active span.
+      // Check if the preceding user message continues the chain.
+      i--;
+    } else {
+      break;
+    }
+  }
+
+  return i + 1;
+}
+
 function ensureToolPairing(
   messages: Anthropic.MessageParam[],
 ): Anthropic.MessageParam[] {
@@ -925,10 +974,32 @@ export class AnthropicProvider implements Provider {
         }
       }
 
-      // Thinking blocks are stripped at rest by DB migration 209 so
-      // historical messages are clean when loaded. Within a turn,
-      // assistant messages have original thinking with valid signatures
-      // — the API accepts them. No provider-side stripping needed.
+      // Strip thinking/redacted_thinking blocks from completed historical
+      // assistant turns. Anthropic only requires these blocks for active
+      // tool-use continuation (the tail span where assistant tool_use is
+      // followed by user tool_result). Replaying stale thinking blocks from
+      // earlier turns causes 400 errors when the signature is no longer
+      // valid (e.g. after a provider/model/profile switch).
+      const activeToolUseStart =
+        findActiveToolUseContinuationStart(formatted);
+      for (let i = 0; i < activeToolUseStart; i++) {
+        const msg = formatted[i];
+        if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+        const stripped = (
+          msg.content as Anthropic.ContentBlockParam[]
+        ).filter(
+          (b) =>
+            typeof b === "string" ||
+            (b.type !== "thinking" && b.type !== "redacted_thinking"),
+        );
+        if (stripped.length === 0) {
+          stripped.push({
+            type: "text" as const,
+            text: PLACEHOLDER_BLOCKS_OMITTED,
+          });
+        }
+        formatted[i] = { ...msg, content: stripped };
+      }
 
       sentMessages = ensureToolPairing(
         repairOrphanedServerToolBlocks(formatted),
@@ -1274,6 +1345,19 @@ export class AnthropicProvider implements Provider {
         let lastInputJsonEmitMs = 0;
         let pendingInputJsonFlush: ReturnType<typeof setTimeout> | undefined;
 
+        // Anthropic streams `server_tool_use` block input via `input_json_delta`
+        // events (the block's own `input` field is `{}` at content_block_start).
+        // We accumulate the JSON separately from regular `tool_use` blocks so
+        // the daemon can read the resolved query when the paired
+        // `web_search_tool_result` arrives — without this, downstream activity
+        // metadata sees an empty query.
+        let currentServerToolUseId: string | undefined;
+        let accumulatedServerToolInputJson = "";
+        const resolvedServerToolInputs = new Map<
+          string,
+          Record<string, unknown>
+        >();
+
         stream.on("streamEvent", (event) => {
           // Reset the text sentinel buffer at each content-block boundary.
           // A new block starts fresh; at the end of a block, flush any
@@ -1300,6 +1384,8 @@ export class AnthropicProvider implements Provider {
             event.type === "content_block_start" &&
             event.content_block.type === "server_tool_use"
           ) {
+            currentServerToolUseId = event.content_block.id;
+            accumulatedServerToolInputJson = "";
             onEvent?.({
               type: "server_tool_start",
               name: event.content_block.name,
@@ -1315,11 +1401,21 @@ export class AnthropicProvider implements Provider {
           ) {
             const block = event.content_block as {
               tool_use_id: string;
-              content?: { type: "web_search_tool_result_error" } | unknown[];
+              content?:
+                | { type: "web_search_tool_result_error"; error_code?: string }
+                | unknown[];
             };
             const isError =
               !Array.isArray(block.content) &&
               block.content?.type === "web_search_tool_result_error";
+            const errorCode =
+              isError && !Array.isArray(block.content)
+                ? block.content?.error_code
+                : undefined;
+            const resolvedInput = resolvedServerToolInputs.get(
+              block.tool_use_id,
+            );
+            resolvedServerToolInputs.delete(block.tool_use_id);
             onEvent?.({
               type: "server_tool_complete",
               toolUseId: block.tool_use_id,
@@ -1327,6 +1423,8 @@ export class AnthropicProvider implements Provider {
               ...(Array.isArray(block.content)
                 ? { content: block.content }
                 : {}),
+              ...(resolvedInput ? { resolvedInput } : {}),
+              ...(errorCode ? { errorCode } : {}),
             });
           }
           if (event.type === "content_block_stop") {
@@ -1345,6 +1443,25 @@ export class AnthropicProvider implements Provider {
             currentStreamingToolName = undefined;
             currentStreamingToolUseId = undefined;
             accumulatedInputJson = "";
+            // Finalize the resolved input for a `server_tool_use` block (e.g.
+            // the actual web-search query) so the paired `web_search_tool_result`
+            // emits `server_tool_complete` with `resolvedInput` populated.
+            if (currentServerToolUseId && accumulatedServerToolInputJson) {
+              try {
+                const parsed = JSON.parse(accumulatedServerToolInputJson);
+                if (parsed && typeof parsed === "object") {
+                  resolvedServerToolInputs.set(
+                    currentServerToolUseId,
+                    parsed as Record<string, unknown>,
+                  );
+                }
+              } catch {
+                // Malformed partial JSON — drop silently; downstream falls
+                // back to whatever was captured at server_tool_start.
+              }
+            }
+            currentServerToolUseId = undefined;
+            accumulatedServerToolInputJson = "";
             // Flush residual text buffer unless it's exactly a sentinel.
             if (textBuffer.length > 0 && !isCompleteSentinel(textBuffer)) {
               onEvent?.({ type: "text_delta", text: textBuffer });
@@ -1354,6 +1471,13 @@ export class AnthropicProvider implements Provider {
         });
 
         stream.on("inputJson", (partialJson) => {
+          if (currentServerToolUseId) {
+            // Server-tool input (e.g. `web_search` query) — accumulate without
+            // emitting `input_json_delta`; the daemon only consumes the
+            // finalized value from `server_tool_complete.resolvedInput`.
+            accumulatedServerToolInputJson += partialJson;
+            return;
+          }
           if (!currentStreamingToolName) return;
           accumulatedInputJson += partialJson;
           const now = Date.now();
@@ -1544,6 +1668,9 @@ export class AnthropicProvider implements Provider {
       case "text":
         return { type: "text", text: block.text };
       case "thinking":
+        if (!block.signature) {
+          return null;
+        }
         return {
           type: "thinking",
           thinking: block.thinking,

package/src/providers/call-site-routing.ts

@@ -23,10 +23,12 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
+import { getDb } from "../memory/db-connection.js";
 import {
   ConnectionResolutionError,
   tryResolveProviderForConnectionName,
 } from "./connection-resolution.js";
+import { listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
 import type {
   Message,
@@ -142,16 +144,32 @@ export class CallSiteRoutingProvider implements Provider {
       overrideProfile,
     });
 
-    if (resolved.provider_connection) {
+    let connectionName = resolved.provider_connection;
+
+    // When no connection is set and the provider differs from the default,
+    // auto-resolve to an active connection for the provider (handles the
+    // "Any active X connection" case where the profile set provider but
+    // not provider_connection, and the merge didn't inherit one).
+    if (!connectionName && resolved.provider !== this.defaultProvider.name) {
+      try {
+        const candidates = listConnections(getDb(), {
+          provider: resolved.provider,
+        });
+        const active = candidates.find((c) => c.status === "active");
+        if (active) {
+          connectionName = active.name;
+        }
+      } catch {
+        // DB not available — fall through to the original error path.
+      }
+    }
+
+    if (connectionName) {
       const connectionProvider = await this.resolveByConnection(
-        resolved.provider_connection,
+        connectionName,
         resolved.provider,
       );
       if (connectionProvider) return connectionProvider;
-      // Soft credential failure — the connection-resolution helper
-      // returned null because the underlying auth bundle yields no
-      // usable adapter (or threw transiently). Reuse the default for
-      // graceful per-call degradation.
       return this.defaultProvider;
     }
 

package/src/providers/connection-resolution.ts

@@ -30,7 +30,7 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
-import { getConnection } from "./inference/connections.js";
+import { getConnection, listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
 import { resolveProviderFromConnection } from "./registry.js";
 import type { Provider } from "./types.js";
@@ -104,15 +104,42 @@ export async function tryResolveProviderForConnectionName(
     );
   }
   if (expectedProvider && connection.provider !== expectedProvider) {
-    throw new ConnectionResolutionError(
-      connectionName,
-      "provider_mismatch",
-      `provider_connection "${connectionName}" has provider="${connection.provider}" but resolving profile declared provider="${expectedProvider}" — set the profile's provider_connection to a row matching its provider`,
-    );
+    // Mismatch usually means the config deep-merge inherited a stale
+    // provider_connection from a lower layer (e.g. profile sets a BYOK
+    // provider with "Any active" but the default layer's
+    // "anthropic-managed" leaked through). Try to find an active connection
+    // for the expected provider before giving up.
+    let resolved = false;
+    try {
+      const db = getDb();
+      const candidates = listConnections(db, { provider: expectedProvider });
+      const active = candidates.find((c) => c.status === "active");
+      if (active) {
+        log.info(
+          {
+            originalConnection: connectionName,
+            resolvedConnection: active.name,
+            expectedProvider,
+          },
+          "Auto-resolved stale provider_connection to matching active connection",
+        );
+        connection = active;
+        resolved = true;
+      }
+    } catch {
+      // DB not available — fall through to the original error.
+    }
+    if (!resolved) {
+      throw new ConnectionResolutionError(
+        connectionName,
+        "provider_mismatch",
+        `provider_connection "${connectionName}" has provider="${connection.provider}" but resolving profile declared provider="${expectedProvider}" — set the profile's provider_connection to a row matching its provider`,
+      );
+    }
   }
   if (connection.status === "disabled") {
     log.debug(
-      { connectionName },
+      { connectionName, provider: connection.provider },
       "provider_connection is disabled — returning null",
     );
     return null;
@@ -154,13 +181,36 @@ export async function resolveDefaultProvider(
   config: ProvidersConfig,
 ): Promise<Provider | null> {
   const resolved = resolveCallSiteConfig("mainAgent", config.llm);
-  const connectionName = resolved.provider_connection;
+  let connectionName = resolved.provider_connection;
   if (!connectionName) {
-    throw new ConnectionResolutionError(
-      "<llm.default>",
-      "missing_connection",
-      `llm.default.provider_connection is unset — every profile must declare a provider_connection. The boot-time backfill in lifecycle.ts populates this field; if you see this error, the backfill did not run or the field was manually cleared.`,
-    );
+    // The merged config has no provider_connection — the profile likely set
+    // provider without a connection ("Any active" selection), and the merge
+    // cleared or failed to inherit one. Try to find an active connection
+    // for the provider before giving up.
+    if (resolved.provider) {
+      try {
+        const candidates = listConnections(getDb(), {
+          provider: resolved.provider,
+        });
+        const active = candidates.find((c) => c.status === "active");
+        if (active) {
+          log.info(
+            { provider: resolved.provider, resolvedConnection: active.name },
+            "Auto-resolved missing provider_connection for default provider",
+          );
+          connectionName = active.name;
+        }
+      } catch {
+        // DB not available — fall through to the original error.
+      }
+    }
+    if (!connectionName) {
+      throw new ConnectionResolutionError(
+        "<llm.default>",
+        "missing_connection",
+        `llm.default.provider_connection is unset — every profile must declare a provider_connection. The boot-time backfill in lifecycle.ts populates this field; if you see this error, the backfill did not run or the field was manually cleared.`,
+      );
+    }
   }
   return tryResolveProviderForConnectionName(
     connectionName,

package/src/providers/fireworks/client.ts

@@ -1,3 +1,4 @@
+import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
 
 export interface FireworksProviderOptions {
@@ -8,6 +9,15 @@ export interface FireworksProviderOptions {
 
 const DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 
+const FIREWORKS_MODEL_EFFORT_CEILINGS: ReadonlyMap<
+  string,
+  "high" | "xhigh" | "max"
+> = new Map(
+  PROVIDER_CATALOG.find((p) => p.id === "fireworks")?.models.flatMap((m) =>
+    m.maxEffort ? ([[m.id, m.maxEffort]] as const) : [],
+  ) ?? [],
+);
+
 export class FireworksProvider extends OpenAIChatCompletionsProvider {
   constructor(
     apiKey: string,
@@ -19,9 +29,17 @@ export class FireworksProvider extends OpenAIChatCompletionsProvider {
       providerName: "fireworks",
       providerLabel: "Fireworks",
       streamTimeoutMs: options.streamTimeoutMs,
-      // Fireworks' OpenAI-compatible chat-completions API documents only
-      // low|medium|high for reasoning_effort; sending "xhigh" 4xxs upstream.
+      // Fallback for models not declared in the catalog. Most Fireworks
+      // chat-completions models only document `low|medium|high`; per-model
+      // overrides (e.g. DeepSeek V4 → "max") come from
+      // {@link resolveMaxReasoningEffort}.
       maxReasoningEffort: "high",
     });
   }
+
+  protected override resolveMaxReasoningEffort(
+    model: string,
+  ): "high" | "xhigh" | "max" {
+    return FIREWORKS_MODEL_EFFORT_CEILINGS.get(model) ?? "high";
+  }
 }

package/src/providers/inference/__tests__/adapter-factory-openai-compatible.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test";
+
+import { OpenAIChatCompletionsProvider } from "../../openai/chat-completions-provider.js";
+import {
+  buildProviderAdapter,
+  createAdapterFromConnection,
+} from "../adapter-factory.js";
+import type { ProviderConnection, ResolvedAuth } from "../auth.js";
+
+describe("openai-compatible adapter factory", () => {
+  test("buildProviderAdapter returns an OpenAIChatCompletionsProvider", () => {
+    const adapter = buildProviderAdapter("openai-compatible", {
+      apiKey: "test-key",
+      model: "my-local-model",
+      streamTimeoutMs: 60_000,
+      baseURL: "http://localhost:8080/v1",
+      useNativeWebSearch: false,
+    });
+    expect(adapter).toBeInstanceOf(OpenAIChatCompletionsProvider);
+  });
+
+  test("createAdapterFromConnection wires baseURL from ResolvedAuth", () => {
+    const connection: ProviderConnection = {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      status: "active",
+      label: "vLLM",
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "my-model" }],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      isManaged: false,
+    };
+
+    const resolvedAuth: ResolvedAuth = {
+      kind: "header",
+      headers: { Authorization: "Bearer sk-test" },
+      baseUrl: "http://localhost:8080/v1",
+    };
+
+    const adapter = createAdapterFromConnection(connection, resolvedAuth, {
+      model: "my-model",
+      streamTimeoutMs: 60_000,
+    });
+
+    expect(adapter).not.toBeNull();
+  });
+
+  test("createAdapterFromConnection rejects 'none' auth for openai-compatible", () => {
+    const connection: ProviderConnection = {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "none" },
+      status: "active",
+      label: null,
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "my-model" }],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      isManaged: false,
+    };
+
+    const resolvedAuth: ResolvedAuth = { kind: "none" };
+
+    const adapter = createAdapterFromConnection(connection, resolvedAuth, {
+      model: "my-model",
+    });
+
+    // openai-compatible is setupMode: "api-key", not keyless, so none auth
+    // should be rejected.
+    expect(adapter).toBeNull();
+  });
+});