@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/daemon/guardian-action-generators.ts

@@ -1,71 +0,0 @@
-import { loadConfig } from "../config/loader.js";
-import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
-import { getConfiguredProvider } from "../providers/provider-send-message.js";
-import {
-  buildGuardianActionGenerationPrompt,
-  getGuardianActionFallbackMessage,
-  GUARDIAN_ACTION_COPY_MAX_TOKENS,
-  GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
-  GUARDIAN_ACTION_COPY_TIMEOUT_MS,
-  includesRequiredKeywords,
-} from "../runtime/guardian-action-message-composer.js";
-import type { GuardianActionCopyGenerator } from "../runtime/http-types.js";
-
-/**
- * Create the daemon-owned guardian action copy generator that resolves
- * providers and calls `provider.sendMessage` to generate guardian action
- * copy text. Uses the `guardianQuestionCopy` call site so model selection
- * tracks the unified `llm.callSites` configuration.
- *
- * This keeps all provider awareness in the daemon lifecycle, away from
- * the runtime composer.
- */
-export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator {
-  return async (context, options = {}) => {
-    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
-    if (!baseProvider) return null;
-    // Wrap so the per-call `callSite` can route to a different provider
-    // transport when `llm.callSites.guardianQuestionCopy.provider` overrides
-    // the default. Connection-aware: when the resolved profile names a
-    // `provider_connection`, that connection's auth wins over the legacy
-    // registry lookup. See `wrapWithCallSiteRouting`.
-    const provider = wrapWithCallSiteRouting(baseProvider, loadConfig());
-
-    const fallbackText =
-      options.fallbackText?.trim() || getGuardianActionFallbackMessage(context);
-    const requiredKeywords = options.requiredKeywords
-      ?.map((kw) => kw.trim())
-      .filter((kw) => kw.length > 0);
-    const prompt = buildGuardianActionGenerationPrompt(
-      context,
-      fallbackText,
-      requiredKeywords,
-    );
-
-    const response = await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: prompt }] }],
-      {
-        tools: [],
-        systemPrompt: GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
-        config: {
-          max_tokens: options.maxTokens ?? GUARDIAN_ACTION_COPY_MAX_TOKENS,
-          callSite: "guardianQuestionCopy",
-        },
-        signal: AbortSignal.timeout(
-          options.timeoutMs ?? GUARDIAN_ACTION_COPY_TIMEOUT_MS,
-        ),
-      },
-    );
-
-    const block = response.content.find((entry) => entry.type === "text");
-    const text = block && "text" in block ? block.text.trim() : "";
-    if (!text) return null;
-    const cleaned = text
-      .replace(/^["'`]+/, "")
-      .replace(/["'`]+$/, "")
-      .trim();
-    if (!cleaned) return null;
-    if (!includesRequiredKeywords(cleaned, requiredKeywords)) return null;
-    return cleaned;
-  };
-}

package/src/memory/guardian-action-store.ts

@@ -1,484 +0,0 @@
-/**
- * Store for cross-channel guardian action requests and deliveries.
- *
- * Guardian action requests are created when a voice call's ASK_GUARDIAN
- * marker fires, and deliveries track per-channel dispatch (telegram, mac).
- * Resolution uses first-response-wins semantics: the first channel to
- * answer resolves the request and all other deliveries are marked answered.
- */
-
-import { and, desc, eq, inArray, lt } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
-
-import { getDb } from "./db-connection.js";
-import { rawChanges } from "./raw-query.js";
-import { guardianActionDeliveries, guardianActionRequests } from "./schema.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type GuardianActionRequestStatus =
-  | "pending"
-  | "answered"
-  | "expired"
-  | "cancelled";
-export type GuardianActionDeliveryStatus =
-  | "pending"
-  | "sent"
-  | "failed"
-  | "answered"
-  | "expired"
-  | "cancelled";
-export type ExpiredReason =
-  | "call_timeout"
-  | "sweep_timeout"
-  | "cancelled"
-  | "superseded";
-export type FollowupState =
-  | "none"
-  | "awaiting_guardian_choice"
-  | "dispatching"
-  | "completed"
-  | "declined"
-  | "failed";
-/** Follow-up action recorded on a request row (column retained). */
-export type FollowupAction = "call_back" | "decline";
-
-export interface GuardianActionRequest {
-  id: string;
-  kind: string;
-  sourceChannel: string;
-  sourceConversationId: string;
-  callSessionId: string;
-  pendingQuestionId: string;
-  questionText: string;
-  requestCode: string;
-  status: GuardianActionRequestStatus;
-  answerText: string | null;
-  answeredByChannel: string | null;
-  answeredByExternalUserId: string | null;
-  answeredAt: number | null;
-  expiresAt: number;
-  expiredReason: ExpiredReason | null;
-  followupState: FollowupState;
-  lateAnswerText: string | null;
-  lateAnsweredAt: number | null;
-  followupAction: FollowupAction | null;
-  followupCompletedAt: number | null;
-  toolName: string | null;
-  inputDigest: string | null;
-  supersededByRequestId: string | null;
-  supersededAt: number | null;
-  createdAt: number;
-  updatedAt: number;
-}
-
-export interface GuardianActionDelivery {
-  id: string;
-  requestId: string;
-  destinationChannel: string;
-  destinationConversationId: string | null;
-  destinationChatId: string | null;
-  destinationExternalUserId: string | null;
-  status: GuardianActionDeliveryStatus;
-  sentAt: number | null;
-  respondedAt: number | null;
-  lastError: string | null;
-  createdAt: number;
-  updatedAt: number;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function rowToRequest(
-  row: typeof guardianActionRequests.$inferSelect,
-): GuardianActionRequest {
-  return {
-    id: row.id,
-    kind: row.kind,
-    sourceChannel: row.sourceChannel,
-    sourceConversationId: row.sourceConversationId,
-    callSessionId: row.callSessionId,
-    pendingQuestionId: row.pendingQuestionId,
-    questionText: row.questionText,
-    requestCode: row.requestCode,
-    status: row.status as GuardianActionRequestStatus,
-    answerText: row.answerText,
-    answeredByChannel: row.answeredByChannel,
-    answeredByExternalUserId: row.answeredByExternalUserId,
-    answeredAt: row.answeredAt,
-    expiresAt: row.expiresAt,
-    expiredReason: (row.expiredReason as ExpiredReason) ?? null,
-    followupState: (row.followupState as FollowupState) ?? "none",
-    lateAnswerText: row.lateAnswerText ?? null,
-    lateAnsweredAt: row.lateAnsweredAt ?? null,
-    followupAction: (row.followupAction as FollowupAction) ?? null,
-    followupCompletedAt: row.followupCompletedAt ?? null,
-    toolName: row.toolName ?? null,
-    inputDigest: row.inputDigest ?? null,
-    supersededByRequestId: row.supersededByRequestId ?? null,
-    supersededAt: row.supersededAt ?? null,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-  };
-}
-
-function rowToDelivery(
-  row: typeof guardianActionDeliveries.$inferSelect,
-): GuardianActionDelivery {
-  return {
-    id: row.id,
-    requestId: row.requestId,
-    destinationChannel: row.destinationChannel,
-    destinationConversationId: row.destinationConversationId,
-    destinationChatId: row.destinationChatId,
-    destinationExternalUserId: row.destinationExternalUserId,
-    status: row.status as GuardianActionDeliveryStatus,
-    sentAt: row.sentAt,
-    respondedAt: row.respondedAt,
-    lastError: row.lastError,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-  };
-}
-
-/** Generate a short human-readable request code (6 hex chars). */
-function generateRequestCode(): string {
-  return uuid().replace(/-/g, "").slice(0, 6).toUpperCase();
-}
-
-// ---------------------------------------------------------------------------
-// Guardian Action Requests
-// ---------------------------------------------------------------------------
-
-/**
- * @internal Test-only helper. Production code should create guardian requests
- * via `createCanonicalGuardianRequest` in canonical-guardian-store.ts.
- * This function is retained solely so that existing test fixtures that seed
- * legacy guardian action rows continue to compile.
- */
-export function createGuardianActionRequest(params: {
-  kind: string;
-  sourceChannel: string;
-  sourceConversationId: string;
-  callSessionId: string;
-  pendingQuestionId: string;
-  questionText: string;
-  expiresAt: number;
-  toolName?: string;
-  inputDigest?: string;
-}): GuardianActionRequest {
-  const db = getDb();
-  const now = Date.now();
-  const id = uuid();
-
-  const row = {
-    id,
-    kind: params.kind,
-    sourceChannel: params.sourceChannel,
-    sourceConversationId: params.sourceConversationId,
-    callSessionId: params.callSessionId,
-    pendingQuestionId: params.pendingQuestionId,
-    questionText: params.questionText,
-    requestCode: generateRequestCode(),
-    status: "pending" as const,
-    answerText: null,
-    answeredByChannel: null,
-    answeredByExternalUserId: null,
-    answeredAt: null,
-    expiresAt: params.expiresAt,
-    expiredReason: null,
-    followupState: "none" as const,
-    lateAnswerText: null,
-    lateAnsweredAt: null,
-    followupAction: null,
-    followupCompletedAt: null,
-    toolName: params.toolName ?? null,
-    inputDigest: params.inputDigest ?? null,
-    supersededByRequestId: null,
-    supersededAt: null,
-    createdAt: now,
-    updatedAt: now,
-  };
-
-  db.insert(guardianActionRequests).values(row).run();
-  return rowToRequest(row);
-}
-
-export function getGuardianActionRequest(
-  id: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(guardianActionRequests)
-    .where(eq(guardianActionRequests.id, id))
-    .get();
-  return row ? rowToRequest(row) : null;
-}
-
-/**
- * Find the most recent pending guardian action request for a given call session.
- * Used by the consultation timeout handler to mark the linked request as timed out.
- */
-export function getPendingRequestByCallSessionId(
-  callSessionId: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(guardianActionRequests)
-    .where(
-      and(
-        eq(guardianActionRequests.callSessionId, callSessionId),
-        eq(guardianActionRequests.status, "pending"),
-      ),
-    )
-    .orderBy(desc(guardianActionRequests.createdAt))
-    .get();
-  return row ? rowToRequest(row) : null;
-}
-
-/**
- * First-response-wins resolution. Checks that the request is still
- * 'pending' before updating; returns the updated request on success
- * or null if the request was already resolved.
- */
-export function resolveGuardianActionRequest(
-  id: string,
-  answerText: string,
-  answeredByChannel: string,
-  answeredByExternalUserId?: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  // Atomically check-and-update: only update if status is still 'pending'
-  db.update(guardianActionRequests)
-    .set({
-      status: "answered",
-      answerText,
-      answeredByChannel,
-      answeredByExternalUserId: answeredByExternalUserId ?? null,
-      answeredAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "pending"),
-      ),
-    )
-    .run();
-
-  // Check if the update took effect
-  if (rawChanges() === 0) return null;
-
-  // Mark all deliveries as 'answered'
-  db.update(guardianActionDeliveries)
-    .set({ status: "answered", respondedAt: now, updatedAt: now })
-    .where(eq(guardianActionDeliveries.requestId, id))
-    .run();
-
-  return getGuardianActionRequest(id);
-}
-
-/**
- * Expire a guardian action request and all its deliveries.
- */
-export function expireGuardianActionRequest(
-  id: string,
-  reason: ExpiredReason,
-): void {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({
-      status: "expired",
-      expiredReason: reason,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "pending"),
-      ),
-    )
-    .run();
-
-  db.update(guardianActionDeliveries)
-    .set({ status: "expired", updatedAt: now })
-    .where(
-      and(
-        eq(guardianActionDeliveries.requestId, id),
-        inArray(guardianActionDeliveries.status, ["pending", "sent"]),
-      ),
-    )
-    .run();
-}
-
-/**
- * Supersede a pending guardian action request: mark it expired with
- * reason='superseded', record the replacement request ID and timestamp,
- * and expire its active deliveries.
- *
- * Returns the updated request on success, or null if the request was
- * not in 'pending' status (first-writer-wins).
- */
-export function supersedeGuardianActionRequest(
-  id: string,
-  supersededByRequestId: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({
-      status: "expired",
-      expiredReason: "superseded",
-      supersededByRequestId,
-      supersededAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "pending"),
-      ),
-    )
-    .run();
-
-  if (rawChanges() === 0) return null;
-
-  // Also expire active deliveries
-  db.update(guardianActionDeliveries)
-    .set({ status: "expired", updatedAt: now })
-    .where(
-      and(
-        eq(guardianActionDeliveries.requestId, id),
-        inArray(guardianActionDeliveries.status, ["pending", "sent"]),
-      ),
-    )
-    .run();
-
-  return getGuardianActionRequest(id);
-}
-
-/**
- * Get all pending guardian action requests that have expired.
- */
-export function getExpiredGuardianActionRequests(): GuardianActionRequest[] {
-  const db = getDb();
-  const now = Date.now();
-  return db
-    .select()
-    .from(guardianActionRequests)
-    .where(
-      and(
-        eq(guardianActionRequests.status, "pending"),
-        lt(guardianActionRequests.expiresAt, now),
-      ),
-    )
-    .all()
-    .map(rowToRequest);
-}
-
-/**
- * Get all deliveries for a specific request.
- */
-export function getDeliveriesByRequestId(
-  requestId: string,
-): GuardianActionDelivery[] {
-  const db = getDb();
-  return db
-    .select()
-    .from(guardianActionDeliveries)
-    .where(eq(guardianActionDeliveries.requestId, requestId))
-    .all()
-    .map(rowToDelivery);
-}
-
-/**
- * Cancel a guardian action request and all its deliveries.
- */
-export function cancelGuardianActionRequest(id: string): void {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({ status: "cancelled", updatedAt: now })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "pending"),
-      ),
-    )
-    .run();
-
-  db.update(guardianActionDeliveries)
-    .set({ status: "cancelled", updatedAt: now })
-    .where(
-      and(
-        eq(guardianActionDeliveries.requestId, id),
-        inArray(guardianActionDeliveries.status, ["pending", "sent"]),
-      ),
-    )
-    .run();
-}
-
-// ---------------------------------------------------------------------------
-// Guardian Action Deliveries
-// ---------------------------------------------------------------------------
-
-export function createGuardianActionDelivery(params: {
-  requestId: string;
-  destinationChannel: string;
-  destinationConversationId?: string;
-  destinationChatId?: string;
-  destinationExternalUserId?: string;
-}): GuardianActionDelivery {
-  const db = getDb();
-  const now = Date.now();
-  const id = uuid();
-
-  const row = {
-    id,
-    requestId: params.requestId,
-    destinationChannel: params.destinationChannel,
-    destinationConversationId: params.destinationConversationId ?? null,
-    destinationChatId: params.destinationChatId ?? null,
-    destinationExternalUserId: params.destinationExternalUserId ?? null,
-    status: "pending" as const,
-    sentAt: null,
-    respondedAt: null,
-    lastError: null,
-    createdAt: now,
-    updatedAt: now,
-  };
-
-  db.insert(guardianActionDeliveries).values(row).run();
-  return rowToDelivery(row);
-}
-
-export function updateDeliveryStatus(
-  deliveryId: string,
-  status: GuardianActionDeliveryStatus,
-  error?: string,
-): void {
-  const db = getDb();
-  const now = Date.now();
-
-  const updates: Record<string, unknown> = { status, updatedAt: now };
-  if (status === "sent") updates.sentAt = now;
-  if (status === "answered") updates.respondedAt = now;
-  if (error !== undefined) updates.lastError = error;
-
-  db.update(guardianActionDeliveries)
-    .set(updates)
-    .where(eq(guardianActionDeliveries.id, deliveryId))
-    .run();
-}

package/src/runtime/guardian-action-grant-minter.ts

@@ -1,150 +0,0 @@
-/**
- * Shared helper for minting scoped approval grants when a guardian-action
- * request is resolved with tool metadata.
- *
- * Used by both the channel inbound path (inbound-message-handler.ts) and
- * the desktop path (conversation-process.ts) to ensure grants are minted
- * consistently regardless of which channel the guardian answers on.
- */
-
-import { mintGrantFromDecision } from "../approvals/approval-primitive.js";
-import type { GuardianActionRequest } from "../memory/guardian-action-store.js";
-import { getLogger } from "../util/logger.js";
-import { runApprovalConversationTurn } from "./approval-conversation-turn.js";
-import type { ApprovalConversationGenerator } from "./http-types.js";
-
-const log = getLogger("guardian-action-grant-minter");
-
-/** TTL for scoped approval grants minted on guardian-action answer resolution. */
-const GUARDIAN_ACTION_GRANT_TTL_MS = 5 * 60 * 1000;
-
-/**
- * Mint a `tool_signature` scoped grant when a guardian-action request is
- * resolved and the request carries tool metadata (toolName + inputDigest).
- *
- * Classifies the guardian's answer via the conversational approval engine
- * (`runApprovalConversationTurn`). Only `approve_once` produces a grant —
- * guardian-action grants are always single-use `tool_signature` scoped.
- *
- * Skips silently when:
- *   - The resolved request has no toolName/inputDigest (informational consult).
- *   - The guardian's answer is not classified as approval (fail-closed).
- *
- * Fails silently on error -- grant minting is best-effort and must never
- * block the guardian-action answer flow.
- */
-export async function tryMintGuardianActionGrant(params: {
-  request: GuardianActionRequest;
-  answerText: string;
-  decisionChannel: string;
-  guardianExternalUserId?: string;
-  approvalConversationGenerator: ApprovalConversationGenerator;
-}): Promise<void> {
-  const {
-    request,
-    answerText,
-    decisionChannel,
-    guardianExternalUserId,
-    approvalConversationGenerator,
-  } = params;
-
-  // Only mint for requests that carry tool metadata -- informational
-  // ASK_GUARDIAN consults without tool context do not produce grants.
-  if (!request.toolName || !request.inputDigest) {
-    return;
-  }
-
-  // Classify the guardian's answer via the conversational approval engine.
-  // Guardian-action grants are always single-use (approve_once only).
-  let isApproval = false;
-  try {
-    const llmResult = await runApprovalConversationTurn(
-      {
-        toolName: request.toolName,
-        allowedActions: ["approve_once", "reject"],
-        role: "guardian",
-        pendingApprovals: [
-          { requestId: request.id, toolName: request.toolName },
-        ],
-        userMessage: answerText,
-      },
-      approvalConversationGenerator,
-    );
-
-    isApproval = llmResult.disposition === "approve_once";
-
-    log.info(
-      {
-        event: "guardian_action_grant_classification",
-        toolName: request.toolName,
-        requestId: request.id,
-        answerText,
-        llmDisposition: llmResult.disposition,
-        matched: isApproval,
-        decisionChannel,
-      },
-      `Approval classifier returned disposition: ${llmResult.disposition}`,
-    );
-  } catch (err) {
-    // Fail-closed: generator errors must not produce grants.
-    log.warn(
-      {
-        event: "guardian_action_grant_classification_error",
-        toolName: request.toolName,
-        requestId: request.id,
-        err,
-        decisionChannel,
-      },
-      "Approval classifier threw an error; treating as non-approval (fail-closed)",
-    );
-  }
-
-  if (!isApproval) {
-    log.info(
-      {
-        event: "guardian_action_grant_skipped_no_approval",
-        toolName: request.toolName,
-        requestId: request.id,
-        answerText,
-        decisionChannel,
-      },
-      "Skipped grant minting: guardian answer not classified as approval",
-    );
-    return;
-  }
-
-  const result = mintGrantFromDecision({
-    scopeMode: "tool_signature",
-    toolName: request.toolName,
-    inputDigest: request.inputDigest,
-    requestChannel: request.sourceChannel,
-    decisionChannel,
-    executionChannel: null,
-    conversationId: request.sourceConversationId,
-    callSessionId: request.callSessionId,
-    guardianExternalUserId: guardianExternalUserId ?? null,
-    expiresAt: Date.now() + GUARDIAN_ACTION_GRANT_TTL_MS,
-  });
-
-  if (result.ok) {
-    log.info(
-      {
-        event: "guardian_action_grant_minted",
-        toolName: request.toolName,
-        requestId: request.id,
-        callSessionId: request.callSessionId,
-        decisionChannel,
-      },
-      "Minted scoped approval grant for guardian-action answer resolution",
-    );
-  } else {
-    log.error(
-      {
-        reason: result.reason,
-        toolName: request.toolName,
-        requestId: request.id,
-      },
-      "Failed to mint scoped approval grant for guardian-action (non-fatal)",
-    );
-  }
-}