@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

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 {

package/src/__tests__/validate-input.test.ts

@@ -6,6 +6,79 @@ import {
   validateInputAgainstSchema,
 } from "../skills/validate-input.js";
 
+describe("nested input validation", () => {
+  const schema = {
+    properties: {
+      options: {
+        type: "object",
+        properties: { label: { type: "string" } },
+        required: ["label"],
+      },
+    },
+  };
+
+  test("reports nested required fields and types with their path", () => {
+    expect(
+      validateInputAgainstSchema("example", { options: {} }, schema),
+    ).toEqual({
+      ok: false,
+      errors: ["options.label is required"],
+    });
+    expect(
+      validateInputAgainstSchema("example", { options: { label: 42 } }, schema),
+    ).toEqual({
+      ok: false,
+      errors: ["options.label must be a string"],
+    });
+  });
+
+  test("preserves open nested objects and only rejects explicitly closed extra fields", () => {
+    const input = { options: { label: "Example", extra: true } };
+    expect(validateInputAgainstSchema("example", input, schema)).toEqual({
+      ok: true,
+    });
+    expect(
+      validateInputAgainstSchema("example", input, {
+        properties: {
+          options: {
+            ...schema.properties.options,
+            additionalProperties: false,
+          },
+        },
+      }),
+    ).toEqual({
+      ok: false,
+      errors: ['Unknown parameter "options.extra". Supported: "label"'],
+    });
+  });
+
+  test("does not treat a richer oneOf as a presence-only union", () => {
+    expect(
+      validateInputAgainstSchema(
+        "example",
+        { options: { label: "Example" } },
+        {
+          properties: {
+            options: {
+              ...schema.properties.options,
+              oneOf: [
+                {
+                  required: ["label"],
+                  properties: { label: { const: "Example" } },
+                },
+                {
+                  required: ["label"],
+                  properties: { label: { const: "Other" } },
+                },
+              ],
+            },
+          },
+        },
+      ),
+    ).toEqual({ ok: true });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // required
 // ---------------------------------------------------------------------------

package/src/__tests__/workspace-migration-159-rename-colliding-jev-profile-name.test.ts

@@ -0,0 +1,197 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const migration = WORKSPACE_MIGRATIONS.find(
+  (entry) => entry.id === "159-rename-colliding-jev-profile-name",
+)!;
+
+let workspaceDir: string;
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, any> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function seedProfilePinTables(rows: {
+  conversations: string[];
+  cronJobs: string[];
+}): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(
+    `CREATE TABLE conversations (id TEXT PRIMARY KEY, inference_profile TEXT)`,
+  );
+  db.run(
+    `CREATE TABLE cron_jobs (id TEXT PRIMARY KEY, inference_profile TEXT)`,
+  );
+  rows.conversations.forEach((profile, index) => {
+    db.query(
+      `INSERT INTO conversations (id, inference_profile) VALUES (?, ?)`,
+    ).run(`conv-${index}`, profile);
+  });
+  rows.cronJobs.forEach((profile, index) => {
+    db.query(`INSERT INTO cron_jobs (id, inference_profile) VALUES (?, ?)`).run(
+      `job-${index}`,
+      profile,
+    );
+  });
+  db.close();
+}
+
+function readPins(table: string): string[] {
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  try {
+    return (
+      db
+        .query(`SELECT inference_profile AS p FROM ${table} ORDER BY id`)
+        .all() as Array<{ p: string }>
+    ).map((row) => row.p);
+  } finally {
+    db.close();
+  }
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-159-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("159-rename-colliding-jev-profile-name migration", () => {
+  test("is registered under its id with checkpoint retry", () => {
+    expect(migration).toBeDefined();
+    expect(migration.retryFailedCheckpoint).toBe(true);
+  });
+
+  test("renames a colliding user profile and rewrites every reference", async () => {
+    writeConfig({
+      llm: {
+        defaultProvider: { provider: "vellum" },
+        profiles: {
+          "jev-managed": {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            label: "Mine",
+          },
+          scratch: { source: "user", fallbackProfile: "jev-managed" },
+          armA: { source: "user", speed: "fast" },
+          blend: {
+            source: "user",
+            mix: [
+              { profile: "jev-managed", weight: 1 },
+              { profile: "armA", weight: 1 },
+            ],
+          },
+        },
+        profileOrder: ["balanced", "jev-managed", "blend"],
+        activeProfile: "jev-managed",
+        advisorProfile: "jev-managed",
+        callSites: { recall: { profile: "jev-managed", maxTokens: 4096 } },
+      },
+    });
+    seedProfilePinTables({
+      conversations: ["jev-managed", "balanced"],
+      cronJobs: ["jev-managed"],
+    });
+
+    await migration.run(workspaceDir);
+
+    const llm = readConfig().llm;
+    expect(llm.profiles["jev-managed"]).toBeUndefined();
+    expect(llm.profiles["jev-managed-custom"]).toEqual({
+      source: "user",
+      provider: "anthropic",
+      model: "claude-opus-4-7",
+      label: "Mine",
+    });
+    expect(Object.keys(llm.profiles)).toEqual([
+      "jev-managed-custom",
+      "scratch",
+      "armA",
+      "blend",
+    ]);
+    expect(llm.activeProfile).toBe("jev-managed-custom");
+    expect(llm.advisorProfile).toBe("jev-managed-custom");
+    expect(llm.profileOrder).toEqual([
+      "balanced",
+      "jev-managed-custom",
+      "blend",
+    ]);
+    expect(llm.callSites.recall.profile).toBe("jev-managed-custom");
+    expect(llm.profiles.scratch.fallbackProfile).toBe("jev-managed-custom");
+    expect(llm.profiles.blend.mix[0].profile).toBe("jev-managed-custom");
+    expect(readPins("conversations")).toEqual([
+      "jev-managed-custom",
+      "balanced",
+    ]);
+    expect(readPins("cron_jobs")).toEqual(["jev-managed-custom"]);
+  });
+
+  test("keeps suffixing past taken and reserved names", async () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "jev-managed": {
+            source: "user",
+            provider: "openai",
+            model: "gpt-5.5",
+          },
+          "jev-managed-custom": { source: "user", provider: "openai" },
+        },
+      },
+    });
+
+    await migration.run(workspaceDir);
+
+    const keys = Object.keys(readConfig().llm.profiles);
+    expect(keys).toEqual(["jev-managed-custom-2", "jev-managed-custom"]);
+  });
+
+  test("leaves a managed stub alone and is idempotent", async () => {
+    const original = {
+      llm: {
+        profiles: {
+          "jev-managed": { source: "managed", status: "disabled" },
+          balanced: { source: "managed" },
+        },
+      },
+    };
+    writeConfig(original);
+
+    await migration.run(workspaceDir);
+    await migration.run(workspaceDir);
+
+    expect(readConfig()).toEqual(original);
+    expect(existsSync(join(workspaceDir, "data", "db", "assistant.db"))).toBe(
+      false,
+    );
+  });
+});

package/src/api/ask-question-tool.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+/**
+ * The `ask_question` tool's input as a recorded call carries it, for a client
+ * reading one back.
+ *
+ * The tool's own schema (`askQuestionInputSchema`) is the authority on what a
+ * model may send: it caps the batch, bounds the options, carries the
+ * descriptions the model reads, and refuses a call that passes both shapes.
+ * This one only has to read what was already accepted, so it validates the
+ * shape and nothing else, and tolerates a recorded call from an assistant
+ * whose bounds differed.
+ *
+ * Both shapes are here because both are what was asked. `desktopHelp` becomes
+ * a one-question prompt inside the daemon, so a reader that only understood
+ * `questions` would have nothing to show for a recorded desktop-help call.
+ *
+ * Structured records win where they exist: the answered record a settled
+ * prompt carries (`AnsweredQuestion`) and the live entries an outstanding one
+ * has. This is the fallback for a call that has neither, which is any prompt
+ * recorded before those records existed, one that timed out, and one whose
+ * outstanding entries a reload could not tie back to it.
+ */
+
+const RecordedQuestionOptionSchema = z.looseObject({
+  id: z.string().optional().catch(undefined),
+  label: z.string(),
+  description: z.string().optional().catch(undefined),
+});
+
+const RecordedQuestionSchema = z.looseObject({
+  question: z.string(),
+  description: z.string().optional().catch(undefined),
+  options: z.array(RecordedQuestionOptionSchema).optional().catch(undefined),
+});
+
+export const AskQuestionInputSchema = z.looseObject({
+  questions: z.array(RecordedQuestionSchema).optional().catch(undefined),
+  desktopHelp: z
+    .looseObject({
+      message: z.string(),
+      doneLabel: z.string().optional().catch(undefined),
+      skipLabel: z.string().optional().catch(undefined),
+    })
+    .optional()
+    .catch(undefined),
+});
+
+export type AskQuestionInput = z.infer<typeof AskQuestionInputSchema>;
+export type RecordedQuestion = z.infer<typeof RecordedQuestionSchema>;