@vellumai/assistant 0.8.5 → 0.8.7

package/src/skills/validate-input.ts

@@ -0,0 +1,177 @@
+/**
+ * Pure JSON-schema input validator for skill tool calls.
+ *
+ * Deliberate strict subset of JSON Schema: it covers only the keywords
+ * actually used by `assistant/src/config/bundled-skills/**\/TOOLS.json`
+ * (required / type / enum / items.type) plus unknown-key detection. Anything
+ * else (`$ref`, `oneOf`, `anyOf`, `allOf`, `format`, `pattern`, `minimum`,
+ * `maximum`, object-shape `additionalProperties`, etc.) is silently skipped so
+ * a richer schema can never cause us to reject a legitimate call.
+ *
+ * Each error message is written to be agent-readable and self-correcting
+ * (e.g. `surface_id is required`, `mode must be one of "replace", "append"`).
+ */
+
+import { isPlainObject } from "../util/object.js";
+
+export interface InputValidationSuccess {
+  ok: true;
+}
+
+export interface InputValidationFailure {
+  ok: false;
+  /** Human-readable messages, one per problem. */
+  errors: string[];
+}
+
+export type InputValidationResult =
+  | InputValidationSuccess
+  | InputValidationFailure;
+
+type SupportedType =
+  | "string"
+  | "number"
+  | "integer"
+  | "boolean"
+  | "array"
+  | "object";
+
+const SUPPORTED_TYPES: ReadonlySet<string> = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object",
+]);
+
+function matchesType(value: unknown, type: SupportedType): boolean {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+  }
+}
+
+function quoteList(values: readonly string[]): string {
+  return values.map((v) => `"${v}"`).join(", ");
+}
+
+/**
+ * Validate a tool input object against the (optional) JSON-schema definition
+ * declared on the tool entry. Returns `{ ok: true }` if the input is valid (or
+ * if there is nothing actionable to validate); otherwise returns a list of
+ * human-readable error strings.
+ *
+ * Pure: never mutates `input` or `schema`, no I/O.
+ */
+export function validateInputAgainstSchema(
+  _toolName: string,
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+): InputValidationResult {
+  // Skip when there's no schema or no properties block — matches today's
+  // lenient behaviour for tools that declare only `{ type: "object" }`.
+  if (!schema) return { ok: true };
+  const properties = schema.properties;
+  if (!isPlainObject(properties)) return { ok: true };
+
+  const errors: string[] = [];
+  const knownKeys = Object.keys(properties);
+  const knownKeySet = new Set(knownKeys);
+
+  // 1. Required fields — presence-only check per JSON Schema spec.
+  // `required` only requires the property to be present; `null` is a valid
+  // value when the schema allows it (e.g. `type: ["string", "null"]`).
+  const required = schema.required;
+  if (Array.isArray(required)) {
+    for (const key of required) {
+      if (typeof key !== "string") continue;
+      if (!(key in input)) {
+        errors.push(`${key} is required`);
+      }
+    }
+  }
+
+  // 2. Per-property checks: type, enum, items.type.
+  for (const [key, rawSubSchema] of Object.entries(properties)) {
+    if (!(key in input)) continue;
+    const value = input[key];
+    // Skip type-checking for absent values; presence is enforced by the
+    // `required` check above. Note: `null` IS a present value and is
+    // type-checked below — only schemas that explicitly opt in to null via
+    // a union type (`type: ["string","null"]`) bypass the check, handled
+    // by the `Array.isArray(declaredType)` skip immediately below.
+    if (value === undefined) continue;
+    if (!isPlainObject(rawSubSchema)) continue;
+
+    const declaredType = rawSubSchema.type;
+    // Skip union types (e.g. `["string", "null"]`) — same lenient treatment
+    // we give `oneOf`/`anyOf`/`$ref`. We only validate single-type schemas.
+    if (Array.isArray(declaredType)) continue;
+    if (typeof declaredType === "string" && SUPPORTED_TYPES.has(declaredType)) {
+      const type = declaredType as SupportedType;
+      if (!matchesType(value, type)) {
+        errors.push(`${key} must be ${typeArticle(type)} ${type}`);
+        // No point checking enum/items if the base type is wrong.
+        continue;
+      }
+
+      // 2a. Enum (string enums are the only shape used today).
+      const enumValues = rawSubSchema.enum;
+      if (Array.isArray(enumValues) && enumValues.length > 0) {
+        if (!enumValues.includes(value)) {
+          errors.push(
+            `${key} must be one of ${quoteList(enumValues.map(String))}`,
+          );
+        }
+      }
+
+      // 2b. Array items.type — per-element check.
+      if (type === "array" && isPlainObject(rawSubSchema.items)) {
+        const itemType = rawSubSchema.items.type;
+        if (
+          typeof itemType === "string" &&
+          SUPPORTED_TYPES.has(itemType) &&
+          Array.isArray(value)
+        ) {
+          const itemTypeName = itemType as SupportedType;
+          value.forEach((element, index) => {
+            if (!matchesType(element, itemTypeName)) {
+              errors.push(
+                `${key}[${index}] must be ${typeArticle(itemTypeName)} ${itemTypeName}`,
+              );
+            }
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Unknown keys — parity with the previous `validateNoUnknownParams`.
+  const unknownKeys = Object.keys(input).filter((k) => !knownKeySet.has(k));
+  for (const key of unknownKeys) {
+    errors.push(
+      `Unknown parameter "${key}". Supported: ${quoteList(knownKeys)}`,
+    );
+  }
+
+  if (errors.length === 0) return { ok: true };
+  return { ok: false, errors };
+}
+
+function typeArticle(type: SupportedType): "a" | "an" {
+  // `integer`, `array`, `object` start with a vowel sound.
+  return type === "integer" || type === "array" || type === "object"
+    ? "an"
+    : "a";
+}

package/src/subagent/manager.ts

@@ -285,12 +285,9 @@ export class SubagentManager {
       conversationRecord.id,
       provider,
       systemPrompt,
-      maxTokens,
       wrappedSendToClient,
       workingDir,
-      undefined, // sharedCesClient
-      undefined, // speedOverride
-      "5m", // cacheTtl — subagents run tight tool-use loops, 5m is always hot
+      { maxTokens, cacheTtl: "5m" },
     );
 
     // Mark conversation as having no direct client — it routes through parent.
@@ -365,6 +362,7 @@ export class SubagentManager {
       label: config.label,
       objective: config.objective,
       isFork: config.fork ?? false,
+      parentToolUseId: config.parentToolUseId,
     } as ServerMessage);
 
     log.info(
@@ -435,8 +433,10 @@ export class SubagentManager {
             "⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯",
           ].join("\n")
         : objective;
-      const messageId = await conversation.persistUserMessage(message, []);
-      await conversation.runAgentLoop(message, messageId, undefined, {
+      const { id: messageId } = await conversation.persistUserMessage({
+        content: message,
+      });
+      await conversation.runAgentLoop(message, messageId, {
         callSite: "subagentSpawn",
         ...(managed.state.config.overrideProfile
           ? { overrideProfile: managed.state.config.overrideProfile }
@@ -609,7 +609,7 @@ export class SubagentManager {
       return "terminal";
 
     // If the conversation is busy, queue the message; otherwise process immediately.
-    const result = managed.conversation.enqueueMessage(trimmed, []);
+    const result = managed.conversation.enqueueMessage({ content: trimmed });
     if (result.rejected) {
       return "sent"; // error event already delivered via sendToClient
     }
@@ -620,9 +620,11 @@ export class SubagentManager {
       // Capture conversation before the await — managed.conversation may be
       // nulled by an external dispose() while persistUserMessage is awaited.
       const conversation = managed.conversation;
-      const messageId = await conversation.persistUserMessage(trimmed, []);
+      const { id: messageId } = await conversation.persistUserMessage({
+        content: trimmed,
+      });
       conversation
-        .runAgentLoop(trimmed, messageId, undefined, {
+        .runAgentLoop(trimmed, messageId, {
           callSite: "subagentSpawn",
           ...(managed.state.config.overrideProfile
             ? { overrideProfile: managed.state.config.overrideProfile }
@@ -984,19 +986,14 @@ export class SubagentManager {
       );
       return;
     }
-    const enqueueResult = parentConversation.enqueueMessage(
-      message,
-      [],
-      undefined,
-      undefined,
-      undefined,
-      undefined,
+    const enqueueResult = parentConversation.enqueueMessage({
+      content: message,
       metadata,
-    );
+    });
     if (!enqueueResult.queued && !enqueueResult.rejected) {
       parentConversation
-        .persistUserMessage(message, [], undefined, metadata)
-        .then((messageId) =>
+        .persistUserMessage({ content: message, metadata })
+        .then(({ id: messageId }) =>
           parentConversation.runAgentLoop(message, messageId),
         )
         .catch((err) => {

package/src/subagent/types.ts

@@ -69,6 +69,12 @@ export interface SubagentConfig {
    * profile, every spawned subagent inherits it automatically.
    */
   overrideProfile?: string;
+  /**
+   * Tool-use id of the `skill_execute` call that spawned this subagent.
+   * Forwarded into the `subagent_spawned` event so the client can anchor the
+   * inline subagent card to the exact spawn tool call.
+   */
+  parentToolUseId?: string;
 }
 
 // ── State (runtime) ─────────────────────────────────────────────────────

package/src/tasks/tool-sanitizer.ts

@@ -1,4 +1,4 @@
-import { getAllTools, getTool } from "../tools/registry.js";
+import { getAllTools, getTool, getToolOwner } from "../tools/registry.js";
 
 /**
  * Deduplicate and sort a list of tool names, validating against the live
@@ -24,7 +24,7 @@ export function sanitizeToolList(tools: string[]): string[] {
  */
 export function getRegisteredToolNames(): string[] {
   return getAllTools()
-    .filter((t) => t.executionMode !== "proxy" && t.origin !== "skill")
+    .filter((t) => getToolOwner(t.name)?.kind !== "skill")
     .map((t) => t.name)
     .sort();
 }

package/src/telemetry/types.ts

@@ -6,6 +6,32 @@ export interface TelemetryEventBase {
   type: string;
   daemon_event_id: string;
   recorded_at: number;
+  /**
+   * Version of the assistant binary at the moment THIS event was
+   * RECORDED (not when the batch was uploaded). Distinct from the
+   * envelope's `assistant_version` field, which still ships for
+   * back-compat with platforms that haven't deployed the per-event
+   * handling.
+   *
+   * The platform's `TelemetryIngestView` prefers per-event over
+   * envelope: when a per-event value is present (including explicit
+   * `null`) it wins. When the field is omitted on the event entirely
+   * (old assistant), the envelope value is the back-compat fallback.
+   *
+   * Daemon-side, this field is always non-null — the reporter stamps
+   * the running binary's `APP_VERSION` when the underlying SQLite row
+   * has no record-time value. In this PR only `llm_usage` events
+   * carry a true record-time value (legacy llm_usage rows from before
+   * migration 267 fall back to `APP_VERSION`); turn, lifecycle, and
+   * onboarding events all stamp `APP_VERSION` directly until the
+   * follow-ups that add the column to `messages` / `lifecycle_events`
+   * (#18112) / `onboarding_events` (#30733) land. Stamping
+   * `APP_VERSION` instead of emitting explicit `null` preserves
+   * envelope-equivalent behavior under the per-event-wins contract.
+   * The type allows `null` for parity with the platform contract;
+   * in practice the daemon never sends it.
+   */
+  assistant_version: string | null;
 }
 
 /** LLM usage event — one per provider API call. */

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -98,7 +98,12 @@ mock.module("../config/loader.js", () => ({
 }));
 
 const mockQueryUnreportedLifecycleEvents = mock(
-  () => [] as { id: string; eventName: string; createdAt: number }[],
+  () =>
+    [] as {
+      id: string;
+      eventName: string;
+      createdAt: number;
+    }[],
 );
 
 mock.module("../memory/lifecycle-events-store.js", () => ({
@@ -116,6 +121,7 @@ const mockQueryUnreportedOnboardingEvents = mock(
       tone: string | null;
       googleConnected: boolean | null;
       googleScopesJson: string | null;
+      priorAssistantsJson: string | null;
       abVariant: string | null;
     }[],
 );
@@ -169,6 +175,7 @@ function makeUsageEvent(
     requestId: null,
     estimatedCostUsd: 0.001,
     pricingStatus: "priced",
+    assistantVersion: "test-app-version",
     conversationType: "standard",
     turnIndex: 1,
     ...overrides,
@@ -938,4 +945,134 @@ describe("UsageTelemetryReporter", () => {
     );
     expect(body.events[0].daemon_event_id).toBe("evt-after-reenable");
   });
+
+  // -------------------------------------------------------------------------
+  // Per-event `assistant_version` on the wire
+  //
+  // The envelope's `assistant_version` is upload-time (always the current
+  // binary). The per-event field is record-time (the binary that was running
+  // when the event was persisted to SQLite). In this PR only `llm_usage`
+  // events carry a true record-time value; turn events (and lifecycle /
+  // onboarding events, not asserted here) stamp the running binary's
+  // `APP_VERSION` directly until their respective follow-ups land.
+  // Nullable llm_usage cases (legacy rows from before migration 267 ran)
+  // fall back to the running binary's `APP_VERSION` rather than emitting
+  // explicit `null` — under the platform contract a present-but-null
+  // per-event value would override the envelope, and we'd rather have a
+  // concrete version than no version.
+  // -------------------------------------------------------------------------
+
+  test("llm_usage event carries its recorded assistantVersion on the wire", async () => {
+    const event = makeUsageEvent({
+      id: "evt-version-llm",
+      assistantVersion: "0.8.4",
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    // Envelope reflects current binary (upload-time).
+    expect(body.assistant_version).toBe("1.2.3-test");
+    // Per-event reflects record-time — a different value here is the
+    // whole point: backlogged events keep the binary they were stamped
+    // with when they were originally recorded.
+    expect(body.events[0].assistant_version).toBe("0.8.4");
+  });
+
+  test("llm_usage event with null assistantVersion falls back to APP_VERSION (pre-migration row)", async () => {
+    const event = makeUsageEvent({
+      id: "evt-version-llm-null",
+      assistantVersion: null,
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    // No explicit null on the wire — the running binary's APP_VERSION is
+    // stamped instead so a present-but-null value can't override the
+    // envelope under the platform's per-event-wins contract.
+    expect(body.events[0].assistant_version).toBe("1.2.3-test");
+  });
+
+  test("turn event emits assistant_version: APP_VERSION (running binary)", async () => {
+    // Turn events are derived from `messages` + `conversations`, which
+    // don't yet carry a per-event version. Until the follow-up migration
+    // adds a column to `messages`, we stamp the running binary's
+    // APP_VERSION instead of explicit null — matches what the envelope
+    // would have provided but per-event so it survives the platform
+    // contract that treats present per-event values as winning over the
+    // envelope.
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    mockQueryUnreportedTurnEvents.mockReturnValue([
+      {
+        id: "evt-turn-version",
+        createdAt: 1700000300000,
+        conversationId: "conv-1",
+        conversationType: "standard",
+        turnIndex: 1,
+        interfaceId: null,
+        channelId: null,
+        clientMetadata: null,
+      },
+    ]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    const turn = body.events.find((e: { type: string }) => e.type === "turn");
+    expect(turn).toBeDefined();
+    expect(turn.assistant_version).toBe("1.2.3-test");
+  });
+
+  test("a single batch can carry mixed per-event versions", async () => {
+    // The whole point of this migration: an old backlogged event keeps
+    // its old version while a freshly recorded event in the same flush
+    // carries the current version. Pre-migration the entire batch would
+    // collapse to the envelope value.
+    const oldEvent = makeUsageEvent({
+      id: "evt-old",
+      assistantVersion: "0.8.3",
+    });
+    const newEvent = makeUsageEvent({
+      id: "evt-new",
+      assistantVersion: "0.8.5",
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([oldEvent, newEvent]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    const versions = body.events.map(
+      (e: { assistant_version: string | null }) => e.assistant_version,
+    );
+    expect(versions.sort()).toEqual(["0.8.3", "0.8.5"]);
+    // Envelope still reflects the running binary, not either event.
+    expect(body.assistant_version).toBe("1.2.3-test");
+  });
 });

package/src/telemetry/usage-telemetry-reporter.ts

@@ -241,6 +241,13 @@ export class UsageTelemetryReporter {
             inference_profile_source: e.inferenceProfileSource,
             cost: e.estimatedCostUsd ?? null,
             recorded_at: e.createdAt,
+            // Record-time version when present; otherwise the running
+            // binary's `APP_VERSION` (a legacy row from before
+            // migration 267 ran). We deliberately don't emit explicit
+            // `null` — under the platform contract a present-but-null
+            // per-event value would override the envelope, and we'd
+            // rather have a concrete version than no version.
+            assistant_version: e.assistantVersion ?? APP_VERSION,
           }),
         ),
         ...turnEvents.map((e): TelemetryEvent => {
@@ -278,6 +285,18 @@ export class UsageTelemetryReporter {
             interface_id: e.interfaceId,
             channel_id: e.channelId,
             client,
+            // Turn events derive from `messages` + `conversations`
+            // rather than a dedicated table. Adding `assistant_version`
+            // to `messages` is a separate (larger) migration; until
+            // then we stamp the running binary's `APP_VERSION` so the
+            // wire value is concrete (matches what the envelope would
+            // have provided, but per-event so it survives the platform
+            // contract that treats present per-event values as winning
+            // over the envelope). Same upload-time attribution risk
+            // for turn events as before this PR — lifecycle, onboarding
+            // and turn events all still rely on the envelope; only
+            // llm_usage is record-time accurate in this PR.
+            assistant_version: APP_VERSION,
           };
         }),
         ...lifecycleEvents.map(
@@ -286,6 +305,12 @@ export class UsageTelemetryReporter {
             daemon_event_id: e.id,
             event_name: e.eventName,
             recorded_at: e.createdAt,
+            // Lifecycle events fall back to the envelope `assistant_version`
+            // — same upload-time attribution risk as before this PR. Adding
+            // the record-time column to `lifecycle_events` (#18112) is a
+            // separate follow-up that mirrors what this PR does for
+            // `llm_usage_events`.
+            assistant_version: APP_VERSION,
           }),
         ),
         ...onboardingEvents.map(
@@ -304,6 +329,12 @@ export class UsageTelemetryReporter {
               ? { google_scopes: JSON.parse(e.googleScopesJson) }
               : {}),
             ...(e.abVariant ? { ab_variant: e.abVariant } : {}),
+            // Onboarding events fall back to the envelope `assistant_version`
+            // — same upload-time attribution risk as before this PR. Adding
+            // the record-time column to `onboarding_events` (#30733) is a
+            // separate follow-up that mirrors what this PR does for
+            // `llm_usage_events`.
+            assistant_version: APP_VERSION,
           }),
         ),
       ];