@vellumai/assistant 0.12.2-dev.202609172017.3da279e → 0.12.2-dev.202609172115.0b9be8f

package/openapi.yaml

@@ -16556,7 +16556,7 @@ paths:
             type: string
           description:
             "Filter by provider id. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, jev,
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
             vellum"
       responses:
         "200":
@@ -16829,7 +16829,7 @@ paths:
             type: string
           description:
             "Filter by provider. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, jev,
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
             vellum, chatgpt"
       responses:
         "200":
@@ -38400,7 +38400,7 @@ components:
         - atlascloud
         - baseten
         - poolside
-        - jev
+        - typesafe
         - vellum
         - chatgpt
     Auth:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609172017.3da279e",
+  "version": "0.12.2-dev.202609172115.0b9be8f",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -389,7 +389,7 @@ describe("setInferenceProfileSession", () => {
       profiles: {
         jev: {
           source: "user",
-          provider: "jev",
+          provider: "typesafe",
           model: "jev-latest",
           status: "active",
         },

package/src/__tests__/llm-catalog-parity.test.ts

@@ -234,12 +234,12 @@ describe("LLM catalog parity: daemon vs client", () => {
   });
 
   test("jev-latest opts out of chat text generation", () => {
-    expect(catalogModelSupportsText("jev", "jev-latest")).toBe(false);
+    expect(catalogModelSupportsText("typesafe", "jev-latest")).toBe(false);
     expect(catalogModelSupportsText("anthropic", "claude-opus-4-8")).toBe(true);
     expect(catalogModelSupportsText("openai-compatible", "local-model")).toBe(
       true,
     );
-    expect(DEFAULT_PROVIDER_CHOICES).not.toContain("jev");
+    expect(DEFAULT_PROVIDER_CHOICES).not.toContain("typesafe");
     expect(DEFAULT_PROVIDER_CHOICES).toContain("poolside");
   });
 

package/src/config/__tests__/default-provider.test.ts

@@ -73,7 +73,9 @@ describe("LLMSchema.defaultProvider", () => {
   });
 
   test("rejects a structured-decision catalog provider", () => {
-    expect(() => DefaultProviderSchema.parse({ provider: "jev" })).toThrow();
+    expect(() =>
+      DefaultProviderSchema.parse({ provider: "typesafe" }),
+    ).toThrow();
   });
 
   test("rejects an empty connectionName", () => {

package/src/config/profile-text-generation.test.ts

@@ -9,7 +9,7 @@ describe("profileSupportsTextGeneration", () => {
   test("false for a structured-decision catalog model", () => {
     expect(
       profileSupportsTextGeneration(
-        { provider: "jev", model: "jev-latest" },
+        { provider: "typesafe", model: "jev-latest" },
         {},
       ),
     ).toBe(false);
@@ -35,7 +35,7 @@ describe("profileSupportsTextGeneration", () => {
       profileSupportsTextGeneration(
         { mix: [{ profile: "jev" }, { profile: "balanced" }] },
         {
-          jev: { provider: "jev", model: "jev-latest" },
+          jev: { provider: "typesafe", model: "jev-latest" },
           balanced: { provider: "anthropic", model: "claude-opus-4-8" },
         },
       ),

package/src/config/schemas/llm.ts

@@ -62,7 +62,7 @@ export const KNOWN_LLM_PROVIDERS = [
   "opencode",
   "baseten",
   "poolside",
-  "jev",
+  "typesafe",
   // Routing identities: "vellum" = the platform-managed route (upstream
   // derived from the model at dispatch) and the catalog owner of
   // Vellum-hosted GPU models; "chatgpt" = the subscription route to OpenAI.

package/src/mcp/__tests__/manager-tool-caps.test.ts

@@ -10,7 +10,8 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { ResolvedMcpConfig } from "../../config/schemas/mcp.js";
 
 const toolsByServer = new Map<string, Array<{ name: string }>>();
-const connectDelays = new Map<string, number>();
+const connectGates = new Map<string, Promise<void>>();
+const listedServers = new Set<string>();
 let mcpGlobalMaxTools: number | undefined;
 
 mock.module("../../config/loader.js", () => ({
@@ -29,12 +30,13 @@ mock.module("../client.js", () => ({
       return null;
     }
     async connect() {
-      const delay = connectDelays.get(this.serverId) ?? 0;
-      if (delay > 0) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
+      const gate = connectGates.get(this.serverId);
+      if (gate) {
+        await gate;
       }
     }
     async listTools() {
+      listedServers.add(this.serverId);
       return (toolsByServer.get(this.serverId) ?? []).map((tool) => ({
         name: tool.name,
         description: `${this.serverId} ${tool.name}`,
@@ -66,7 +68,8 @@ function configWith(ids: string[]): ResolvedMcpConfig {
 describe("McpServerManager tool selection", () => {
   beforeEach(() => {
     toolsByServer.clear();
-    connectDelays.clear();
+    connectGates.clear();
+    listedServers.clear();
     mcpGlobalMaxTools = undefined;
   });
 
@@ -98,23 +101,32 @@ describe("McpServerManager tool selection", () => {
   test("a slow earlier server does not prevent later servers from connecting", async () => {
     toolsByServer.set("slow", [{ name: "slow_tool" }]);
     toolsByServer.set("fast", [{ name: "fast_tool" }]);
-    connectDelays.set("slow", 40);
+    let releaseSlow!: () => void;
+    connectGates.set(
+      "slow",
+      new Promise<void>((resolve) => {
+        releaseSlow = resolve;
+      }),
+    );
 
     const manager = new McpServerManager();
-    const startedAt = Date.now();
-    const started = await manager.start(configWith(["slow", "fast"]));
-    const elapsed = Date.now() - startedAt;
-
-    expect(started.connectedServerCount).toBe(2);
-    expect(started.servers.map((server) => server.serverId).sort()).toEqual([
-      "fast",
-      "slow",
-    ]);
-    expect(
-      elapsed < 80,
-      "Servers connect in parallel, so one 40ms delay should not serialize both.",
-    ).toBe(true);
-    await manager.stop();
+    const starting = manager.start(configWith(["slow", "fast"]));
+    try {
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      expect([...listedServers]).toEqual(["fast"]);
+
+      releaseSlow();
+      const started = await starting;
+      expect(started.connectedServerCount).toBe(2);
+      expect(started.servers.map((server) => server.serverId).sort()).toEqual([
+        "fast",
+        "slow",
+      ]);
+    } finally {
+      releaseSlow();
+      await starting;
+      await manager.stop();
+    }
   });
 
   test("a workspace global-max override raises how many tools are kept", async () => {

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -85,7 +85,7 @@ mock.module("../../../../../util/logger.js", () => ({
   }),
 }));
 
-const { selectPool, MemoryV3RetrievalUnavailableError } =
+const { selectPool, MemoryV3RetrievalUnavailableError, TYPE_SAFE_POOL_KEEP_NOUL } =
   await import("../pool-select.js");
 type SelectorPool = Parameters<typeof selectPool>[0];
 
@@ -968,3 +968,121 @@ describe("selectPool: cataloged thinking and forced-tool compatibility", () => {
     expect(selection.pages).toEqual([{ slug: "topic-x", sections: [] }]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// selectPool: TypeSafe System One noul-per-candidate path.
+// ---------------------------------------------------------------------------
+
+function typesafeResponse(answers: Record<string, unknown>): ProviderResponse {
+  return {
+    model: "jev-latest",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: JSON.stringify(answers, null, 2) }],
+    rawResponse: { answers },
+  };
+}
+
+function makeTypesafeProvider(response: ProviderResponse): Provider {
+  return {
+    name: "typesafe",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      return response;
+    },
+  };
+}
+
+function noulAnswer(noul: number): { type: "noul"; noul: number } {
+  return { type: "noul", noul };
+}
+
+describe("selectPool: TypeSafe System One", () => {
+  test("sends one noul per candidate and no select_pages tool", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(0.9),
+        "2": noulAnswer(0.1),
+        "3": noulAnswer(0.8),
+        "4": noulAnswer(0.2),
+      }),
+    );
+
+    await selectPool(makePool(), makeTurn("rollout?"));
+
+    expect(providerCalls).toHaveLength(1);
+    const [call] = providerCalls;
+    expect(call.options?.tools).toBeUndefined();
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)?.tool_choice,
+    ).toBeUndefined();
+    expect(
+      (call.options?.config as Record<string, unknown> | undefined)?.callSite,
+    ).toBe("memoryV3SelectL2");
+
+    const payload = JSON.parse(
+      (call.messages[0]!.content[0] as { text: string }).text,
+    ) as {
+      state: {
+        candidates: Record<string, { slug: string; text: string }>;
+        current_message: string;
+        selector_instructions: string;
+      };
+      questions: Record<string, { type: string; instructions: string }>;
+    };
+    expect(Object.keys(payload.questions)).toEqual(["1", "2", "3", "4"]);
+    expect(payload.questions["1"]?.type).toBe("noul");
+    expect(payload.questions["1"]?.instructions).toContain("`candidates.1`");
+    expect(payload.state.candidates["1"]?.slug).toBe("page-a");
+    expect(payload.state.candidates["1"]?.text).toBe(CARD_A);
+    expect(payload.state.candidates["3"]?.slug).toBe("topic-x");
+    expect(payload.state.current_message).toBe("rollout?");
+    expect(payload.state.selector_instructions.length).toBeGreaterThan(0);
+  });
+
+  test("keeps candidates at or above the inclusive noul threshold", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(TYPE_SAFE_POOL_KEEP_NOUL),
+        "2": noulAnswer(TYPE_SAFE_POOL_KEEP_NOUL - 0.01),
+        "3": noulAnswer(0.91),
+        "4": noulAnswer(0.12),
+      }),
+    );
+
+    const result = await selectPool(makePool(), makeTurn("rollout?"));
+    expect(result.keptAll).toBe(false);
+    expect(result.pages).toEqual([
+      { slug: "page-a", sections: [] },
+      { slug: "topic-x", sections: [] },
+    ]);
+  });
+
+  test("an all-below-threshold pool is a deliberate empty selection", async () => {
+    providerStub = makeTypesafeProvider(
+      typesafeResponse({
+        "1": noulAnswer(0.1),
+        "2": noulAnswer(0.2),
+        "3": noulAnswer(0.05),
+        "4": noulAnswer(0.3),
+      }),
+    );
+
+    const result = await selectPool(makePool(), makeTurn("nothing relevant"));
+    expect(result).toEqual({ pages: [], keptAll: false });
+  });
+
+  test("unusable answers throw after the re-prompt retry", async () => {
+    providerStub = makeTypesafeProvider({
+      model: "jev-latest",
+      stopReason: "end_turn",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      content: [{ type: "text", text: "not-json" }],
+    });
+
+    await expect(selectPool(makePool(), makeTurn("x"))).rejects.toThrow(
+      MemoryV3RetrievalUnavailableError,
+    );
+    expect(providerCalls).toHaveLength(3);
+  });
+});

package/src/plugins/defaults/memory/v3/orchestrate.ts

@@ -67,7 +67,9 @@
  *   3. A SINGLE forced-tool select (`selectPool`) over the whole pool. The
  *      result is this turn's selections — current turn only. Cross-turn
  *      persistence is the injector's job (net-new blocks frozen into history),
- *      not a per-turn re-rendered carry set.
+ *      not a per-turn re-rendered carry set. When the call site resolves to
+ *      TypeSafe, `selectPool` asks one System One noul per numbered candidate
+ *      instead of forcing `select_pages`.
  */
 
 import type { AssistantConfig } from "../../../../config/schema.js";

package/src/plugins/defaults/memory/v3/pool-select.ts

@@ -1,7 +1,7 @@
 /**
  * Memory v3 — single pool selector.
  *
- * Runs a SINGLE forced-tool call over one unified candidate pool rendered in
+ * Runs a SINGLE selector call over one unified candidate pool rendered in
  * two segments that share one numbering:
  *
  *   1. STABLE PREFIX — the core+hot lane pages as FULL CARDS (head section +
@@ -52,6 +52,8 @@
 import type {
   ContentBlock,
   Message,
+  Provider,
+  ProviderResponse,
   ToolUseContent,
 } from "@vellumai/plugin-api";
 import { getConfiguredProvider, safeStringSlice } from "@vellumai/plugin-api";
@@ -179,7 +181,8 @@ type PoolSelectorAttemptFailureReason =
   | "provider_error"
   | "missing_tool_use"
   | "unexpected_tool_name"
-  | "schema_mismatch";
+  | "schema_mismatch"
+  | "unusable_answers";
 
 interface PoolSelectorAttemptFailure {
   attempt: number;
@@ -493,6 +496,248 @@ export function selectAllPoolCandidates(pool: SelectorPool): SelectedPage[] {
   );
 }
 
+/**
+ * Inclusive noul threshold for TypeSafe pool selection. 0.5 is calibrated
+ * equal yes/no. This sits slightly below that so a plausible candidate is
+ * kept, matching the selector's recall-heavy rule.
+ */
+export const TYPE_SAFE_POOL_KEEP_NOUL = 0.4;
+
+/** Catalog id of the TypeSafe System One provider. */
+const TYPE_SAFE_PROVIDER_ID = "typesafe";
+
+type TypesafeNoulQuestion = {
+  type: "noul";
+  instructions: string;
+  criteria: { yes: string; no: string };
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function noulFromAnswer(answer: unknown): number | undefined {
+  if (typeof answer === "number" && Number.isFinite(answer)) {
+    return answer;
+  }
+  if (
+    isRecord(answer) &&
+    typeof answer.noul === "number" &&
+    Number.isFinite(answer.noul)
+  ) {
+    return answer.noul;
+  }
+  return undefined;
+}
+
+function typesafeCandidateEntries(
+  pool: SelectorPool,
+): Record<string, { slug: Slug; text: string }> {
+  const entries: Record<string, { slug: Slug; text: string }> = {};
+  pool.stable.forEach((candidate, index) => {
+    entries[String(index + 1)] = {
+      slug: candidate.slug,
+      text: candidate.card,
+    };
+  });
+  pool.finder.forEach((candidate, index) => {
+    entries[String(pool.stable.length + index + 1)] = {
+      slug: candidate.slug,
+      text: renderFinderLine(candidate),
+    };
+  });
+  return entries;
+}
+
+function typesafeKeepQuestion(id: string): TypesafeNoulQuestion {
+  return {
+    type: "noul",
+    instructions:
+      `Would the upcoming assistant reply draw on \`candidates.${id}\`? ` +
+      "Lean inclusive. Facts, current task and event state, register, " +
+      "framing, calibration, and relationship texture all count. True when " +
+      "the candidate could plausibly inform the reply.",
+    criteria: {
+      yes: "The reply would draw on this candidate.",
+      no: "The reply would not draw on this candidate.",
+    },
+  };
+}
+
+function answersFromSelectorResponse(
+  response: ProviderResponse,
+): Record<string, unknown> | null {
+  const raw = response.rawResponse;
+  if (isRecord(raw) && isRecord(raw.answers)) {
+    return raw.answers;
+  }
+  const textBlock = response.content.find((block) => block.type === "text");
+  if (!textBlock || textBlock.type !== "text") {
+    return null;
+  }
+  try {
+    const parsed: unknown = JSON.parse(textBlock.text);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function selectPoolWithTypesafe(
+  pool: SelectorPool,
+  turn: MemoryRoutingTurn,
+  ordered: PoolLine[],
+  systemPrompt: string,
+  provider: Provider,
+): Promise<PoolSelection> {
+  const candidates = typesafeCandidateEntries(pool);
+  const questions: Record<string, TypesafeNoulQuestion> = {};
+  for (const id of Object.keys(candidates)) {
+    questions[id] = typesafeKeepQuestion(id);
+  }
+  const state = {
+    selector_instructions: systemPrompt,
+    candidates,
+    ...(turn.situationalContext
+      ? { situation: turn.situationalContext }
+      : {}),
+    recent_context: turn.recentContext,
+    current_message: turn.currentMessage,
+  };
+  const userMsg: Message = {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ state, questions }),
+      },
+    ],
+  };
+
+  const failures: PoolSelectorAttemptFailure[] = [];
+  let attempt = 0;
+  const recordFailure = (
+    failure: Omit<
+      PoolSelectorAttemptFailure,
+      | "callSite"
+      | "providerName"
+      | "candidateCount"
+      | "stableCount"
+      | "finderCount"
+    >,
+  ): void => {
+    const diagnostic: PoolSelectorAttemptFailure = {
+      ...failure,
+      callSite: MEMORY_V3_SELECT_CALL_SITE,
+      providerName: provider.name,
+      candidateCount: ordered.length,
+      stableCount: pool.stable.length,
+      finderCount: pool.finder.length,
+    };
+    failures.push(diagnostic);
+    log.warn(diagnostic, "pool selector attempt failed");
+  };
+
+  let lastError: unknown = null;
+  const parsed = await retryForResult(async () => {
+    attempt += 1;
+    let response: Awaited<ReturnType<typeof provider.sendMessage>>;
+    try {
+      response = await provider.sendMessage([userMsg], {
+        config: {
+          callSite: MEMORY_V3_SELECT_CALL_SITE,
+          conversationId: turn.conversationId,
+          disableTurnStartCache: true,
+        },
+      });
+      lastError = null;
+    } catch (error) {
+      lastError = error;
+      recordFailure({
+        attempt,
+        reason: "provider_error",
+        error: summarizeError(error),
+      });
+      throw error;
+    }
+    const answers = answersFromSelectorResponse(response);
+    if (!answers) {
+      recordFailure({
+        attempt,
+        reason: "unusable_answers",
+        response: summarizeResponse(response),
+      });
+      return null;
+    }
+    const picked: number[] = [];
+    let parsedCount = 0;
+    for (let index = 0; index < ordered.length; index++) {
+      const noul = noulFromAnswer(answers[String(index + 1)]);
+      if (noul === undefined) {
+        continue;
+      }
+      parsedCount += 1;
+      if (noul >= TYPE_SAFE_POOL_KEEP_NOUL) {
+        picked.push(index);
+      }
+    }
+    if (parsedCount === 0) {
+      recordFailure({
+        attempt,
+        reason: "unusable_answers",
+        response: summarizeResponse(response),
+      });
+      return null;
+    }
+    return { pages: mergeSelectedLines(ordered, picked), keptAll: false };
+  });
+
+  if (parsed === null) {
+    if (lastError !== null) {
+      const detail =
+        lastError instanceof Error ? lastError.message : String(lastError);
+      const redactedDetail = truncate(
+        redactLogString(detail),
+        ERROR_MESSAGE_MAX_CHARS,
+      );
+      log.warn(
+        {
+          candidateCount: ordered.length,
+          stableCount: pool.stable.length,
+          finderCount: pool.finder.length,
+          callSite: MEMORY_V3_SELECT_CALL_SITE,
+          providerName: provider.name,
+          failures,
+        },
+        "pool selector provider call failed after retries",
+      );
+      throw new MemoryV3RetrievalUnavailableError(
+        `memory-v3 pool selector provider call failed after retries: ${redactedDetail}`,
+        {
+          cause: lastError,
+          conversationNotice: providerBillingNoticeFromError(lastError),
+        },
+      );
+    }
+    log.warn(
+      {
+        candidateCount: ordered.length,
+        stableCount: pool.stable.length,
+        finderCount: pool.finder.length,
+        callSite: MEMORY_V3_SELECT_CALL_SITE,
+        providerName: provider.name,
+        failures,
+      },
+      "pool selector returned no usable TypeSafe answers after retries",
+    );
+    throw new MemoryV3RetrievalUnavailableError(
+      "memory-v3 pool selector returned no usable selection after retries",
+    );
+  }
+
+  return parsed;
+}
+
 /** A selection plus whether it came from the recall-safe keep-all fallback. */
 export interface PoolSelection {
   pages: SelectedPage[];
@@ -504,14 +749,16 @@ export interface PoolSelection {
 }
 
 /**
- * Run the single forced-tool selector over the unified candidate pool. Returns
+ * Run the single selector over the unified candidate pool. Returns
  * the pages to inject, merged per slug (a page selected as a card and on
  * finder lines yields one entry carrying every selected section), plus a
  * `keptAll` flag marking the recall-safe fallback.
  *
- * An omitted `ids` keeps ALL candidates (the recall-safe "all of these are
- * relevant" signal, `keptAll: true`); an explicit `[]` keeps none; an
- * infrastructure failure (after a short re-prompt retry) throws
+ * On a chat model, an omitted `ids` keeps ALL candidates (the recall-safe
+ * "all of these are relevant" signal, `keptAll: true`); an explicit `[]`
+ * keeps none. TypeSafe answers one noul per candidate and never omits ids,
+ * so `keptAll` is always false on that path. An infrastructure failure
+ * (after a short re-prompt retry) throws
  * {@link MemoryV3RetrievalUnavailableError}, and the orchestrator keeps the
  * stable prefix unjudged in its place.
  *
@@ -545,6 +792,16 @@ export async function selectPool(
     );
   }
 
+  if (provider.name === TYPE_SAFE_PROVIDER_ID) {
+    return selectPoolWithTypesafe(
+      pool,
+      turn,
+      ordered,
+      systemPrompt,
+      provider,
+    );
+  }
+
   // Two content blocks: the stable prefix (cards) carries the cache
   // breakpoint; the dynamic tail (finder lines + per-turn context) does not.
   // See the module doc for the cache contract.

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

@@ -206,7 +206,7 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
-  jev: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+  typesafe: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new JevProvider(apiKey, model, {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),

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

@@ -5,6 +5,7 @@ import {
   conversationToState,
   DEFAULT_JEV_MODEL,
   JevProvider,
+  noulFromAnswer,
   parseSystemOneOverride,
   validateJevApiKey,
 } from "./client.js";
@@ -66,6 +67,15 @@ describe("parseSystemOneOverride", () => {
   });
 });
 
+describe("noulFromAnswer", () => {
+  test("reads a typed noul object or a bare number", () => {
+    expect(noulFromAnswer({ type: "noul", noul: 0.91 })).toBe(0.91);
+    expect(noulFromAnswer(0.4)).toBe(0.4);
+    expect(noulFromAnswer({ type: "choice", choice: "keep" })).toBeUndefined();
+    expect(noulFromAnswer(null)).toBeUndefined();
+  });
+});
+
 describe("conversationToState", () => {
   test("flattens system prompt and turns into a string", () => {
     const state = conversationToState(

package/src/providers/jev/client.ts

@@ -15,7 +15,7 @@ import type {
 
 const log = getLogger("jev-client");
 
-export const JEV_PROVIDER_ID = "jev";
+export const JEV_PROVIDER_ID = "typesafe";
 export const DEFAULT_JEV_BASE_URL = "https://api.typesafe.ai";
 export const DEFAULT_JEV_MODEL = "jev-latest";
 
@@ -115,6 +115,21 @@ function isJevQuestions(value: unknown): value is JevQuestions {
   return entries.every(([, question]) => isJevQuestion(question));
 }
 
+/** Calibrated P(yes) from a System One noul answer, or undefined when absent. */
+export function noulFromAnswer(answer: unknown): number | undefined {
+  if (typeof answer === "number" && Number.isFinite(answer)) {
+    return answer;
+  }
+  if (
+    isRecord(answer) &&
+    typeof answer.noul === "number" &&
+    Number.isFinite(answer.noul)
+  ) {
+    return answer.noul;
+  }
+  return undefined;
+}
+
 /**
  * If the last user message is a TypeSafe System One payload, use it as the
  * evaluation request. `state` is optional; callers fall back to the

package/src/providers/model-catalog.ts

@@ -77,7 +77,8 @@ export interface CatalogModel {
    * Whether the model produces free-form chat text. Omit (or true) for
    * ordinary chat models. False for structured-decision models that return
    * answers rather than generated text; those stay out of conversation
-   * pickers and cannot be the conversation model.
+   * pickers and cannot be the conversation model. They can still back a
+   * saved profile and a call-site pin.
    */
   supportsText?: boolean;
   supportsEffort?: boolean;
@@ -2532,8 +2533,8 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyPlaceholder: "Your Poolside API key",
   },
   {
-    id: "jev",
-    displayName: "Jev",
+    id: "typesafe",
+    displayName: "TypeSafe",
     subtitle:
       "TypeSafe System One decision model. Returns structured answers, not generated text. Requires a TypeSafe API key.",
     setupMode: "api-key",

package/src/runtime/routes/__tests__/inference-profiles-routes.test.ts

@@ -927,7 +927,7 @@ describe("PUT inference/active-profile validation", () => {
       profiles: {
         jev: {
           source: "user",
-          provider: "jev",
+          provider: "typesafe",
           model: "jev-latest",
           status: "active",
         },

package/src/runtime/routes/secret-routes.ts

@@ -303,7 +303,7 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           );
           return { success: false, error: validation.reason };
         }
-      } else if (name === "jev") {
+      } else if (name === "typesafe") {
         const validation = await validateJevApiKey(value);
         if (!validation.valid) {
           log.warn(