@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/acp/types.ts

@@ -4,20 +4,14 @@
 
 import type { StopReason } from "@agentclientprotocol/sdk";
 
-import type { AcpAgentConfig as ConfiguredAcpAgent } from "../config/acp-schema.js";
-import type { AcpModelOption } from "./model-config.js";
-
 /**
- * A configured ACP agent plus what the daemon learns about it at spawn time.
- * The configured half is the schema's own inferred type, so a new config leaf
- * is declared once, in `config/acp-schema.ts`.
+ * Configuration for a single ACP agent process.
  */
-export interface AcpAgentConfig extends ConfiguredAcpAgent {
-  /**
-   * Always set on a resolved agent: the resolver fills in a bundled profile's
-   * command when the config entry omits it.
-   */
+export interface AcpAgentConfig {
   command: string;
+  args: string[];
+  description?: string;
+  env?: Record<string, string>;
   /**
    * Identity of the Claude token `prepareAgentEnv` resolved into `env`,
    * whichever source it came from. Recorded on the history row when Claude
@@ -57,32 +51,6 @@ export interface AcpSessionState {
   authErrorCredential?: string;
   /** Latest context-window usage gauge, from the most recent `usage_update`. */
   latestUsage?: AcpUsageSnapshot;
-  /**
-   * Model the session is running on, as the adapter reports it. Absent while
-   * the adapter advertises no model selector, which is how the feature stays
-   * invisible for agents that cannot switch models.
-   */
-  model?: string;
-  /** Models the adapter offers this session, flattened from its selector. */
-  availableModels?: AcpModelOption[];
-  /** Time-ordered identifier of the assistant process issuing revisions. */
-  modelRevisionEpoch?: string;
-  /** Monotonic revision within `modelRevisionEpoch`. */
-  modelRevision?: number;
-}
-
-/**
- * Statuses a session is still live in. One list for every place that asks the
- * question: the boot sweep over persisted rows, the in-memory liveness guard,
- * `close()`, and the delete route's conflict guard.
- */
-export const ACP_LIVE_STATUSES = ["running", "initializing"] as const;
-
-/** Whether a status is one a session can still move from. */
-export function isLiveAcpStatus(
-  status: AcpSessionState["status"],
-): status is (typeof ACP_LIVE_STATUSES)[number] {
-  return ACP_LIVE_STATUSES.some((live) => live === status);
 }
 
 /** Context-window usage snapshot tracked from ACP `usage_update`. */
@@ -96,16 +64,3 @@ export interface AcpUsageSnapshot {
   /** Cumulative output tokens across all turns, from `PromptResponse.usage`. */
   outputTokens?: number;
 }
-
-/**
- * The adapter answered `session/set_config_option` with an error: the value
- * was refused. Raised only for the adapter's own answer to that request, so a
- * closed connection, an exited process, or a failed authentication is never
- * mistaken for a refusal.
- */
-export class AcpConfigOptionRefusedError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "AcpConfigOptionRefusedError";
-  }
-}

package/src/api/events/app-files-changed.ts

@@ -1,10 +1,9 @@
 /**
  * `app_files_changed` SSE event.
  *
- * Broadcast after an app is created, compiled, or otherwise updated so
- * connected clients re-read the app (refresh preview, reload the running
- * surface). Workspace compiles go through `assistant apps refresh` or
- * `app_refresh`; file edits do not emit this on their own.
+ * Broadcast when an app's source files change on disk — emitted when a new
+ * app is created and by the app source watcher on edits — so connected
+ * clients re-read the app (refresh preview, reload the running surface).
  *
  * Canonical wire-contract source. Daemon code imports the type
  * directly from this file; external consumers import via

package/src/api/index.ts

@@ -3,7 +3,6 @@ import { z } from "zod";
 import { AcpAuthRequiredEventSchema } from "./events/acp-auth-required.js";
 import { AcpSessionCompletedEventSchema } from "./events/acp-session-completed.js";
 import { AcpSessionErrorEventSchema } from "./events/acp-session-error.js";
-import { AcpSessionModelUpdateEventSchema } from "./events/acp-session-model-update.js";
 import { AcpSessionSpawnedEventSchema } from "./events/acp-session-spawned.js";
 import { AcpSessionUpdateEventSchema } from "./events/acp-session-update.js";
 import { AcpSessionUsageEventSchema } from "./events/acp-session-usage.js";
@@ -187,10 +186,6 @@ export {
   type AcpSessionErrorEvent,
   AcpSessionErrorEventSchema,
 } from "./events/acp-session-error.js";
-export {
-  type AcpSessionModelUpdateEvent,
-  AcpSessionModelUpdateEventSchema,
-} from "./events/acp-session-model-update.js";
 export {
   type AcpSessionSpawnedEvent,
   AcpSessionSpawnedEventSchema,
@@ -969,7 +964,6 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   AcpAuthRequiredEventSchema,
   AcpSessionCompletedEventSchema,
   AcpSessionErrorEventSchema,
-  AcpSessionModelUpdateEventSchema,
   AcpSessionSpawnedEventSchema,
   AcpSessionUpdateEventSchema,
   AcpSessionUsageEventSchema,

package/src/apps/app-store.ts

@@ -114,7 +114,7 @@ export function resolveEffectiveAppHtmlFromDir(sourceDir: string): string {
   if (isLegacySingleFileDir(sourceDir)) {
     return UNSUPPORTED_LEGACY_APP_HTML;
   }
-  return `<p>App compilation failed. Run <code>assistant apps refresh</code> to rebuild.</p>`;
+  return `<p>App compilation failed. Edit a source file to trigger a rebuild.</p>`;
 }
 
 /**

package/src/bundler/app-compiler.ts

@@ -13,10 +13,6 @@ import { existsSync, rmSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { delimiter, dirname, join, resolve } from "node:path";
 
-import {
-  computeAppSourceFingerprint,
-  writeAppSourceFingerprint,
-} from "../apps/source-fingerprint.js";
 import { getLogger } from "../util/logger.js";
 import { ensureCompilerTools } from "./compiler-tools.js";
 import {
@@ -432,8 +428,6 @@ export async function runCompile(
     };
   }
 
-  const sourceFingerprint = computeAppSourceFingerprint(appDir);
-
   // Clear stale dist/ output so removed assets (e.g. CSS) don't persist
   if (existsSync(distDir)) {
     rmSync(distDir, { recursive: true, force: true });
@@ -556,15 +550,6 @@ export async function runCompile(
     await writeFile(join(distDir, "index.html"), html);
   }
 
-  try {
-    writeAppSourceFingerprint(appDir, distDir, sourceFingerprint);
-  } catch (err) {
-    log.warn(
-      { err, appDir, distDir },
-      "Failed to write source fingerprint after compile",
-    );
-  }
-
   const durationMs = Math.round(performance.now() - start);
   log.info({ durationMs }, "Build succeeded");
   return { ok: true, errors: [], warnings: [], durationMs };

package/src/calls/__tests__/voice-control-protocol.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import {
-  createControlMarkerHoldback,
+  couldBeControlMarker,
   ESCALATE_VERDICT_TOKEN,
   HOLD_VERDICT_TOKEN,
   isIncompleteControlMarkerTail,
@@ -28,7 +28,21 @@ describe("front-door verdict tokens", () => {
     ).toBe(" one two ");
   });
 
+  test("couldBeControlMarker holds the complete tokens (not flushed to TTS)", () => {
+    expect(couldBeControlMarker("[0]")).toBe(true);
+    expect(couldBeControlMarker("[1]")).toBe(true);
+  });
+
+  test("couldBeControlMarker holds a partial token still streaming", () => {
+    // Any prefix of a token must be held so a streamed "[1" does not leak
+    // to the TTS engine before the full token arrives.
+    for (const partial of ["[", "[0", "[1"]) {
+      expect(couldBeControlMarker(partial)).toBe(true);
+    }
+  });
+
   test("ordinary text is not mistaken for a token", () => {
+    expect(couldBeControlMarker("Sure, one moment")).toBe(false);
     expect(stripInternalSpeechMarkers("Sure, one moment")).toBe(
       "Sure, one moment",
     );
@@ -45,6 +59,16 @@ describe("minimize-room marker", () => {
       stripInternalSpeechMarkers("Done [-1] here").replace(/\s+/g, " "),
     ).toBe("Done here");
   });
+
+  test("couldBeControlMarker holds the marker and its streaming prefixes", () => {
+    for (const text of ["[", "[-", "[-1", "[-1]", "[-1] trailing"]) {
+      expect(couldBeControlMarker(text)).toBe(true);
+    }
+  });
+
+  test("a bracket prefix that disproves the marker is not held", () => {
+    expect(couldBeControlMarker("[- something else")).toBe(false);
+  });
 });
 
 describe("isIncompleteControlMarkerTail", () => {
@@ -79,60 +103,3 @@ describe("isIncompleteControlMarkerTail", () => {
     }
   });
 });
-
-describe("createControlMarkerHoldback", () => {
-  function collect(): {
-    flush: ReturnType<typeof createControlMarkerHoldback>;
-    chunks: string[];
-  } {
-    const chunks: string[] = [];
-    const flush = createControlMarkerHoldback((chunk) => chunks.push(chunk));
-    return { flush, chunks };
-  }
-
-  test("holds a token still streaming and strips it once complete", () => {
-    const { flush, chunks } = collect();
-    flush("Sure [");
-    expect(chunks).toEqual(["Sure "]);
-    flush("Sure [1");
-    expect(chunks).toEqual(["Sure "]);
-    flush("Sure [1] one moment");
-    expect(chunks).toEqual(["Sure ", " one moment"]);
-  });
-
-  test("ordinary bracketed text flushes without stalling", () => {
-    const { flush, chunks } = collect();
-    flush("Option [A] then [note] here");
-    expect(chunks).toEqual(["Option [A] then [note] here"]);
-  });
-
-  test("a bracket prefix that disproves every marker flushes", () => {
-    const { flush, chunks } = collect();
-    flush("[- something else");
-    expect(chunks).toEqual(["[- something else"]);
-  });
-
-  test("a guardian-approval body is held until its JSON balances", () => {
-    const { flush, chunks } = collect();
-    const streaming =
-      'Hold on. [ASK_GUARDIAN_APPROVAL: {"question": "ok]?", "options": ["a", "b"';
-    flush(streaming);
-    expect(chunks).toEqual(["Hold on. "]);
-    flush(`${streaming}]}] Thanks.`);
-    expect(chunks).toEqual(["Hold on. ", " Thanks."]);
-  });
-
-  test("force emits a held tail that never became a marker", () => {
-    const { flush, chunks } = collect();
-    flush("Score was [1");
-    expect(chunks).toEqual(["Score was "]);
-    flush("Score was [1", { force: true });
-    expect(chunks).toEqual(["Score was ", "[1"]);
-  });
-
-  test("a chunk that strips to nothing is not emitted", () => {
-    const { flush, chunks } = collect();
-    flush("[END_CALL]");
-    expect(chunks).toEqual([]);
-  });
-});

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -842,42 +842,6 @@ describe("startVoiceTurn triage-and-escalate control prompt", () => {
     expect(installed()).toContain(escalatedContinuationRule());
   });
 
-  test("the auto-built phone prompt carries the front-door rule anchored to the caller's words", async () => {
-    const installed = captureInstalledPrompt();
-    await startVoiceTurn({
-      ...makeTurnOptions(),
-      content: "what time is it",
-      routingLeg: "front-door",
-    });
-    expect(installed()).toContain("<voice_call_control>");
-    expect(installed()).toContain(
-      `13. ${frontDoorDecisionRule({ callerUtterance: "what time is it" })}`,
-    );
-  });
-
-  test("a phone sentinel anchors the front-door rule on its persisted form", async () => {
-    const installed = captureInstalledPrompt();
-    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
-    expect(installed()).toContain(
-      frontDoorDecisionRule({
-        callerUtterance: "(call connected — deliver opening greeting)",
-      }),
-    );
-    expect(installed()).not.toContain(JSON.stringify(CALL_OPENING_MARKER));
-  });
-
-  test("the auto-built phone prompt carries the escalated continuation rule", async () => {
-    const installed = captureInstalledPrompt();
-    await startVoiceTurn({
-      ...makeTurnOptions(),
-      routingLeg: "escalated",
-      spokenEscalationBridge: "One moment.",
-    });
-    expect(installed()).toContain(
-      `13. ${escalatedContinuationRule("One moment.")}`,
-    );
-  });
-
   test("leaves a caller-supplied prompt verbatim when no routing leg is set", async () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn({
@@ -896,7 +860,7 @@ describe("default call protocol numbered rules", () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn(makeTurnOptions());
     expect(installed()).toContain(
-      "11. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, use the language the Task context implies, if any; otherwise default to English.",
+      "12. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, use the language the Task context implies, if any; otherwise default to English.",
     );
   });
 

package/src/calls/__tests__/voice-triage-escalate.test.ts

@@ -5,7 +5,6 @@ import {
   capEscalationBridge,
   classifyFrontDoorLeading,
   createFrontDoorStreamGate,
-  createFrontDoorVerdictMachine,
   ESCALATE_VERDICT_TOKEN,
   escalatedContinuationRule,
   ESCALATION_CONTINUATION_CONTENT,
@@ -18,7 +17,6 @@ import {
   isEscalationBridgeComplete,
   MAX_ESCALATION_BRIDGE_CHARS,
   needsFallbackBridge,
-  resolveSpokenEscalationBridge,
   spokenBridgeText,
 } from "../voice-triage-escalate.js";
 
@@ -283,34 +281,6 @@ describe("fallbackEscalationBridgeFor", () => {
   });
 });
 
-describe("resolveSpokenEscalationBridge", () => {
-  test("a real capped bridge is spoken as the model's own speech", () => {
-    expect(resolveSpokenEscalationBridge("Let me check that.", "es")).toEqual({
-      spokenBridge: "Let me check that.",
-      usesFallback: false,
-    });
-  });
-
-  test("an empty or too-short bridge falls back to the localized canned phrase, audio-only", () => {
-    expect(resolveSpokenEscalationBridge("", "es")).toEqual({
-      spokenBridge: FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.es,
-      usesFallback: true,
-    });
-    expect(resolveSpokenEscalationBridge("Ok", undefined)).toEqual({
-      spokenBridge: FALLBACK_ESCALATION_BRIDGE,
-      usesFallback: true,
-    });
-  });
-
-  test("a canned phrase the table lacks for the caller's language is English and says so", () => {
-    expect(resolveSpokenEscalationBridge("", "ko")).toEqual({
-      spokenBridge: FALLBACK_ESCALATION_BRIDGE,
-      usesFallback: true,
-      language: "en",
-    });
-  });
-});
-
 describe("capEscalationBridge", () => {
   test("cuts just after the first sentence terminator", () => {
     expect(
@@ -479,81 +449,6 @@ describe("live-voice escalation orchestration (end-to-end — TODO)", () => {
   );
 });
 
-describe("createFrontDoorVerdictMachine", () => {
-  /** Feed `deltas` through a machine and return the step kinds, in order. */
-  function kinds(deltas: string[], holdEnabled = false): string[] {
-    const machine = createFrontDoorVerdictMachine(holdEnabled);
-    return deltas.map((delta) => machine.push(delta).kind);
-  }
-
-  test("stays pending while the lead could still become a token", () => {
-    expect(kinds(["", "[", "1"])).toEqual(["pending", "pending", "pending"]);
-  });
-
-  test("an answer releases the held lead on the transition, then each delta", () => {
-    const machine = createFrontDoorVerdictMachine(false);
-    expect(machine.push("[")).toEqual({ kind: "pending" });
-    expect(machine.push("A] first")).toEqual({
-      kind: "answer",
-      text: "[A] first",
-    });
-    expect(machine.push(", second")).toEqual({
-      kind: "answer",
-      text: ", second",
-    });
-  });
-
-  test("escalate reports the capped bridge on the delta that completes it", () => {
-    const machine = createFrontDoorVerdictMachine(false);
-    expect(machine.push(`${ESCALATE_VERDICT_TOKEN} One `)).toEqual({
-      kind: "escalate",
-      bridge: null,
-    });
-    expect(machine.push("moment")).toEqual({ kind: "bridging" });
-    expect(machine.push(". Extra text past the cap")).toEqual({
-      kind: "bridge",
-      bridge: "One moment.",
-    });
-    expect(machine.push(" more")).toEqual({ kind: "done" });
-  });
-
-  test("a bridge that completes on the verdict delta is reported with it", () => {
-    const machine = createFrontDoorVerdictMachine(false);
-    expect(machine.push(`${ESCALATE_VERDICT_TOKEN} Let me check.`)).toEqual({
-      kind: "escalate",
-      bridge: "Let me check.",
-    });
-  });
-
-  test("finish hands off a bridge that never hit a terminator", () => {
-    const machine = createFrontDoorVerdictMachine(false);
-    machine.push(`${ESCALATE_VERDICT_TOKEN} Give me a second`);
-    expect(machine.finish()).toEqual({
-      kind: "bridge",
-      bridge: "Give me a second",
-    });
-    expect(machine.push("late")).toEqual({ kind: "done" });
-  });
-
-  test("finish on an answer or a pending lead is done, not a bridge", () => {
-    const answering = createFrontDoorVerdictMachine(false);
-    answering.push("Sure.");
-    expect(answering.finish()).toEqual({ kind: "done" });
-    const undecided = createFrontDoorVerdictMachine(false);
-    undecided.push("[");
-    expect(undecided.finish()).toEqual({ kind: "done" });
-  });
-
-  test("hold is a step only when the leg was taught the token", () => {
-    expect(kinds([HOLD_VERDICT_TOKEN], true)).toEqual(["hold"]);
-    expect(kinds([`${HOLD_VERDICT_TOKEN} trailing`], true)).toEqual(["hold"]);
-    expect(kinds([HOLD_VERDICT_TOKEN], false)).toEqual(["answer"]);
-    const held = createFrontDoorVerdictMachine(true);
-    held.push(HOLD_VERDICT_TOKEN);
-    expect(held.push("anything")).toEqual({ kind: "done" });
-  });
-});
-
 describe("createFrontDoorStreamGate", () => {
   /** Feed `deltas` through a gate and return what it released, in order. */
   function release(

package/src/calls/call-constants.ts

@@ -69,35 +69,15 @@ export function getGuardianWaitUpdateSteadyMaxIntervalMs(): number {
   return getConfig().calls.guardianWaitUpdateSteadyMaxIntervalMs;
 }
 
-// Fixed conversational timings. Named here, beside the config-backed limits
-// above, so the phone path's cadence is readable in one place.
-
-/** Caller silence after the assistant's turn before it nudges them. */
-export const CALLER_SILENCE_NUDGE_MS = 30_000;
-
-/** Listen window after the goodbye drains, in case the caller re-engages. */
-export const END_CALL_LISTEN_WINDOW_MS = 2_000;
-
-/** Max time to wait for goodbye audio to drain before forcing hangup. */
-export const END_CALL_DRAIN_MAX_WAIT_MS = 15_000;
-
-/** Lead before the max call duration at which the low-on-time warning is spoken. */
-export const DURATION_WARNING_LEAD_MS = 2 * 60 * 1000;
-
-/** Delay after the max-duration goodbye is spoken before the call is ended. */
-export const POST_GOODBYE_HANGUP_DELAY_MS = 3_000;
-
-/** Cap on waiting for a superseded turn's teardown before the next caller turn starts. */
-export const BARGE_IN_TEARDOWN_WAIT_MS = 2_000;
-
 export function getSilenceTimeoutMs(): number {
-  return CALLER_SILENCE_NUDGE_MS;
+  return 30 * 1000; // 30 seconds
 }
 
 export function getEndCallListenWindowMs(): number {
-  return END_CALL_LISTEN_WINDOW_MS;
+  return 2 * 1000;
 }
 
+/** Max time to wait for goodbye audio to drain before forcing hangup. */
 export function getEndCallDrainMaxWaitMs(): number {
-  return END_CALL_DRAIN_MAX_WAIT_MS;
+  return 15 * 1000;
 }