@vellumai/assistant 0.12.3 → 0.12.4-staging.2

package/src/__tests__/provider-platform-proxy-integration.test.ts

@@ -191,6 +191,7 @@ const MANAGED_FALLBACK_PROVIDERS: string[] = [
   "openai",
   "fireworks",
   "together",
+  "typesafe",
 ];
 
 function enableManagedProxy() {
@@ -314,28 +315,57 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic, openai, gemini, fireworks, and together", async () => {
+    test("managed bootstrap registers every managed-routable catalog provider", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-      expect(listProviders()).toEqual(
-        expect.arrayContaining([
-          "anthropic",
-          "openai",
-          "gemini",
-          "fireworks",
-          "together",
-        ]),
+      expect([...listProviders()].sort()).toEqual(
+        [...MANAGED_FALLBACK_PROVIDERS].sort(),
       );
-      expect(listProviders()).toHaveLength(5);
-      expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("together")).toBe("managed-proxy");
+      for (const provider of MANAGED_FALLBACK_PROVIDERS) {
+        expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+      }
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
+    test("managed typesafe sends System One through the typesafe proxy path with the assistant key", async () => {
+      enableManagedProxy();
+      mockProviderKeys = {};
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
+
+      const provider = getProvider("typesafe");
+      const originalFetch = globalThis.fetch;
+      let capturedUrl = "";
+      let capturedHeaders: Record<string, string> = {};
+      globalThis.fetch = (async (
+        input: string | URL | Request,
+        init?: RequestInit,
+      ) => {
+        capturedUrl = String(input);
+        capturedHeaders = (init?.headers ?? {}) as Record<string, string>;
+        return new Response(
+          JSON.stringify({
+            model: "jev-latest",
+            answers: {},
+            usage: { input_tokens: 1, output_tokens: 0 },
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        );
+      }) as typeof fetch;
+      try {
+        await provider.sendMessage([userMsg("hello")], {
+          config: { model: "jev-latest" },
+        });
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+
+      expect(capturedUrl).toBe(
+        `${PLATFORM_BASE}/v1/runtime-proxy/typesafe/v1/systemone`,
+      );
+      expect(capturedHeaders.Authorization).toBe(`Bearer ${MANAGED_API_KEY}`);
+    });
+
     test("managed anthropic uses anthropic proxy path", async () => {
       enableManagedProxy();
       mockProviderKeys = {};

package/src/__tests__/retry-fallback-escalation.test.ts

@@ -12,7 +12,9 @@ mock.module("../util/retry.js", () => ({
 import {
   recordFallbackServed,
   resetFallbackBreaker,
+  shouldSkipPrimary,
 } from "../providers/fallback-breaker.js";
+import { malformedToolCallError } from "../providers/malformed-tool-call.js";
 import type {
   Message,
   Provider,
@@ -666,6 +668,26 @@ describe("RetryProvider fallback-route escalation", () => {
     expect(backup.calls()).toBe(1);
   });
 
+  test("malformed tool call exhausts retries → backup serves, breaker stays closed", async () => {
+    const primary = failingProvider("openai", () =>
+      malformedToolCallError("openai", "MALFORMED_FUNCTION_CALL"),
+    );
+    const backup = backupProvider();
+    const route = makeRoute(backup.provider);
+    const wrapped = new RetryProvider(primary.provider, {
+      resolveFallbackRoute: route.resolveFallbackRoute,
+    });
+
+    const result = await wrapped.sendMessage(MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    expect(primary.calls()).toBe(1 + DEFAULT_MAX_RETRIES);
+    expect(backup.calls()).toBe(1);
+    expect(result.model).toBe("backup-model");
+    expect(shouldSkipPrimary({ upstream: "openai" })).toBe(false);
+  });
+
   test("resolveFallbackRoute unset → behavior unchanged (original error rethrown)", async () => {
     const finalError = new ProviderError("Service Unavailable", "openai", 503);
     const primary = failingProvider("openai", () => finalError);

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -55,8 +55,10 @@ afterAll(() => {
   resetDbForTesting();
 });
 
-const TEST_TOKEN = "test-bearer-token-attach";
-const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+// This suite mocks isHttpAuthDisabled() to true, so a request carrying no
+// bearer authenticates through the dev bypass. A bearer that is present is
+// verified against the signing key, which these tests do not set up.
+const AUTH_HEADERS: Record<string, string> = {};
 
 describe("Runtime attachment metadata", () => {
   let server: RuntimeHttpServer;

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -25,6 +25,7 @@ const MANAGED_PROVIDERS = [
   "gemini",
   "fireworks",
   "together",
+  "typesafe",
 ] as const;
 
 let platformBaseUrlOverride: string | undefined;

package/src/__tests__/send-endpoint-busy.test.ts

@@ -302,8 +302,10 @@ function makePendingApprovalConversation(
 // Tests
 // ---------------------------------------------------------------------------
 
-const TEST_TOKEN = "test-bearer-token-send";
-const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+// This suite mocks isHttpAuthDisabled() to true, so a request carrying no
+// bearer authenticates through the dev bypass. A bearer that is present is
+// verified against the signing key, which these tests do not set up.
+const AUTH_HEADERS: Record<string, string> = {};
 
 describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
   let server: RuntimeHttpServer;

package/src/__tests__/steer-on-enqueue-question.test.ts

@@ -1,45 +1,62 @@
 /**
- * Enqueue-steer contract: when a chat message is enqueued while an
- * `ask_question` prompt is open for the same conversation, the user has chosen
- * to move on rather than answer it. `steerOnEnqueuedMessageIfQuestionParked`
- * steers to that message — aborting the parked turn (which settles the open
- * question via its turn-abort signal) and draining the message — instead of
- * stranding it behind a prompt no one will answer.
+ * Enqueue contract for a message typed while an `ask_question` card is open.
  *
- * Only `kind: "question"` interactions trigger the steer; pending confirmations
- * are handled separately by the enqueue path's auto-deny.
+ * The message is read as the answer: `answerParkedQuestionWithEnqueuedMessage`
+ * resolves the parked prompt with the typed text as free text and consumes the
+ * queued message, so the parked turn keeps running and the model reads the
+ * answer once, in the tool result.
+ *
+ * Everything a single free-text answer cannot honestly stand in for falls back
+ * to `steerOnEnqueuedMessageIfQuestionParked`, which supersedes the prompt by
+ * aborting the parked turn and draining the message instead. Confirmations and
+ * secrets are separate interaction kinds and are untouched by both paths.
  */
 import { afterEach, describe, expect, test } from "bun:test";
 
 import type { Conversation } from "../daemon/conversation.js";
+import type { QueuedMessage } from "../daemon/conversation-queue-manager.js";
 import {
   deleteConversation,
   setConversation,
 } from "../daemon/conversation-registry.js";
 import {
+  answerParkedQuestionWithEnqueuedMessage,
   steerOnEnqueuedMessageIfQuestionParked,
   supersedePendingInteractionsOnEnqueue,
 } from "../daemon/handlers/conversations.js";
+import type { QuestionPromptResult } from "../permissions/question-prompter.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 interface ParkedTurn {
   abortCount: () => number;
   fake: { pendingSteerRepair: boolean };
+  /** Queue entries still waiting, by request id. */
+  queuedIds: () => string[];
+  /** Event types emitted through the queued message's own sink. */
+  emittedTypes: () => string[];
+  enqueue: (message: Partial<QueuedMessage> & { requestId: string }) => void;
 }
 
 /**
  * Register a fake conversation whose in-flight turn is parked. The fake exposes
- * just the surface `steerToMessage` touches: a processing flag, a queue whose
- * messages can be looked up and promoted, an abort controller that records
+ * just the surface the enqueue paths touch: a processing flag, a queue that can
+ * be looked up, promoted and removed from, an abort controller that records
  * aborts, and the confirmation-deny hook.
  */
 function registerParkedTurn(id: string): ParkedTurn {
   let abortCount = 0;
+  const emitted: string[] = [];
+  const queue = new Map<string, QueuedMessage>();
   const fake = {
     isProcessing: () => true,
     queue: {
-      findByRequestId: (requestId: string) => ({ requestId }),
-      promoteToHead: (requestId: string) => ({ requestId }),
+      findByRequestId: (requestId: string) => queue.get(requestId),
+      promoteToHead: (requestId: string) => queue.get(requestId),
+    },
+    removeQueuedMessage: (requestId: string) => {
+      const item = queue.get(requestId);
+      queue.delete(requestId);
+      return item;
     },
     pendingSteerRepair: false,
     abortController: {
@@ -51,23 +68,249 @@ function registerParkedTurn(id: string): ParkedTurn {
     denyAllPendingConfirmations: () => {},
   };
   setConversation(id, fake as unknown as Conversation);
-  return { abortCount: () => abortCount, fake };
+  const enqueue = (
+    message: Partial<QueuedMessage> & { requestId: string },
+  ): void => {
+    queue.set(message.requestId, {
+      content: "",
+      attachments: [],
+      onEvent: (event) => {
+        emitted.push(event.type);
+      },
+      sentAt: 0,
+      ...message,
+    } as QueuedMessage);
+  };
+  // Every case needs a queued message to act on; the plain typed reply is the
+  // common one, and cases that need other content re-enqueue over it.
+  enqueue({ requestId: "msg-1", content: "next tuesday works" });
+  return {
+    abortCount: () => abortCount,
+    fake,
+    queuedIds: () => [...queue.keys()],
+    emittedTypes: () => [...emitted],
+    enqueue,
+  };
 }
 
 const registeredRequestIds: string[] = [];
 function registerInteraction(
   conversationId: string,
-  kind: "question" | "confirmation",
-): void {
-  const requestId = `pending-${kind}-${conversationId}`;
-  pendingInteractions.register(requestId, { conversationId, kind });
+  kind: "question" | "confirmation" | "secret",
+  options: { requestId?: string; questionIds?: string[] } = {},
+): { requestId: string; result: () => QuestionPromptResult | undefined } {
+  const requestId =
+    options.requestId ?? `pending-${kind}-${conversationId}-${Date.now()}`;
+  let result: QuestionPromptResult | undefined;
+  const questionIds = options.questionIds ?? ["q1"];
+  pendingInteractions.register(requestId, {
+    conversationId,
+    kind,
+    ...(kind === "question"
+      ? {
+          metadata: {
+            orderedIds: questionIds,
+            optionsById: Object.fromEntries(
+              questionIds.map((id) => [id, ["opt-a"]]),
+            ),
+          },
+          rpcResolve: (value: unknown) => {
+            result = value as QuestionPromptResult;
+          },
+        }
+      : {}),
+  });
   registeredRequestIds.push(requestId);
+  return { requestId, result: () => result };
 }
 
 const QUESTION_CONV = "steer-enqueue-question";
 const CONFIRMATION_CONV = "steer-enqueue-confirmation";
 const NONE_CONV = "steer-enqueue-none";
 
+describe("a typed reply answers a parked question", () => {
+  afterEach(() => {
+    for (const id of registeredRequestIds) {
+      pendingInteractions.resolve(id, "cancelled");
+    }
+    registeredRequestIds.length = 0;
+    deleteConversation(QUESTION_CONV);
+    deleteConversation(CONFIRMATION_CONV);
+    deleteConversation(NONE_CONV);
+  });
+
+  test("resolves a single parked question with the typed text", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+
+    const answered = answerParkedQuestionWithEnqueuedMessage(
+      QUESTION_CONV,
+      "msg-1",
+    );
+
+    expect(answered).toBe(true);
+    expect(question.result()).toEqual({
+      entries: [
+        { questionId: "q1", decision: "free_text", text: "next tuesday works" },
+      ],
+      overall: "completed",
+      answeredInChat: true,
+    });
+    // The parked turn keeps running: no abort, no tool-result repair.
+    expect(conv.abortCount()).toBe(0);
+    expect(conv.fake.pendingSteerRepair).toBe(false);
+    // The message reaches the model through the tool result, so it is consumed
+    // rather than run as a turn of its own, and the client's queued row is
+    // retired the way a queue delete retires it.
+    expect(conv.queuedIds()).toEqual([]);
+    expect(conv.emittedTypes()).toEqual(["message_queued_deleted"]);
+  });
+
+  test("answers the first question of a batch and leaves the rest unanswered", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question", {
+      questionIds: ["q1", "q2", "q3"],
+    });
+
+    const answered = answerParkedQuestionWithEnqueuedMessage(
+      QUESTION_CONV,
+      "msg-1",
+    );
+
+    expect(answered).toBe(true);
+    expect(question.result()).toEqual({
+      entries: [
+        { questionId: "q1", decision: "free_text", text: "next tuesday works" },
+        { questionId: "q2", decision: "skipped" },
+        { questionId: "q3", decision: "skipped" },
+      ],
+      overall: "completed",
+      answeredInChat: true,
+    });
+    expect(conv.abortCount()).toBe(0);
+  });
+
+  test("supersedes instead when the message carries an attachment", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({
+      requestId: "msg-1",
+      content: "here it is",
+      attachments: [
+        {
+          id: "att-1",
+          filename: "notes.txt",
+          mimeType: "text/plain",
+          data: "",
+        },
+      ],
+    });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+    expect(conv.queuedIds()).toEqual(["msg-1"]);
+  });
+
+  test("supersedes instead when the message is a slash command", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({ requestId: "msg-1", content: "/compact" });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("supersedes instead when the message is blank", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({ requestId: "msg-1", content: "   " });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("supersedes instead when the send is automated rather than typed", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const question = registerInteraction(QUESTION_CONV, "question");
+    conv.enqueue({
+      requestId: "msg-1",
+      content: "scheduled follow-up",
+      metadata: { automated: true },
+    });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("supersedes instead when two questions are parked at once", () => {
+    // Which prompt the text answers would be a guess, so the old behavior
+    // stands: abort the turn and run the message as its own turn.
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const first = registerInteraction(QUESTION_CONV, "question", {
+      requestId: "question-a",
+    });
+    const second = registerInteraction(QUESTION_CONV, "question", {
+      requestId: "question-b",
+    });
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(first.result()).toBeUndefined();
+    expect(second.result()).toBeUndefined();
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("leaves a parked secret alone while answering the question", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    const secret = registerInteraction(QUESTION_CONV, "secret");
+    const question = registerInteraction(QUESTION_CONV, "question");
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(question.result()?.overall).toBe("completed");
+    expect(conv.abortCount()).toBe(0);
+    expect(pendingInteractions.get(secret.requestId)?.kind).toBe("secret");
+  });
+
+  test("does not answer from a pending confirmation (not a question)", () => {
+    const conv = registerParkedTurn(CONFIRMATION_CONV);
+    registerInteraction(CONFIRMATION_CONV, "confirmation");
+
+    const answered = answerParkedQuestionWithEnqueuedMessage(
+      CONFIRMATION_CONV,
+      "msg-1",
+    );
+    const steered = steerOnEnqueuedMessageIfQuestionParked(
+      CONFIRMATION_CONV,
+      "msg-1",
+    );
+
+    expect(answered).toBe(false);
+    expect(steered).toBe(false);
+    expect(conv.abortCount()).toBe(0);
+    // The message is left on the queue to run as its own turn.
+    expect(conv.queuedIds()).toEqual(["msg-1"]);
+  });
+
+  test("does nothing when no prompt is parked", () => {
+    const conv = registerParkedTurn(NONE_CONV);
+
+    supersedePendingInteractionsOnEnqueue(NONE_CONV, "msg-1");
+
+    expect(conv.abortCount()).toBe(0);
+    expect(conv.queuedIds()).toEqual(["msg-1"]);
+    expect(conv.emittedTypes()).toEqual([]);
+  });
+});
+
 describe("steerOnEnqueuedMessageIfQuestionParked", () => {
   afterEach(() => {
     for (const id of registeredRequestIds) {
@@ -134,27 +377,15 @@ describe("steerOnEnqueuedMessageIfQuestionParked", () => {
     expect(steered).toBe(false);
     expect(conv.abortCount()).toBe(0);
   });
-
-  test("supersedePendingInteractionsOnEnqueue steers a parked question", () => {
-    // The centralized routine is invoked by both the HTTP send handler and the
-    // CLI signal path. With no pending confirmation it steers a parked question
-    // — the behavior the CLI signal path previously lacked.
-    const conv = registerParkedTurn(QUESTION_CONV);
-    registerInteraction(QUESTION_CONV, "question");
-
-    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
-
-    expect(conv.abortCount()).toBe(1);
-    expect(conv.fake.pendingSteerRepair).toBe(true);
-  });
 });
 
 describe("removeByConversation preserves question interactions", () => {
   // The enqueue path's confirmation auto-deny calls removeByConversation before
-  // the steer runs. Questions must survive it — they are settled instead by the
-  // steer's turn abort — or, when an ask_question and a confirmation are pending
-  // concurrently, the queued message would strand behind a question whose entry
-  // was cleared (and whose Promise was never settled) before the steer fired.
+  // the question is answered or steered to. Questions must survive it (they
+  // are settled instead by the answer or by the steer's turn abort) or, when
+  // an ask_question and a confirmation are pending concurrently, the queued
+  // message would strand behind a question whose entry was cleared (and whose
+  // Promise was never settled) before either path fired.
   const CONV = "remove-by-conv-preserve-question";
   const ids: string[] = [];
   function register(kind: "question" | "confirmation"): void {