@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/subagent/manager.ts

@@ -237,10 +237,17 @@ export class SubagentManager {
         config.systemPromptOverride ??
         buildSubagentSystemPrompt({ ...config, id: subagentId }, role);
     }
-    const maxTokens = resolveCallSiteConfig(
-      "subagentSpawn",
-      appConfig.llm,
-    ).maxTokens;
+    // Resolve under the same profile the run will use (forwarded via
+    // `SubagentConfig`) so the constructed conversation's default token cap
+    // matches the inherited profile rather than the static `subagentSpawn`
+    // default. Per-call routing re-resolves the model anyway; this keeps the
+    // initial value consistent.
+    const maxTokens = resolveCallSiteConfig("subagentSpawn", appConfig.llm, {
+      ...(config.overrideProfile
+        ? { overrideProfile: config.overrideProfile }
+        : {}),
+      ...(config.forceOverrideProfile ? { forceOverrideProfile: true } : {}),
+    }).maxTokens;
     const workingDir = getSandboxWorkingDir();
 
     // ── Initialise state ────────────────────────────────────────────

package/src/telemetry/trace-collection-policy.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  isDiagnosticsConsentVersionEligible,
+  TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION,
+} from "./trace-collection-policy.js";
+
+describe("isDiagnosticsConsentVersionEligible", () => {
+  test("the threshold version itself is eligible (>=, inclusive boundary)", () => {
+    expect(
+      isDiagnosticsConsentVersionEligible(
+        TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION,
+      ),
+    ).toBe(true);
+  });
+
+  test("a later version is eligible", () => {
+    expect(isDiagnosticsConsentVersionEligible("2999-01-01")).toBe(true);
+  });
+
+  test("an earlier version fails closed", () => {
+    expect(isDiagnosticsConsentVersionEligible("2000-01-01")).toBe(false);
+  });
+
+  test("the empty version (never accepted / unversioned default) fails closed", () => {
+    expect(isDiagnosticsConsentVersionEligible("")).toBe(false);
+  });
+});

package/src/telemetry/trace-collection-policy.ts

@@ -0,0 +1,30 @@
+/**
+ * Per-turn trace-collection disclosure gate (daemon side).
+ *
+ * A "trace" is the full transcript of one assistant turn. Traces are only
+ * collected from owners who accepted the diagnostics-sharing consent copy that
+ * *discloses* trace collection — identified by its accepted version.
+ *
+ * This mirrors the platform's authoritative ingest gate in
+ * `vellum-assistant-platform`:
+ *   - `django/app/core/trace_collection.py` (`is_trace_collection_enabled`)
+ *   - `config.settings.TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION`
+ *
+ * The daemon applies the same `share_diagnostics_accepted_version >= threshold`
+ * check the platform does, so traces for ineligible owners never leave the
+ * device. (The platform would drop them anyway, but checking here keeps the PII
+ * local — data minimization.)
+ *
+ * Keep this constant in lockstep with the platform setting. Versions are
+ * "YYYY-MM-DD" strings, so the lexicographic compare is chronological; ""
+ * (never accepted) and older versions fail closed.
+ */
+export const TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION = "2026-06-18";
+
+/**
+ * True iff `version` (the owner's `share_diagnostics_accepted_version`) is at or
+ * past the disclosing version. Fails closed for "" / older versions.
+ */
+export function isDiagnosticsConsentVersionEligible(version: string): boolean {
+  return version >= TRACE_COLLECTION_MIN_DIAGNOSTICS_CONSENT_VERSION;
+}

package/src/telemetry/types.ts

@@ -147,6 +147,82 @@ export interface TurnTelemetryClientInfo {
   interface_version?: string;
 }
 
+/**
+ * One message in a turn trace. `role` is the stored `messages.role`
+ * (`"user"` / `"assistant"` / `"system"`); tool-result rows persisted with
+ * role `"user"` keep that role here so the transcript is faithful to what was
+ * sent to the model. `content` is the parsed `messages.content` — either the
+ * modern `ContentBlock[]` (text / tool_use / tool_result / thinking / image /
+ * file blocks) or a legacy plain string. Stored verbatim by the platform as an
+ * opaque JSON column, so the shape is self-describing rather than normalized.
+ */
+export interface TurnTraceMessage {
+  /** `messages.id` — stable per-row id. */
+  id: string;
+  /** Stored role of the message row. */
+  role: string;
+  /** Epoch-ms `messages.created_at`. */
+  created_at: number;
+  /**
+   * Parsed `messages.content`. `unknown` because it is forwarded verbatim:
+   * modern rows are `ContentBlock[]`, legacy rows are a plain string.
+   */
+  content: unknown;
+}
+
+/**
+ * One tool invocation in a turn trace, projected from the `tool_invocations`
+ * audit table for the turn window. Carries the full tool call + result so the
+ * platform sees the same transcript the assistant did. Both `input` and
+ * `result` are captured verbatim (full-fidelity) — no field-level redaction is
+ * applied. The protections for this PII are the owner consent gate, the
+ * PII-segregated `pii_turn_raw` table, and its 30-day TTL.
+ */
+export interface TurnTraceToolCall {
+  /** `tool_invocations.id`. */
+  id: string;
+  tool_name: string;
+  /** Verbatim tool input — parsed JSON when it parses, else the raw string. */
+  input: unknown;
+  /** Stored tool result string (verbatim). */
+  result: string;
+  /** Audit decision (`"allow"` / `"error"` / …). */
+  decision: string;
+  duration_ms: number;
+  created_at: number;
+}
+
+/**
+ * Full transcript of a single turn — the user message, assistant response
+ * message(s), and the tool calls + results that occurred between this user
+ * turn and the next real user turn. Attached to the turn telemetry event's
+ * `trace` field ONLY when trace collection is enabled — the `trace-collection`
+ * feature flag AND the owner's `share_diagnostics` consent must both be true.
+ * The platform stores this verbatim as an opaque JSON column, so the daemon
+ * owns the shape.
+ *
+ * Each turn's trace is its natural window. A turn whose window holds no
+ * assistant response (a coalesced-batch head, or a turn that failed/cancelled
+ * before responding) traces user-only — faithful, since its window genuinely
+ * has no response. A coalesced batch's shared response lives on the batch's
+ * final turn's window, where the daemon already attributes it.
+ */
+export interface TurnTrace {
+  /** Shape version so the platform/dbt can evolve parsing without ambiguity. */
+  schema_version: 1;
+  /**
+   * Ordered message rows for the turn (the user message first, then assistant
+   * responses and any tool-result rows), oldest-first by `(created_at, id)`.
+   */
+  messages: TurnTraceMessage[];
+  /**
+   * Tool invocations that occurred during the turn window, oldest-first. May
+   * be empty for turns with no tool use. Projected from `tool_invocations`,
+   * which complements the inline tool_use/tool_result blocks in `messages`.
+   */
+  tool_calls: TurnTraceToolCall[];
+}
+
 /** Turn event — one per user message. */
 export interface TurnTelemetryEvent extends TelemetryEventBase {
   type: "turn";
@@ -200,6 +276,19 @@ export interface TurnTelemetryEvent extends TelemetryEventBase {
    * middleware hasn't been wired to yet).
    */
   client: TurnTelemetryClientInfo | null;
+  /**
+   * Full per-turn transcript (user message + assistant responses + tool
+   * calls/results). Present ONLY when trace collection is enabled — the daemon
+   * composes the gate itself from the `trace-collection` feature flag (delivered
+   * via the assistant-tagged flag sync, evaluated server-side for this
+   * assistant's owner) AND the owner's cached `share_diagnostics` consent, both
+   * of which must be true. Fail-closed: when either is off (or unknown) no trace
+   * is attached. The platform dual-writes consented traces into a separate PII
+   * table and keeps the trace-free turn row; downstream consumers that don't
+   * read traces ignore this field. Null / absent when the gate is off or the
+   * serialized trace exceeded the size cap.
+   */
+  trace?: TurnTrace | null;
 }
 
 /** Lifecycle event — app_open, hatch, etc. */