@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/config/__tests__/platform-identity.test.ts

@@ -1,117 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import {
-  setPlatformAssistantId,
-  setPlatformOrganizationId,
-  setPlatformUserId,
-} from "../env.js";
-import {
-  fetchPlatformIdentityIds,
-  PLATFORM_IDENTITY_VALIDATE_PATH,
-  resolvePlatformAssistantId,
-} from "../platform-identity.js";
-
-const BASE_URL = "https://platform.vellum.ai";
-const ASSISTANT_ID = "11111111-2222-4333-8444-555555555555";
-const ORG_ID = "22222222-3333-4444-8555-666666666666";
-const USER_ID = "33333333-4444-4555-8666-777777777777";
-
-describe("fetchPlatformIdentityIds", () => {
-  const originalFetch = globalThis.fetch;
-  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
-  let fetchImpl: (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ) => Promise<Response> = async () =>
-    new Response("not found", { status: 404 });
-
-  beforeEach(() => {
-    fetchCalls.length = 0;
-    fetchImpl = async () => new Response("not found", { status: 404 });
-    globalThis.fetch = (async (
-      input: RequestInfo | URL,
-      init?: RequestInit,
-    ) => {
-      const url = typeof input === "string" ? input : input.toString();
-      fetchCalls.push({ url, init });
-      return fetchImpl(input, init);
-    }) as unknown as typeof fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  test("returns the three ids from a successful validate response", async () => {
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-          name: "Example Assistant",
-        }),
-        { status: 200 },
-      );
-
-    await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
-    ).resolves.toEqual({
-      assistantId: ASSISTANT_ID,
-      organizationId: ORG_ID,
-      userId: USER_ID,
-    });
-    expect(fetchCalls[0]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
-    );
-    expect(fetchCalls[0]?.init?.method).toBe("POST");
-    const headers = new Headers(fetchCalls[0]?.init?.headers);
-    expect(headers.get("Authorization")).toBe("Api-Key assistant-key");
-  });
-
-  test("strips a trailing slash from the base URL", async () => {
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      );
-
-    await fetchPlatformIdentityIds(`${BASE_URL}/`, "assistant-key");
-    expect(fetchCalls[0]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
-    );
-  });
-
-  test("returns null on 401 without throwing", async () => {
-    fetchImpl = async () => new Response("no", { status: 401 });
-    await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
-    ).resolves.toBeNull();
-  });
-
-  test("returns null on a network error without throwing", async () => {
-    fetchImpl = async () => {
-      throw new Error("network down");
-    };
-    await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
-    ).resolves.toBeNull();
-  });
-});
-
-describe("resolvePlatformAssistantId", () => {
-  afterEach(() => {
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-  });
-
-  test("returns the in-memory override", async () => {
-    setPlatformAssistantId(ASSISTANT_ID);
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
-  });
-});

package/src/config/acp-agent-write.ts

@@ -1,43 +0,0 @@
-/**
- * Raw-config helper shared by the config PATCH and SET routes, the paths that
- * write a coding agent's entry.
- */
-
-import { isPlainObject } from "../util/object.js";
-
-/**
- * Clearing a leaf of a coding agent's entry is a write of `null` - a PATCH of
- * `{ acp: { agents: { <id>: { model: null } } } }` or a
- * `config set acp.agents.<id>.model null`. The deep-merge assigns that literal
- * `null` because the stored value is a scalar, and a SET writes it verbatim by
- * design. Both `command` and `model` are optional strings in `AcpConfigSchema`,
- * so a persisted `null` makes every later `loadConfig()` warn and take its
- * salvage path, dropping the whole `acp` section with the agents defined in it.
- * Clearing means removing the key, so drop it here on every write path.
- *
- * A cleared `command` then reads as an omitted one: a bundled id inherits the
- * profile's command, and an id that has no profile fails the agents refinement
- * with a message naming the id, which tells the user more than zod's "expected
- * string, received null".
- */
-export function scrubNulledAcpAgentLeaves(raw: Record<string, unknown>): void {
-  const acp = raw.acp;
-  if (!isPlainObject(acp)) {
-    return;
-  }
-  const agents = acp.agents;
-  if (!isPlainObject(agents)) {
-    return;
-  }
-  for (const entry of Object.values(agents)) {
-    if (!isPlainObject(entry)) {
-      continue;
-    }
-    if (entry.command === null) {
-      delete entry.command;
-    }
-    if (entry.model === null) {
-      delete entry.model;
-    }
-  }
-}

package/src/config/acp-schema.test.ts

@@ -1,81 +0,0 @@
-/**
- * Covers the ACP config leaf that carries model selection, the per-agent
- * `model`. It is optional with no `.default()`, so an absent value must stay
- * absent after parsing: the bundled profile supplies the model a session
- * starts on, and a key materialized as `undefined` would shadow it.
- *
- * `command` is optional in the same shape, so an entry for a bundled id can
- * carry a model and nothing else; the record's own check keeps a command
- * required for every id that has no bundled profile to inherit one from.
- */
-
-import { describe, expect, test } from "bun:test";
-
-import { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
-
-describe("AcpConfigSchema", () => {
-  test("populates defaults for an empty config", () => {
-    expect(AcpConfigSchema.parse({})).toEqual({
-      maxConcurrentSessions: 4,
-      agents: {},
-    });
-  });
-});
-
-describe("AcpConfigSchema agents", () => {
-  test("a bundled id's entry may omit command and name only a model", () => {
-    const parsed = AcpConfigSchema.parse({
-      agents: { claude: { model: "sonnet" } },
-    });
-
-    expect(parsed.agents).toEqual({ claude: { args: [], model: "sonnet" } });
-    expect("command" in parsed.agents.claude!).toBe(false);
-  });
-
-  test("an id with no bundled profile needs a command", () => {
-    const result = AcpConfigSchema.safeParse({
-      agents: { mine: { model: "sonnet" } },
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      return;
-    }
-    expect(result.error.issues.map((issue) => issue.path)).toEqual([
-      ["agents", "mine", "command"],
-    ]);
-    expect(result.error.issues[0]?.message).toContain("acp.agents.mine");
-  });
-
-  test("an id naming an Object.prototype member inherits no command", () => {
-    expect(
-      AcpConfigSchema.safeParse({ agents: { constructor: { model: "x" } } })
-        .success,
-    ).toBe(false);
-  });
-});
-
-describe("AcpAgentConfigSchema", () => {
-  test("round-trips a per-agent model override", () => {
-    expect(
-      AcpAgentConfigSchema.parse({
-        command: "claude-agent-acp",
-        model: "opus",
-      }),
-    ).toEqual({ command: "claude-agent-acp", args: [], model: "opus" });
-  });
-
-  test("leaves model unset when omitted, so a bundled profile's shows through", () => {
-    const parsed = AcpAgentConfigSchema.parse({ command: "claude-agent-acp" });
-
-    expect(parsed.model).toBeUndefined();
-    expect("model" in parsed).toBe(false);
-  });
-
-  test("rejects a non-string model", () => {
-    expect(
-      AcpAgentConfigSchema.safeParse({ command: "claude-agent-acp", model: 3 })
-        .success,
-    ).toBe(false);
-  });
-});

package/src/config/platform-identity.ts

@@ -1,144 +0,0 @@
-/**
- * Bound platform identity (assistant, organization, user).
- *
- * Django maps an assistant API key to these ids via
- * `POST /v1/internal/assistants/validate/`. Process startup rehydrates from
- * that endpoint. Resolution prefers the in-memory ids, then the vault
- * copies of `vellum:platform_*`.
- */
-
-import { credentialKey } from "../security/credential-key.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
-import { getLogger } from "../util/logger.js";
-import {
-  getPlatformAssistantId,
-  getPlatformOrganizationId,
-  getPlatformUserId,
-  setPlatformAssistantId,
-  setPlatformOrganizationId,
-  setPlatformUserId,
-} from "./env.js";
-
-const log = getLogger("platform-identity");
-
-export const PLATFORM_IDENTITY_VALIDATE_PATH =
-  "/v1/internal/assistants/validate/";
-
-const VALIDATE_TIMEOUT_MS = 5_000;
-
-export type PlatformIdentityIds = {
-  assistantId: string;
-  organizationId: string;
-  userId: string;
-};
-
-function asNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-export function applyPlatformIdentityIds(ids: PlatformIdentityIds): void {
-  if (ids.assistantId) {
-    setPlatformAssistantId(ids.assistantId);
-  }
-  if (ids.organizationId) {
-    setPlatformOrganizationId(ids.organizationId);
-  }
-  if (ids.userId) {
-    setPlatformUserId(ids.userId);
-  }
-}
-
-/**
- * Trade an assistant API key for the bound platform ids.
- *
- * Returns null when the platform is unreachable, refuses the key, or the
- * body has no ids. Never throws.
- */
-export async function fetchPlatformIdentityIds(
-  baseUrl: string,
-  apiKey: string,
-): Promise<PlatformIdentityIds | null> {
-  const url = `${baseUrl.replace(/\/+$/, "")}${PLATFORM_IDENTITY_VALIDATE_PATH}`;
-  try {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Api-Key ${apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: "{}",
-      signal: AbortSignal.timeout(VALIDATE_TIMEOUT_MS),
-    });
-    if (!res.ok) {
-      log.warn(
-        { status: res.status },
-        "platform identity validate returned non-2xx",
-      );
-      return null;
-    }
-    const body: unknown = await res.json();
-    if (!body || typeof body !== "object") {
-      return null;
-    }
-    const obj = body as Record<string, unknown>;
-    const assistantId = asNonEmptyString(obj.assistant_id);
-    const organizationId = asNonEmptyString(obj.organization_id);
-    const userId = asNonEmptyString(obj.user_id);
-    if (!assistantId && !organizationId && !userId) {
-      return null;
-    }
-    return {
-      assistantId: assistantId ?? "",
-      organizationId: organizationId ?? "",
-      userId: userId ?? "",
-    };
-  } catch (err) {
-    log.warn({ err }, "platform identity validate failed");
-    return null;
-  }
-}
-
-async function readVaultField(field: string): Promise<string> {
-  try {
-    return (
-      (await getSecureKeyAsync(credentialKey("vellum", field)))?.trim() ?? ""
-    );
-  } catch (err) {
-    log.warn(
-      { err, field },
-      "failed to read platform identity from credential store",
-    );
-    return "";
-  }
-}
-
-export async function resolvePlatformAssistantId(): Promise<string> {
-  return (
-    getPlatformAssistantId().trim() ||
-    (await readVaultField("platform_assistant_id"))
-  );
-}
-
-export async function resolvePlatformAssistantIdOrNull(): Promise<
-  string | null
-> {
-  const id = await resolvePlatformAssistantId();
-  return id || null;
-}
-
-export async function resolvePlatformOrganizationId(): Promise<string> {
-  return (
-    getPlatformOrganizationId().trim() ||
-    (await readVaultField("platform_organization_id"))
-  );
-}
-
-export async function resolvePlatformUserId(): Promise<string> {
-  return (
-    getPlatformUserId().trim() || (await readVaultField("platform_user_id"))
-  );
-}

package/src/config/schemas/__tests__/voice.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { VoiceConfigSchema, VoiceFrontModelConfigSchema } from "../voice.js";
-
-const PROGRESS_DEFAULTS = {
-  enabled: true,
-  opsThreshold: 3,
-  idleIntervalMs: 5_000,
-  maxSilenceMs: 35_000,
-  longOpMs: 15_000,
-  minGapMs: 6_000,
-  generationTimeoutMs: 1_500,
-};
-
-const FRONT_MODEL_DEFAULTS = {
-  endpointDecisionTimeoutMs: 1200,
-  endpointExtensionMs: 1500,
-  endpointMaxExtensions: 2,
-  progress: PROGRESS_DEFAULTS,
-};
-
-describe("VoiceFrontModelConfigSchema", () => {
-  test("empty object parses to defaults", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({});
-    expect(parsed).toEqual(FRONT_MODEL_DEFAULTS);
-  });
-
-  test("accepts overrides", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      endpointDecisionTimeoutMs: 400,
-      endpointMaxExtensions: 0,
-    });
-    expect(parsed.endpointDecisionTimeoutMs).toBe(400);
-    expect(parsed.endpointMaxExtensions).toBe(0);
-    // Unspecified fields still get defaults
-    expect(parsed.endpointExtensionMs).toBe(1500);
-  });
-
-  test("strips retired generated-ack settings", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      ackFirstDeltaTimeoutMs: 2500,
-      ackGenerationTimeoutMs: 600,
-    });
-    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
-    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
-  });
-
-  test("rejects non-positive endpointDecisionTimeoutMs", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      endpointDecisionTimeoutMs: 0,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects negative endpointMaxExtensions", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      endpointMaxExtensions: -1,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("absent progress namespace parses to full progress defaults", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({});
-    expect(parsed.progress).toEqual(PROGRESS_DEFAULTS);
-  });
-
-  test("partial progress overrides merge with defaults", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      progress: { enabled: false, opsThreshold: 5 },
-    });
-    expect(parsed.progress.enabled).toBe(false);
-    expect(parsed.progress.opsThreshold).toBe(5);
-    // Unspecified progress fields still get defaults
-    expect(parsed.progress.idleIntervalMs).toBe(5_000);
-    expect(parsed.progress.maxSilenceMs).toBe(35_000);
-    expect(parsed.progress.longOpMs).toBe(15_000);
-    expect(parsed.progress.minGapMs).toBe(6_000);
-    expect(parsed.progress.generationTimeoutMs).toBe(1_500);
-  });
-
-  test("a stale maxPerTurn key is stripped, not rejected", () => {
-    // The cap was removed; configs written while it existed must still parse.
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      progress: { maxPerTurn: 3 },
-    });
-    expect("maxPerTurn" in parsed.progress).toBe(false);
-  });
-
-  test("rejects non-positive progress.opsThreshold", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      progress: { opsThreshold: 0 },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects a heartbeat ceiling shorter than the idle tick interval", () => {
-    // The heartbeat is only checked on the idle tick, so a shorter ceiling
-    // could be overshot by a full interval.
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      progress: { idleIntervalMs: 60_000, maxSilenceMs: 10_000 },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((issue) => issue.message);
-      expect(
-        msgs.some((msg) =>
-          msg.includes("voice.frontModel.progress.maxSilenceMs"),
-        ),
-      ).toBe(true);
-    }
-    // The floor itself is allowed: the tick is exactly on the ceiling.
-    expect(
-      VoiceFrontModelConfigSchema.safeParse({
-        progress: { idleIntervalMs: 60_000, maxSilenceMs: 60_000 },
-      }).success,
-    ).toBe(true);
-  });
-
-  test("rejects a non-boolean progress.enabled", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      progress: { enabled: "yes" },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((i) => i.message);
-      expect(
-        msgs.some((m) => m.includes("voice.frontModel.progress.enabled")),
-      ).toBe(true);
-    }
-  });
-});
-
-describe("VoiceConfigSchema", () => {
-  test("empty object parses to front-model defaults", () => {
-    expect(VoiceConfigSchema.parse({})).toEqual({
-      frontModel: FRONT_MODEL_DEFAULTS,
-    });
-  });
-
-  test("partial frontModel overrides merge with defaults", () => {
-    const parsed = VoiceConfigSchema.parse({
-      frontModel: { endpointDecisionTimeoutMs: 300 },
-    });
-    expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
-    expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
-    expect(parsed.frontModel.progress).toEqual(PROGRESS_DEFAULTS);
-  });
-});

package/src/config/schemas/voice.ts

@@ -1,150 +0,0 @@
-import { z } from "zod";
-
-export const VoiceProgressConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({
-        error: "voice.frontModel.progress.enabled must be a boolean",
-      })
-      .default(true)
-      .describe(
-        "Speak short progress updates during long-running tool-heavy turns; the opt-out for progress narration",
-      ),
-    opsThreshold: z
-      .number({
-        error: "voice.frontModel.progress.opsThreshold must be a number",
-      })
-      .int("voice.frontModel.progress.opsThreshold must be an integer")
-      .positive(
-        "voice.frontModel.progress.opsThreshold must be a positive integer",
-      )
-      .default(3)
-      .describe(
-        "Narrate after this many tool operations since the last narration",
-      ),
-    idleIntervalMs: z
-      .number({
-        error: "voice.frontModel.progress.idleIntervalMs must be a number",
-      })
-      .int("voice.frontModel.progress.idleIntervalMs must be an integer")
-      .positive(
-        "voice.frontModel.progress.idleIntervalMs must be a positive integer",
-      )
-      .default(5_000)
-      .describe(
-        "How often (ms) a running turn's silence is checked, and so the soonest new tool activity is narrated",
-      ),
-    maxSilenceMs: z
-      .number({
-        error: "voice.frontModel.progress.maxSilenceMs must be a number",
-      })
-      .int("voice.frontModel.progress.maxSilenceMs must be an integer")
-      .positive(
-        "voice.frontModel.progress.maxSilenceMs must be a positive integer",
-      )
-      .default(35_000)
-      .describe(
-        "Heartbeat ceiling (ms): narrate after this much unbroken silence even when nothing new has happened. Evaluated on the idle tick, so its resolution is idleIntervalMs and it must be at least that long",
-      ),
-    longOpMs: z
-      .number({
-        error: "voice.frontModel.progress.longOpMs must be a number",
-      })
-      .int("voice.frontModel.progress.longOpMs must be an integer")
-      .positive("voice.frontModel.progress.longOpMs must be a positive integer")
-      .default(15_000)
-      .describe(
-        "A tool operation that ran at least this long (ms) narrates the moment it completes, without waiting for opsThreshold",
-      ),
-    minGapMs: z
-      .number({
-        error: "voice.frontModel.progress.minGapMs must be a number",
-      })
-      .int("voice.frontModel.progress.minGapMs must be an integer")
-      .positive("voice.frontModel.progress.minGapMs must be a positive integer")
-      .default(6_000)
-      .describe(
-        "Minimum spacing (ms) from any spoken floor-holder (ack or narration)",
-      ),
-    generationTimeoutMs: z
-      .number({
-        error: "voice.frontModel.progress.generationTimeoutMs must be a number",
-      })
-      .int("voice.frontModel.progress.generationTimeoutMs must be an integer")
-      .positive(
-        "voice.frontModel.progress.generationTimeoutMs must be a positive integer",
-      )
-      .default(1_500)
-      .describe(
-        "Budget (ms) for LLM-generated progress text. Not latency-critical: it speaks into dead air",
-      ),
-  })
-  // The heartbeat is checked when the idle tick finds the turn silent, so a
-  // ceiling shorter than the tick interval would be missed by up to a full
-  // interval, a promise the cadence cannot keep. Rejecting the combination
-  // beats silently overshooting it.
-  .refine((progress) => progress.maxSilenceMs >= progress.idleIntervalMs, {
-    error:
-      "voice.frontModel.progress.maxSilenceMs must be at least idleIntervalMs: the heartbeat is evaluated on the idle tick",
-  })
-  .describe(
-    "Progress-narration tuning for live voice sessions (spoken updates during long-running turns)",
-  );
-
-export const VoiceFrontModelConfigSchema = z
-  .object({
-    endpointDecisionTimeoutMs: z
-      .number({
-        error: "voice.frontModel.endpointDecisionTimeoutMs must be a number",
-      })
-      .int("voice.frontModel.endpointDecisionTimeoutMs must be an integer")
-      .positive(
-        "voice.frontModel.endpointDecisionTimeoutMs must be a positive integer",
-      )
-      .default(1200)
-      .describe(
-        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows. Measured Haiku roundtrips through the managed proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
-      ),
-    endpointExtensionMs: z
-      .number({
-        error: "voice.frontModel.endpointExtensionMs must be a number",
-      })
-      .int("voice.frontModel.endpointExtensionMs must be an integer")
-      .positive(
-        "voice.frontModel.endpointExtensionMs must be a positive integer",
-      )
-      .default(1500)
-      .describe(
-        "How long (ms) a 'hold' decision keeps the turn open before turn-end replays",
-      ),
-    endpointMaxExtensions: z
-      .number({
-        error: "voice.frontModel.endpointMaxExtensions must be a number",
-      })
-      .int("voice.frontModel.endpointMaxExtensions must be an integer")
-      .nonnegative(
-        "voice.frontModel.endpointMaxExtensions must be a nonnegative integer",
-      )
-      .default(2)
-      .describe("Cap on consecutive 'hold' extensions per utterance"),
-    progress: VoiceProgressConfigSchema.default(
-      VoiceProgressConfigSchema.parse({}),
-    ),
-  })
-  .describe(
-    "Voice front-door endpointing and long-turn progress narration tuning, shared by live voice and phone calls",
-  );
-
-export const VoiceConfigSchema = z
-  .object({
-    frontModel: VoiceFrontModelConfigSchema.default(
-      VoiceFrontModelConfigSchema.parse({}),
-    ),
-  })
-  .describe(
-    "Transport-agnostic voice configuration shared by live voice and phone calls: front-door routing and progress narration tuning",
-  );
-
-export type VoiceConfig = z.infer<typeof VoiceConfigSchema>;
-export type VoiceFrontModelConfig = z.infer<typeof VoiceFrontModelConfigSchema>;
-export type VoiceProgressConfig = z.infer<typeof VoiceProgressConfigSchema>;