@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/telemetry/phone-call-funnel.ts

@@ -0,0 +1,144 @@
+/**
+ * Phone-call telemetry vocabulary: the single source of truth for the step
+ * names, funnel version, and dimension values the call store's emitter uses.
+ *
+ * The phone half of the live-voice funnel, and deliberately its mirror image:
+ * same onboarding substrate (`type: "onboarding"`), same open-string
+ * `step_name` / `funnel_version`, same reason for both. See
+ * `live-voice-funnel.ts` for the full argument; the short version is that the
+ * backend stores those two as open strings, so a new funnel needs no platform
+ * serializer and no wire-contract change.
+ *
+ * **Duration is not a field**, for the same reason it is not one on live
+ * voice: the onboarding event shape has no numeric slot. The two events below
+ * are keyed by the call session id in `session_id` and the warehouse subtracts
+ * their `recorded_at` stamps.
+ *
+ * **Turn count is not a field either.** Phone turns already carry the call
+ * session id in their `client` bag (`voiceTelemetry` at the bridge call site),
+ * so a turn count is a count of those rows.
+ *
+ * A call that starts and never ends is **censored, not infinite**: a daemon
+ * crash between the two writes emits no end event, so duration math must drop
+ * unmatched `started` rows rather than treat the call as still running.
+ */
+
+import type { CallMode, CallStatus } from "../calls/types.js";
+
+/** Funnel version stamped on every phone-call event. */
+export const PHONE_CALL_FUNNEL_VERSION = "phone_call_v1_2026_09";
+
+/**
+ * Phone-call funnel steps. `stepName` is the wire value; `stepIndex` is the
+ * ordinal position.
+ *
+ * `callStarted` fires when the call session row is created, before the
+ * provider has dialled: a call that never connects is exactly the one worth
+ * counting, so the start event precedes no-answer, busy, provider failure and
+ * the inbound credential preflight (an inbound session exists before that
+ * preflight runs and records against it).
+ *
+ * It does **not** cover an outbound attempt rejected before a session exists:
+ * `startCall`, `startVerificationCall` and `startInviteCall` all return on a
+ * failed `preflightVoiceIngress()` without creating a row, and this funnel is
+ * keyed by the session id it would have had. Counting those needs a key that
+ * does not depend on a session row, which is its own piece of work.
+ */
+export const PHONE_CALL_STEPS = {
+  callStarted: { stepName: "phone_call_started", stepIndex: 0 },
+  callEnded: { stepName: "phone_call_ended", stepIndex: 1 },
+} as const;
+
+export type PhoneCallStepName =
+  (typeof PHONE_CALL_STEPS)[keyof typeof PHONE_CALL_STEPS]["stepName"];
+
+/**
+ * Which way the call was placed. Inbound is someone dialling the assistant's
+ * number; outbound is the assistant dialling out on a task.
+ */
+export type PhoneCallDirection = "inbound" | "outbound";
+
+/**
+ * How a call ended, stamped as `outcome`.
+ *
+ * `failed` means the call died on an error: no answer, a provider or
+ * credential failure, a dropped media stream. A call the caller or the
+ * assistant hung up, including one cancelled before it connected, is
+ * `completed`: it ran its course and the close reason on `screen` says how.
+ */
+export type PhoneCallOutcome = "completed" | "failed";
+
+/**
+ * How far a call that produced NO caller turn actually got.
+ *
+ * The phone analogue of the live-voice silence taxonomy, and the closest thing
+ * call telemetry has to a "the phone path didn't work" rate. A bare
+ * started/ended pair cannot separate a call that never connected from one that
+ * connected to silence, and those have completely different fixes.
+ *
+ * - `no_connect` the call never reached `in_progress`: it failed, was
+ *                cancelled, or was never answered, so nobody could have
+ *                spoken.
+ * - `no_turn`    the call connected and then no caller utterance was ever
+ *                transcribed: a silent line, a failed STT leg, or a caller who
+ *                hung up on the disclosure.
+ */
+export type PhoneCallSilenceReason = "no_connect" | "no_turn";
+
+/**
+ * Classify a call that produced no caller turn. Call only when the call really
+ * produced none: the second branch asserts silence, so a call that did take a
+ * turn would be mislabelled by it.
+ */
+export function phoneCallSilenceReason(signals: {
+  connected: boolean;
+}): PhoneCallSilenceReason {
+  return signals.connected ? "no_turn" : "no_connect";
+}
+
+/**
+ * The mode an ordinary call carries. Only the verification and invite flows
+ * write a mode on the session row, so a null there is not a missing dimension
+ * but the ordinary conversation every other path creates.
+ */
+const PHONE_CALL_DEFAULT_MODE: CallMode = "normal";
+
+/**
+ * The `screen` dimension for a started call: which way it was placed and what
+ * kind of call it is, as `started_<direction>:<mode>`.
+ *
+ * The mode separates the three things a phone call can be (a normal
+ * conversation, a callee verification, an invite redemption) because they have
+ * completely different shapes and success criteria, and a funnel that mixed
+ * them would report the verification flow's brevity as a conversation problem.
+ */
+export function phoneCallStartScreen(
+  direction: PhoneCallDirection,
+  mode?: CallMode | null,
+): string {
+  return `started_${direction}:${mode ?? PHONE_CALL_DEFAULT_MODE}`;
+}
+
+/**
+ * The `screen` dimension for an ended call: the terminal status it reached,
+ * plus a detail half carrying the silence classification when the call took no
+ * caller turn at all.
+ *
+ * The status is the daemon's own `CallStatus` verbatim rather than a mapping,
+ * so a rename surfaces here as a compile error instead of a silently-empty
+ * dashboard facet.
+ *
+ * The silence value carries a `silent_` prefix to match the live-voice stamp,
+ * which shares its detail slot with failure codes and renders in an admin
+ * column labelled "failure code". Reading the two funnels side by side is
+ * worth more than a shorter string here.
+ */
+export function phoneCallEndScreen(
+  status: CallStatus,
+  silenceReason?: PhoneCallSilenceReason | null,
+): string {
+  if (silenceReason) {
+    return `ended_${status}:silent_${silenceReason}`;
+  }
+  return `ended_${status}`;
+}

package/src/tools/__tests__/tool-schema-root-combinator-guard.test.ts

@@ -0,0 +1,81 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, test } from "bun:test";
+
+import { parseToolManifestFile } from "../../skills/tool-manifest.js";
+import { explicitTools } from "../tool-manifest.js";
+
+/**
+ * Tool input schemas must be plain objects at the root.
+ *
+ * Anthropic's Messages API rejects a tool whose `input_schema` carries
+ * `oneOf`, `anyOf`, or `allOf` at the top level ("input_schema does not
+ * support oneOf, allOf, or anyOf at the top level"). The rejection is a 400
+ * for the whole request, so one offending definition takes down every call
+ * that advertises it. Other hosts accept the same schema, which lets the
+ * mistake hide until a request routes to Anthropic directly. Either/or rules
+ * between fields belong in the tool description and the tool's own input
+ * validation instead.
+ *
+ * Covers the core manifest and every bundled skill's `TOOLS.json`.
+ * Combinators nested under `properties` are accepted by Anthropic and stay
+ * out of scope.
+ */
+
+const ROOT_COMBINATORS = ["oneOf", "anyOf", "allOf"] as const;
+
+const BUNDLED_SKILLS_DIR = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../config/bundled-skills",
+);
+
+interface SchemaCase {
+  /** Tool name, prefixed with the skill directory for bundled skill tools. */
+  label: string;
+  schema: Record<string, unknown>;
+}
+
+function bundledSkillSchemas(): SchemaCase[] {
+  const cases: SchemaCase[] = [];
+  for (const relative of new Bun.Glob("*/TOOLS.json").scanSync({
+    cwd: BUNDLED_SKILLS_DIR,
+  })) {
+    const manifest = parseToolManifestFile(join(BUNDLED_SKILLS_DIR, relative));
+    for (const tool of manifest.tools) {
+      cases.push({
+        label: `${dirname(relative)}/${tool.name}`,
+        schema: tool.input_schema,
+      });
+    }
+  }
+  return cases;
+}
+
+function coreSchemas(): SchemaCase[] {
+  return explicitTools.map((tool) => {
+    if (!tool.name) {
+      throw new Error("core manifest entries carry explicit names");
+    }
+    return {
+      label: tool.name,
+      schema: tool.input_schema as Record<string, unknown>,
+    };
+  });
+}
+
+const CASES: SchemaCase[] = [...coreSchemas(), ...bundledSkillSchemas()];
+
+describe("tool input schema root", () => {
+  test("covers the core manifest and the bundled skills", () => {
+    expect(CASES.length).toBeGreaterThan(explicitTools.length);
+  });
+
+  for (const { label, schema } of CASES) {
+    test(`${label} keeps combinators out of the schema root`, () => {
+      for (const keyword of ROOT_COMBINATORS) {
+        expect(schema).not.toHaveProperty(keyword);
+      }
+      expect(schema.type).toBe("object");
+    });
+  }
+});

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

@@ -124,6 +124,8 @@ const DESCRIPTION = [
   "For logins, use saved credentials first. Securely collect missing credentials",
   "with assistant credentials prompt, then fill the login form yourself.",
   "",
+  "Every call passes exactly one of `questions` or `desktopHelp`.",
+  "",
   "Use this tool whenever a request is ambiguous and can be resolved",
   "by 2–4 plausible interpretations or discrete choices. Prefer it over",
   "plain-text clarification — structured options are faster to answer and",
@@ -255,10 +257,10 @@ export const askQuestionTool = {
   category: "interaction",
   executionTarget: "sandbox",
   defaultRiskLevel: RiskLevel.Low,
-  input_schema: {
-    ...toToolInputSchema(askQuestionInputSchema),
-    oneOf: [{ required: ["questions"] }, { required: ["desktopHelp"] }],
-  },
+  // Anthropic rejects `oneOf` / `anyOf` / `allOf` at the root of a tool
+  // schema, so the either/or rule between `questions` and `desktopHelp` lives
+  // in the description and the Zod refine, not in the wire schema.
+  input_schema: toToolInputSchema(askQuestionInputSchema),
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/browser/browser-execution.ts

@@ -60,7 +60,6 @@ import {
   captureScreenshotJpeg,
   dispatchClickAt,
   dispatchHoverAt,
-  dispatchInsertText,
   dispatchKeyPress,
   dispatchWheelScroll,
   evaluateExpression,
@@ -68,6 +67,7 @@ import {
   getCenterPoint,
   getCurrentUrl,
   getPageTitle,
+  insertTextIntoElement,
   navigateAndWait,
   querySelectorBackendNodeId,
   scrollIntoViewIfNeeded,
@@ -1761,60 +1761,6 @@ export async function executeBrowserClick(
   }
 }
 
-// ── Shared input helpers ─────────────────────────────────────────────
-
-/**
- * Focus an element, clear its existing value (handling both
- * `<input>`/`<textarea>` and `contentEditable` targets), re-focus
- * (sites sometimes blur on a programmatic value reset), and insert
- * the requested text via `Input.insertText`.
- *
- * Used by both `executeBrowserType` and `executeBrowserFillCredential`
- * so credential fills cannot append to autofilled / pre-populated
- * fields — appending would leak the existing value into the broker
- * payload and corrupt the resulting password.
- */
-async function clearAndInsertText(
-  cdp: CdpClient,
-  backendNodeId: number,
-  value: string,
-  signal?: AbortSignal,
-): Promise<void> {
-  await focusElement(cdp, backendNodeId, signal);
-
-  // Resolve the node to a Runtime.RemoteObject so we can invoke a
-  // function on the element itself via Runtime.callFunctionOn. This
-  // is more reliable than a keyboard select-all + delete sequence
-  // across input, textarea, and contenteditable targets.
-  const { object } = await cdp.send<{ object: { objectId: string } }>(
-    "DOM.resolveNode",
-    { backendNodeId },
-    signal,
-  );
-  await cdp.send(
-    "Runtime.callFunctionOn",
-    {
-      objectId: object.objectId,
-      functionDeclaration: `function() {
-        if (typeof this.value === "string") {
-          this.value = "";
-        } else if (this.isContentEditable) {
-          this.textContent = "";
-        }
-        this.dispatchEvent(new Event("input", { bubbles: true }));
-      }`,
-      arguments: [],
-    },
-    signal,
-  );
-
-  // Re-focus after clearing — some sites move focus when the value
-  // property is reassigned programmatically.
-  await focusElement(cdp, backendNodeId, signal);
-
-  await dispatchInsertText(cdp, value, signal);
-}
-
 // ── browser_type ─────────────────────────────────────────────────────
 
 export async function executeBrowserType(
@@ -1860,10 +1806,21 @@ export async function executeBrowserType(
     }
 
     if (clearFirst) {
-      await clearAndInsertText(cdp, backendNodeId, text, context.signal);
+      await insertTextIntoElement(
+        cdp,
+        backendNodeId,
+        text,
+        { clearFirst: true },
+        context.signal,
+      );
     } else {
-      await focusElement(cdp, backendNodeId, context.signal);
-      await dispatchInsertText(cdp, text, context.signal);
+      await insertTextIntoElement(
+        cdp,
+        backendNodeId,
+        text,
+        { clearFirst: false },
+        context.signal,
+      );
     }
 
     if (pressEnter) {
@@ -2502,7 +2459,13 @@ export async function executeBrowserFillCredential(
         // would append the credential to the existing value,
         // producing a corrupted password and leaking partial state
         // back into the page.
-        await clearAndInsertText(cdp, backendNodeId, value, context.signal);
+        await insertTextIntoElement(
+          cdp,
+          backendNodeId,
+          value,
+          { clearFirst: true, verify: false },
+          context.signal,
+        );
       },
     });