@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/plugins/defaults/task-progress/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "default-task-progress",
+  "version": "1.0.0",
+  "description": "First-party default plugin that injects a compact provider-only snapshot of active task_progress cards at user-prompt-submit and post-compact.",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20.12.0"
+  },
+  "peerDependencies": {
+    "@vellumai/plugin-api": "^0.12.2"
+  }
+}

package/src/plugins/defaults/task-progress/src/apply-task-progress-context.ts

@@ -0,0 +1,93 @@
+import {
+  type ContentBlock,
+  type Message,
+} from "@vellumai/plugin-api";
+
+import {
+  type ConversationSurfaceSnapshot,
+  listConversationSurfaceSnapshots,
+} from "../../../../daemon/conversation-surface-snapshots.js";
+import {
+  ACTIVE_TASK_PROGRESS_BLOCK,
+  formatActiveTaskProgressSnapshot,
+} from "./format-task-progress-context.js";
+
+function stripTaggedBlocksFromText(text: string): string {
+  return text.replace(ACTIVE_TASK_PROGRESS_BLOCK, "");
+}
+
+function stripActiveTaskProgressBlocks(messages: Message[]): Message[] {
+  let changed = false;
+  const next: Message[] = [];
+  for (const message of messages) {
+    const content: ContentBlock[] = [];
+    let contentChanged = false;
+    for (const block of message.content) {
+      if (block.type !== "text") {
+        content.push(block);
+        continue;
+      }
+      const stripped = stripTaggedBlocksFromText(block.text);
+      if (stripped === block.text) {
+        content.push(block);
+        continue;
+      }
+      contentChanged = true;
+      if (stripped.trim().length === 0) {
+        continue;
+      }
+      content.push({ ...block, text: stripped });
+    }
+    if (!contentChanged) {
+      next.push(message);
+      continue;
+    }
+    changed = true;
+    next.push({ ...message, content });
+  }
+  return changed ? next : messages;
+}
+
+function attachToTrailingUserMessage(
+  messages: Message[],
+  snapshot: string,
+): Message[] {
+  let userIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      userIndex = i;
+      break;
+    }
+  }
+  if (userIndex === -1) {
+    return messages;
+  }
+  const user = messages[userIndex]!;
+  return [
+    ...messages.slice(0, userIndex),
+    {
+      ...user,
+      content: [...user.content, { type: "text" as const, text: snapshot }],
+    },
+    ...messages.slice(userIndex + 1),
+  ];
+}
+
+/**
+ * Replace any prior tagged snapshot on the working history with the current
+ * active task-progress cards. Assigns a new message array when the history
+ * changes so the snapshot is not written back as ordinary transcript.
+ */
+export function applyTaskProgressContext(
+  conversationId: string,
+  messages: Message[],
+): Message[] {
+  const snapshots: ConversationSurfaceSnapshot[] =
+    listConversationSurfaceSnapshots(conversationId);
+  const snapshotText = formatActiveTaskProgressSnapshot(snapshots);
+  const stripped = stripActiveTaskProgressBlocks(messages);
+  if (snapshotText.length === 0) {
+    return stripped;
+  }
+  return attachToTrailingUserMessage(stripped, snapshotText);
+}

package/src/plugins/defaults/task-progress/src/format-task-progress-context.ts

@@ -0,0 +1,67 @@
+import type { ConversationSurfaceSnapshot } from "../../../../daemon/conversation-surface-snapshots.js";
+import { getTaskProgressDataFromSurfaceData } from "../../../../runtime/task-progress.js";
+
+export const ACTIVE_TASK_PROGRESS_OPEN = "<active_task_progress>";
+export const ACTIVE_TASK_PROGRESS_CLOSE = "</active_task_progress>";
+
+export const ACTIVE_TASK_PROGRESS_BLOCK =
+  /<active_task_progress\b[\s\S]*?<\/active_task_progress>/gi;
+
+const STEP_INSTRUCTION =
+  "Update this card with ui_update as the steps change.";
+
+function normalizeField(value: string): string {
+  return value
+    .replace(/[<>]/g, "")
+    .replace(/[\r\n\u2028\u2029]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function isActiveTaskProgressSurface(
+  snapshot: ConversationSurfaceSnapshot,
+): boolean {
+  if (snapshot.surfaceType !== "card" || snapshot.completed) {
+    return false;
+  }
+  const plan = getTaskProgressDataFromSurfaceData(snapshot.data);
+  if (!plan) {
+    return false;
+  }
+  return plan.steps.some(
+    (step) => step.status === "pending" || step.status === "in_progress",
+  );
+}
+
+export function formatActiveTaskProgressSnapshot(
+  snapshots: ConversationSurfaceSnapshot[],
+): string {
+  const cards = snapshots.filter(isActiveTaskProgressSurface);
+  if (cards.length === 0) {
+    return "";
+  }
+  return cards
+    .map((snapshot) => {
+      const plan = getTaskProgressDataFromSurfaceData(snapshot.data);
+      if (!plan) {
+        return "";
+      }
+      const lines = [
+        ACTIVE_TASK_PROGRESS_OPEN,
+        `surface_id: ${normalizeField(snapshot.surfaceId)}`,
+      ];
+      const title = plan.title ? normalizeField(plan.title) : "";
+      if (title.length > 0) {
+        lines.push(`title: ${title}`);
+      }
+      lines.push("steps:");
+      for (const step of plan.steps) {
+        lines.push(`- [${step.status}] ${normalizeField(step.label)}`);
+      }
+      lines.push(STEP_INSTRUCTION);
+      lines.push(ACTIVE_TASK_PROGRESS_CLOSE);
+      return lines.join("\n");
+    })
+    .filter((block) => block.length > 0)
+    .join("\n");
+}

package/src/plugins/defaults/tool-error/hooks/post-tool-use.ts

@@ -10,7 +10,10 @@
  * guidance while the client-facing and persisted tool output stay the tool's
  * actual result. This mirrors how Claude Code (`additionalContext`) and Codex
  * (`additional_contexts`) surface PostToolUse feedback as separate context
- * rather than rewriting the tool response.
+ * rather than rewriting the tool response. The one exception is an assistant
+ * turn that left a native web search deferred: its answering message must
+ * hold tool_result blocks alone, so the loop folds the guidance into the
+ * provider-bound copy of the errored tool_result (see `buildToolResultFollowUp`).
  *
  * The coaching is bounded per tool: once a single tool has failed
  * `MAX_CONSECUTIVE_ERROR_NUDGES` times in a row the notice is dropped — the

package/src/plugins/defaults/tool-result-truncate/terminal.ts

@@ -6,52 +6,7 @@
  * This module is side-effect free: importing it does not register any plugin.
  */
 
-const HIGH_SURROGATE_START = 0xd800;
-const HIGH_SURROGATE_END = 0xdbff;
-const LOW_SURROGATE_START = 0xdc00;
-const LOW_SURROGATE_END = 0xdfff;
-
-function isHighSurrogate(code: number): boolean {
-  return code >= HIGH_SURROGATE_START && code <= HIGH_SURROGATE_END;
-}
-
-function isLowSurrogate(code: number): boolean {
-  return code >= LOW_SURROGATE_START && code <= LOW_SURROGATE_END;
-}
-
-/**
- * Slice a string by code-unit indices without splitting a surrogate pair, so
- * the result never ends or begins mid-emoji. Indices are clamped to the
- * string bounds; a cut that would land between a high/low surrogate is nudged
- * inward to the nearest whole code point.
- */
-function safeStringSlice(
-  str: string,
-  start = 0,
-  end: number = str.length,
-): string {
-  let safeStart = Math.max(0, Math.min(str.length, start));
-  let safeEnd = Math.max(safeStart, Math.min(str.length, end));
-
-  if (safeEnd < str.length && safeEnd > safeStart) {
-    const lastCode = str.charCodeAt(safeEnd - 1);
-    if (isHighSurrogate(lastCode)) {
-      safeEnd--;
-    }
-  }
-
-  if (safeStart > 0 && safeStart < str.length) {
-    const firstCode = str.charCodeAt(safeStart);
-    if (isLowSurrogate(firstCode)) {
-      safeStart++;
-      if (safeStart > safeEnd) {
-        safeEnd = safeStart;
-      }
-    }
-  }
-
-  return str.slice(safeStart, safeEnd);
-}
+import { safeStringSlice } from "@vellumai/plugin-api";
 
 /**
  * Minimum number of characters to preserve when truncating.

package/src/prompts/__tests__/parallel-tasks-section.test.ts

@@ -103,6 +103,31 @@ describe("parallel-tasks system prompt section", () => {
     }
   });
 
+  test("an explicit rendered state replaces the derivation", () => {
+    // A fork wake replaying its source's recorded surface renders what the
+    // source's live turn rendered, whatever its own scope could spawn.
+    expect(
+      buildSystemPrompt({
+        canSpawnSubagents: false,
+        delegateIndependentTasks: true,
+      }),
+    ).toContain(HEADING);
+    expect(
+      buildSystemPrompt({
+        canSpawnSubagents: true,
+        delegateIndependentTasks: false,
+      }),
+    ).not.toContain(HEADING);
+    // It is the rendered state, not a capability claim: the channel gate has
+    // already been applied by the turn that recorded it.
+    expect(
+      buildSystemPrompt({
+        channelCapabilities: channel("slack"),
+        delegateIndependentTasks: true,
+      }),
+    ).toContain(HEADING);
+  });
+
   test("delegates only independent tasks and keeps small requests inline", () => {
     const prompt = buildSystemPrompt({ canSpawnSubagents: true });
     expect(prompt).toContain("several independent things at once");

package/src/prompts/delegation-gate.ts

@@ -0,0 +1,57 @@
+import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
+
+/**
+ * Whether this turn arrived on an external messaging surface (Slack, Telegram,
+ * email, a plugin channel) rather than the app itself.
+ *
+ * `resolveChannelCapabilities` folds every first-party client (macOS, web,
+ * iOS, CLI, the HTTP API) onto the `vellum` channel, and a prompt built
+ * outside a turn carries no capabilities at all, so those two cases are the
+ * app and everything else is a channel the gateway delivers to over a reply
+ * callback.
+ */
+export function isExternalChannelTurn(
+  capabilities: ChannelCapabilities | undefined,
+): boolean {
+  const channel = capabilities?.channel;
+  return channel !== undefined && channel !== "vellum";
+}
+
+/** The two inputs the delegation section's gate reads. */
+export interface DelegationGateInputs {
+  /**
+   * Whether the turn can actually spawn subagents, read off its resolved
+   * tool surface (`canSpawnSubagentsForTurn`). Absent means no.
+   */
+  canSpawnSubagents?: boolean;
+  channelCapabilities?: ChannelCapabilities;
+}
+
+/**
+ * The delegation section's gate: the turn can spawn AND a subagent's answer
+ * would reach whoever asked.
+ *
+ * Off unless a caller states it can spawn, and the caller that states it
+ * derives the answer from the turn's resolved tool surface rather than
+ * assuming (`canSpawnSubagentsForTurn`). Guidance about handing work to
+ * subagents is worth nothing to a turn that cannot spawn, and worse than
+ * nothing when it makes that turn defer work it has to do inline.
+ *
+ * Off on an external channel for the second reason: a subagent's terminal
+ * summary reaches the parent through the conversation's event sink, which an
+ * app client reads and a channel does not, so a delegated answer would never
+ * be delivered to the person who asked for it.
+ *
+ * Its own module so the conversation's prompt build and the prompt builder
+ * share one derivation: the conversation resolves the state once, hands it to
+ * the builder, and keeps it for the wire-surface recorder, so the prompt the
+ * provider receives and the state a fork replays are the same value.
+ */
+export function resolveDelegateIndependentTasks(
+  options: DelegationGateInputs | undefined,
+): boolean {
+  return (
+    options?.canSpawnSubagents === true &&
+    !isExternalChannelTurn(options?.channelCapabilities)
+  );
+}

package/src/prompts/system-prompt.ts

@@ -26,6 +26,7 @@ import {
 import { stripCommentLines } from "../util/strip-comment-lines.js";
 import { cleanupBootstrapFiles } from "./bootstrap-cleanup.js";
 import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "./cache-boundary.js";
+import { resolveDelegateIndependentTasks } from "./delegation-gate.js";
 import { resolveGuardianPersona, resolveUserSlug } from "./persona-resolver.js";
 import { renderWorkspaceSections } from "./sections.js";
 import { isTemplateContent } from "./template-detection.js";
@@ -440,23 +441,15 @@ export interface BuildSystemPromptOptions {
    * pass), rather than from a caller's assumption.
    */
   canSpawnSubagents?: boolean;
-}
-
-/**
- * Whether this turn arrived on an external messaging surface (Slack, Telegram,
- * email, a plugin channel) rather than the app itself.
- *
- * `resolveChannelCapabilities` folds every first-party client (macOS, web,
- * iOS, CLI, the HTTP API) onto the `vellum` channel, and a prompt built
- * outside a turn carries no capabilities at all, so those two cases are the
- * app and everything else is a channel the gateway delivers to over a reply
- * callback.
- */
-function isExternalChannelTurn(
-  capabilities: ChannelCapabilities | undefined,
-): boolean {
-  const channel = capabilities?.channel;
-  return channel !== undefined && channel !== "vellum";
+  /**
+   * The delegation section's rendered state, replacing the derivation from
+   * `canSpawnSubagents` and `channelCapabilities` when set. A fork wake
+   * replaying its source conversation's recorded surface passes the state
+   * the source's live turn rendered (`ConversationToolSurface`), so the
+   * fork's system prompt matches the source's byte for byte even though the
+   * wake's own scope cannot spawn; a spawn is still rejected at execution.
+   */
+  delegateIndependentTasks?: boolean;
 }
 
 /**
@@ -525,22 +518,11 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   const ctx = {
     ...options,
     hasNoClient,
-    // The delegation section's gate: the turn can spawn AND a subagent's
-    // answer would reach whoever asked.
-    //
-    // Off unless a caller states it can spawn, and the caller that states it
-    // derives the answer from the turn's resolved tool surface rather than
-    // assuming (`canSpawnSubagentsForTurn`). Guidance about handing work to
-    // subagents is worth nothing to a turn that cannot spawn, and worse than
-    // nothing when it makes that turn defer work it has to do inline.
-    //
-    // Off on an external channel for the second reason: a subagent's terminal
-    // summary reaches the parent through the conversation's event sink, which
-    // an app client reads and a channel does not, so a delegated answer would
-    // never be delivered to the person who asked for it.
+    // The delegation section's gate, or the rendered state a replaying wake
+    // carries from its source (see `resolveDelegateIndependentTasks`).
     delegateIndependentTasks:
-      options?.canSpawnSubagents === true &&
-      !isExternalChannelTurn(options?.channelCapabilities),
+      options?.delegateIndependentTasks ??
+      resolveDelegateIndependentTasks(options),
     isContainerized: getIsContainerized(),
     sendUserMessageTool: options?.sendUserMessageTool === true,
     workspaceDir: getWorkspaceDir(),

package/src/providers/__tests__/context-overflow-error.test.ts

@@ -47,6 +47,16 @@ describe("ContextOverflowError", () => {
     expect((err as Error & { cause?: unknown }).cause).toBe(cause);
   });
 
+  test("forwards rawRequest onto the ProviderError", () => {
+    const rawRequest = { model: "claude-opus-4.6", messages: [] };
+    const err = new ContextOverflowError("m", "anthropic", {
+      actualTokens: 10,
+      maxTokens: 5,
+      rawRequest,
+    });
+    expect(err.rawRequest).toEqual(rawRequest);
+  });
+
   test("omits optional fields when unset", () => {
     const err = new ContextOverflowError("m", "gemini");
     expect(err.actualTokens).toBeUndefined();

package/src/providers/__tests__/search-provider-catalog.test.ts

@@ -86,4 +86,22 @@ describe("search-provider-catalog", () => {
     expect(getSearchProvider("brave")?.displayName).toBe("Brave");
     expect(getSearchProvider("unknown-xyz")).toBeUndefined();
   });
+
+  test("SearXNG is a keyless BYOK provider that requires an instance URL", () => {
+    const searxng = getSearchProvider("searxng");
+    expect(searxng?.kind).toBe("byok");
+    expect(searxng?.keyless).toBe(true);
+    expect(searxng?.supportsApiBase).toBe(true);
+    expect(searxng?.defaultApiBase).toBeUndefined();
+    expect(searxng?.envVar).toBe("SEARXNG_API_KEY");
+  });
+
+  test("TinyFish is a keyed BYOK provider with a cloud API base", () => {
+    const tinyfish = getSearchProvider("tinyfish");
+    expect(tinyfish?.kind).toBe("byok");
+    expect(tinyfish?.keyless).toBeUndefined();
+    expect(tinyfish?.supportsApiBase).toBe(true);
+    expect(tinyfish?.defaultApiBase).toBe("https://api.search.tinyfish.ai");
+    expect(tinyfish?.envVar).toBe("TINYFISH_API_KEY");
+  });
 });

package/src/providers/anthropic/client.ts

@@ -958,6 +958,7 @@ export class AnthropicProvider implements Provider {
     // (30 min default) from an external transport abort (bun fetch deadline,
     // edge LB, NAT idle) — only the latter should be retried.
     let innerTimeoutSignal: AbortSignal | undefined;
+    let inspectableRequest: unknown | undefined;
     try {
       sentMessages = await this.buildSentMessages(messages);
       const {
@@ -1344,6 +1345,7 @@ export class AnthropicProvider implements Provider {
         const streamOnce = async (
           streamParams: Anthropic.MessageStreamParams,
         ): Promise<Anthropic.Message> => {
+          inspectableRequest = streamParams;
           const stream: UnifiedStream = useFastMode
             ? (this.client.beta.messages.stream(
                 {
@@ -1768,6 +1770,7 @@ export class AnthropicProvider implements Provider {
               statusCode: error.status,
               reason: "context_overflow",
               cause: error,
+              rawRequest: inspectableRequest,
             },
           );
         }
@@ -1779,7 +1782,11 @@ export class AnthropicProvider implements Provider {
           reason?: ProviderErrorReason;
           apiErrorType?: string;
           apiErrorCode?: string;
+          rawRequest?: unknown;
         } = {};
+        if (inspectableRequest !== undefined) {
+          errorOptions.rawRequest = inspectableRequest;
+        }
         if (retryAfterMs !== undefined) {
           errorOptions.retryAfterMs = retryAfterMs;
         }
@@ -1832,7 +1839,9 @@ export class AnthropicProvider implements Provider {
         }`,
         "anthropic",
         undefined,
-        abortReason ? { cause: error, abortReason } : { cause: error },
+        abortReason
+          ? { cause: error, abortReason, rawRequest: inspectableRequest }
+          : { cause: error, rawRequest: inspectableRequest },
       );
     }
   }

package/src/providers/anthropic-gateway-shared.ts

@@ -45,6 +45,9 @@ export function retagDelegateError(
       maxTokens: error.maxTokens,
       statusCode: error.statusCode,
       cause: error,
+      ...(error.rawRequest !== undefined
+        ? { rawRequest: error.rawRequest }
+        : {}),
     });
   }
   if (error instanceof ProviderError && error.provider !== providerName) {
@@ -57,6 +60,9 @@ export function retagDelegateError(
       apiErrorCode: error.apiErrorCode,
       apiErrorParam: error.apiErrorParam,
       rawBody: error.rawBody,
+      ...(error.rawRequest !== undefined
+        ? { rawRequest: error.rawRequest }
+        : {}),
     });
   }
   throw error;

package/src/providers/fetch-provider-catalog.ts

@@ -84,6 +84,17 @@ export const FETCH_PROVIDER_CATALOG: readonly FetchProviderCatalogEntry[] = [
     supportsApiBase: true,
     defaultApiBase: "https://api.fastcrw.com",
   },
+  {
+    id: "tinyfish",
+    displayName: "TinyFish",
+    kind: "byok",
+    apiKeyPrefix: "TinyFish API key...",
+    envVar: "TINYFISH_API_KEY",
+    secretKey: "tinyfish",
+    privacyPolicyUrl: "https://www.tinyfish.ai/privacy-policy",
+    supportsApiBase: true,
+    defaultApiBase: "https://api.fetch.tinyfish.ai",
+  },
 ];
 
 /** Provider ids accepted by the web-fetch config schema. */

package/src/providers/gemini/client.ts

@@ -439,6 +439,14 @@ export class GeminiProvider implements Provider {
         )
       : undefined;
 
+    let inspectableRequest:
+      | {
+          model: string;
+          contents: unknown;
+          config: genai.GenerateContentConfig;
+        }
+      | undefined;
+
     try {
       recordProviderRequestDiagnostics({ model_id: activeModel });
       const geminiContents = await this.toGeminiContents(messages, activeModel);
@@ -476,6 +484,12 @@ export class GeminiProvider implements Provider {
         geminiConfig.httpOptions = { headers: usageAttributionHeaders };
       }
 
+      inspectableRequest = {
+        model: activeModel,
+        contents: geminiContents,
+        config: stripGeminiHttpOptions(geminiConfig),
+      };
+
       // Accumulate from streaming chunks
       let fullText = "";
       const functionCalls: Array<{
@@ -583,11 +597,6 @@ export class GeminiProvider implements Provider {
         content.push(block);
       }
 
-      const rawRequest = {
-        model: activeModel,
-        contents: geminiContents,
-        config: stripGeminiHttpOptions(geminiConfig),
-      };
       const rawResponse = {
         model: responseModel,
         text: fullText || null,
@@ -609,7 +618,7 @@ export class GeminiProvider implements Provider {
           ...(cachedTokens > 0 ? { cacheReadInputTokens: cachedTokens } : {}),
         },
         stopReason: finishReason,
-        rawRequest,
+        rawRequest: inspectableRequest,
         rawResponse,
       };
     } catch (error) {
@@ -630,6 +639,7 @@ export class GeminiProvider implements Provider {
               maxTokens: overflow.maxTokens,
               statusCode: error.status,
               cause: error,
+              rawRequest: inspectableRequest,
             },
           );
         }
@@ -639,7 +649,12 @@ export class GeminiProvider implements Provider {
           error.status,
           // Skip reason on caller-abort: abortReason already carries the intent
           // and short-circuits classification/retry (mirrors the Anthropic client).
-          abortReason ? { abortReason } : { reason: deriveGeminiReason(error) },
+        abortReason
+            ? { abortReason, rawRequest: inspectableRequest }
+            : {
+                reason: deriveGeminiReason(error),
+                rawRequest: inspectableRequest,
+              },
         );
       }
       throw new ProviderError(
@@ -648,7 +663,9 @@ export class GeminiProvider implements Provider {
         }`,
         "gemini",
         undefined,
-        abortReason ? { cause: error, abortReason } : { cause: error },
+        abortReason
+          ? { cause: error, abortReason, rawRequest: inspectableRequest }
+          : { cause: error, rawRequest: inspectableRequest },
       );
     }
   }

package/src/providers/inference/adapter-factory.ts

@@ -35,6 +35,7 @@ import { AtlasCloudProvider } from "../atlascloud/client.js";
 import { BasetenProvider } from "../baseten/client.js";
 import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
+import { JevProvider } from "../jev/client.js";
 import { MinimaxProvider } from "../minimax/client.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { OllamaProvider } from "../ollama/client.js";
@@ -205,6 +206,11 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
+  typesafe: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new JevProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
   vellum: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new VellumProvider(apiKey, model, {
       streamTimeoutMs,