@vellumai/assistant 0.12.2 → 0.12.3-staging.1

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/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 } : {}),
     }),
+  jev: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new JevProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
   vellum: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new VellumProvider(apiKey, model, {
       streamTimeoutMs,

package/src/providers/jev/client.test.ts

@@ -0,0 +1,260 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { ProviderError } from "../../util/errors.js";
+import {
+  conversationToState,
+  DEFAULT_JEV_MODEL,
+  JevProvider,
+  parseSystemOneOverride,
+  validateJevApiKey,
+} from "./client.js";
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function stubFetch(
+  impl: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>,
+): typeof fetch {
+  return impl as unknown as typeof fetch;
+}
+
+describe("parseSystemOneOverride", () => {
+  test("reads a TypeSafe questions payload from the last user message", () => {
+    const parsed = parseSystemOneOverride(
+      JSON.stringify({
+        questions: {
+          urgency: {
+            type: "noul",
+            instructions: "Does this message express urgency?",
+          },
+        },
+      }),
+    );
+    expect(parsed?.questions.urgency?.type).toBe("noul");
+    expect(parsed?.state).toBeUndefined();
+  });
+
+  test("forwards an explicit state when present", () => {
+    const parsed = parseSystemOneOverride(
+      JSON.stringify({
+        state: "Cancel my subscription",
+        questions: {
+          intent: {
+            type: "choice",
+            instructions: "What does the user want?",
+            criteria: { cancel: "Cancellation", refund: "Refund" },
+          },
+        },
+      }),
+    );
+    expect(parsed?.state).toBe("Cancel my subscription");
+    expect(parsed?.questions.intent?.type).toBe("choice");
+  });
+
+  test("ignores ordinary chat text", () => {
+    expect(parseSystemOneOverride("Cancel my subscription")).toBeNull();
+  });
+});
+
+describe("conversationToState", () => {
+  test("flattens system prompt and turns into a string", () => {
+    const state = conversationToState(
+      [
+        {
+          role: "user",
+          content: [{ type: "text", text: "Cancel my subscription" }],
+        },
+      ],
+      "You are a helpful assistant.",
+    );
+    expect(state).toContain("system:\nYou are a helpful assistant.");
+    expect(state).toContain("user:\nCancel my subscription");
+  });
+});
+
+describe("validateJevApiKey", () => {
+  test("rejects a 401 from the models endpoint", async () => {
+    globalThis.fetch = stubFetch(async () =>
+      jsonResponse({ error: "nope" }, 401),
+    );
+    const result = await validateJevApiKey("bad-key");
+    expect(result).toEqual({
+      valid: false,
+      reason: "API key is invalid or expired.",
+    });
+  });
+
+  test("falls back to System One when /v1/models is unpublished", async () => {
+    const urls: string[] = [];
+    globalThis.fetch = stubFetch(async (input) => {
+      const url = String(input);
+      urls.push(url);
+      if (url.endsWith("/v1/models")) {
+        return jsonResponse({ error: "missing" }, 404);
+      }
+      return jsonResponse({
+        model: DEFAULT_JEV_MODEL,
+        answers: { probe: { type: "noul", noul: 1 } },
+      });
+    });
+    const result = await validateJevApiKey("sk-test");
+    expect(result).toEqual({ valid: true });
+    expect(urls.some((url) => url.endsWith("/v1/systemone"))).toBe(true);
+  });
+
+  test("allows the key on transient 429s", async () => {
+    globalThis.fetch = stubFetch(async () =>
+      jsonResponse({ error: "slow down" }, 429),
+    );
+    const result = await validateJevApiKey("sk-test");
+    expect(result).toEqual({ valid: true });
+  });
+});
+
+describe("JevProvider.sendMessage", () => {
+  test("evaluates conversation state with the default experiment noul", async () => {
+    let captured: { url: string; body: unknown } | undefined;
+    globalThis.fetch = stubFetch(async (input, init) => {
+      captured = {
+        url: String(input),
+        body: JSON.parse(String(init?.body ?? "{}")) as unknown,
+      };
+      return jsonResponse({
+        model: "jev-latest",
+        answers: { actionable: { type: "noul", noul: 0.91 } },
+        usage: { input_tokens: 12, output_tokens: 4 },
+      });
+    });
+
+    const provider = new JevProvider("sk-test", "jev-latest");
+    const deltas: string[] = [];
+    const response = await provider.sendMessage(
+      [
+        {
+          role: "user",
+          content: [{ type: "text", text: "Please cancel this charge." }],
+        },
+      ],
+      {
+        onEvent: (event) => {
+          if (event.type === "text_delta") {
+            deltas.push(event.text);
+          }
+        },
+      },
+    );
+
+    expect(captured?.url).toBe("https://api.typesafe.ai/v1/systemone");
+    expect(captured?.body).toMatchObject({
+      model: "jev-latest",
+      questions: {
+        actionable: {
+          type: "noul",
+          instructions:
+            "Does the latest user message ask the assistant to take a specific action?",
+        },
+      },
+    });
+    expect(String((captured?.body as { state: string }).state)).toContain(
+      "Please cancel this charge.",
+    );
+    expect(response.model).toBe("jev-latest");
+    expect(response.usage).toEqual({ inputTokens: 12, outputTokens: 4 });
+    expect(response.content[0]).toEqual({
+      type: "text",
+      text: JSON.stringify(
+        { actionable: { type: "noul", noul: 0.91 } },
+        null,
+        2,
+      ),
+    });
+    expect(deltas.join("")).toBe(
+      response.content[0] && "text" in response.content[0]
+        ? response.content[0].text
+        : "",
+    );
+  });
+
+  test("forwards an explicit System One payload from the last user message", async () => {
+    let captured: unknown;
+    globalThis.fetch = stubFetch(async (_input, init) => {
+      captured = JSON.parse(String(init?.body ?? "{}")) as unknown;
+      return jsonResponse({
+        model: "jev-latest",
+        answers: {
+          department: {
+            type: "choice",
+            choice: "billing",
+            probabilities: { billing: 0.8, technical: 0.2 },
+            confidence: 0.6,
+          },
+        },
+      });
+    });
+
+    const provider = new JevProvider("sk-test", "jev-latest");
+    await provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              state: "I was charged twice.",
+              questions: {
+                department: {
+                  type: "choice",
+                  instructions: "Which team should handle this?",
+                  criteria: {
+                    billing: "Payments",
+                    technical: "Bugs",
+                  },
+                },
+              },
+            }),
+          },
+        ],
+      },
+    ]);
+
+    expect(captured).toMatchObject({
+      model: "jev-latest",
+      state: "I was charged twice.",
+      questions: {
+        department: {
+          type: "choice",
+          instructions: "Which team should handle this?",
+        },
+      },
+    });
+  });
+
+  test("throws ProviderError with invalid_credentials on 401", async () => {
+    globalThis.fetch = stubFetch(async () =>
+      jsonResponse({ error: { message: "bad key" } }, 401),
+    );
+    const provider = new JevProvider("sk-test", "jev-latest");
+    try {
+      await provider.sendMessage([
+        { role: "user", content: [{ type: "text", text: "hello" }] },
+      ]);
+      throw new Error("expected sendMessage to throw");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      const providerError = error as ProviderError;
+      expect(providerError.statusCode).toBe(401);
+      expect(providerError.reason).toBe("invalid_credentials");
+      expect(providerError.message).toBe("bad key");
+    }
+  });
+});