@vellumai/vellum-gateway 0.7.3 → 0.8.1

package/src/auth/guardian-bootstrap.ts

@@ -98,7 +98,9 @@ interface GuardianLookupRow {
  * Find the existing guardian contact for the "vellum" channel.
  * Mirrors assistant's `findGuardianForChannel("vellum")`.
  */
-async function findVellumGuardian(): Promise<{ principalId: string } | null> {
+export async function findVellumGuardian(): Promise<{
+  principalId: string;
+} | null> {
   const rows = await assistantDbQuery<GuardianLookupRow>(
     `SELECT c.id AS contact_id, c.principal_id
      FROM contacts c

package/src/auth/ipc-route-policy.ts

@@ -48,12 +48,34 @@ type PolicyEntry =
  */
 const POLICY_TABLE: PolicyEntry[] = [
   // Admin / internal
+  //
+  // Every operationId whose daemon-side route policy is gateway-only
+  // (`allowedPrincipalTypes: ["svc_gateway"]` in
+  // `assistant/src/runtime/auth/route-policy.ts`) MUST have a matching
+  // entry here. The gateway IPC proxy default-allows operationIds with
+  // no policy entry, so an authenticated edge JWT could otherwise reach
+  // them by setting `X-Vellum-Proxy-Server: ipc`, bypassing the daemon
+  // HTTP router entirely.
+  //
+  // The `ipc-route-policy-coverage.test.ts` lint enforces this invariant
+  // by walking the daemon route source files at test time.
   ["admin_rollbackmigrations_post", ["internal.write"], ["svc_gateway"]],
+  ["channel_inbound", ["ingress.write"], ["svc_gateway"]],
+  ["emit_event", ["internal.write"], ["svc_gateway"]],
+  ["internal_mcp_add", ["internal.write"], ["svc_gateway"]],
   ["internal_mcp_auth_start", ["internal.write"], ["svc_gateway"]],
   ["internal_mcp_auth_status", ["internal.write"], ["svc_gateway"]],
+  ["internal_mcp_list", ["internal.write"], ["svc_gateway"]],
   ["internal_mcp_reload", ["internal.write"], ["svc_gateway"]],
+  ["internal_mcp_remove", ["internal.write"], ["svc_gateway"]],
+  ["internal_oauth_callback", ["internal.write"], ["svc_gateway"]],
   ["internal_oauth_connect_start", ["internal.write"], ["svc_gateway"]],
   ["internal_oauth_connect_status", ["internal.write"], ["svc_gateway"]],
+  ["internal_twilio_connect_action", ["internal.write"], ["svc_gateway"]],
+  ["internal_twilio_status", ["internal.write"], ["svc_gateway"]],
+  ["internal_twilio_voice_webhook", ["internal.write"], ["svc_gateway"]],
+  ["upgrade_broadcast", ["internal.write"], ["svc_gateway"]],
+  ["workspace_commit", ["internal.write"], ["svc_gateway"]],
 
   // Calls
   ["calls_answer", ["calls.write"]],
@@ -134,6 +156,18 @@ const POLICY_TABLE: PolicyEntry[] = [
   ["listMemoryItems", ["settings.read"]],
   ["updateMemoryItem", ["settings.write"]],
 
+  // Inference profile sessions
+  ["inference_profile_close", ["chat.write"]],
+  ["inference_profile_list", ["chat.read"]],
+  ["inference_profile_open", ["chat.write"]],
+
+  // Inference provider connections
+  ["inference_provider_connections_create", ["settings.write"]],
+  ["inference_provider_connections_delete", ["settings.write"]],
+  ["inference_provider_connections_get", ["settings.read"]],
+  ["inference_provider_connections_list", ["settings.read"]],
+  ["inference_provider_connections_update", ["settings.write"]],
+
   // Notification intent
   ["notificationintentresult_post", ["settings.write"]],
 

package/src/db/assistant-db-proxy.ts

@@ -13,9 +13,12 @@
  * gateway's own database.
  */
 
-import { ipcCallAssistant } from "../ipc/assistant-client.js";
+import {
+  IpcHandlerError,
+  ipcCallAssistant,
+} from "../ipc/assistant-client.js";
 
-type SqliteValue = string | number | null | Uint8Array;
+export type SqliteValue = string | number | null | Uint8Array;
 
 interface DbProxyResult {
   rows?: Record<string, SqliteValue>[];
@@ -28,11 +31,11 @@ async function dbProxy(
   mode: "query" | "run" | "exec",
   bind?: SqliteValue[],
 ): Promise<DbProxyResult> {
-  const result = await ipcCallAssistant("db_proxy", { sql, mode, bind });
-  if (result === undefined) {
-    throw new Error("db_proxy IPC call failed — assistant may not be ready");
-  }
-  return result as DbProxyResult;
+  return (await ipcCallAssistant("db_proxy", {
+    sql,
+    mode,
+    bind,
+  })) as DbProxyResult;
 }
 
 /**
@@ -66,3 +69,69 @@ export async function assistantDbRun(
 export async function assistantDbExec(sql: string): Promise<void> {
   await dbProxy(sql, "exec");
 }
+
+// ---------------------------------------------------------------------------
+// Transaction helper
+// ---------------------------------------------------------------------------
+
+export interface AssistantDbTransactionStep {
+  /** The SQL write statement to execute. */
+  sql: string;
+  /** Positional bind parameters. */
+  bind?: SqliteValue[];
+  /**
+   * If set, abort the transaction (rollback) when this step's row-change
+   * count is below this threshold. Used for stale-write detection — e.g.
+   * "increment use_count only if status = 'active' AND use_count < max_uses",
+   * with `requireChanges: 1` to abort when no rows match.
+   */
+  requireChanges?: number;
+}
+
+export type AssistantDbTransactionResult =
+  | {
+      ok: true;
+      results: Array<{ changes: number; lastInsertRowid: number }>;
+    }
+  | {
+      ok: false;
+      reason: "require_changes_failed";
+      failedStep: number;
+      actualChanges: number;
+      requiredChanges: number;
+    };
+
+/**
+ * Execute multiple write statements against the assistant's SQLite DB inside
+ * a single atomic transaction (BEGIN IMMEDIATE). All steps commit together;
+ * any throw — including a `requireChanges` constraint failure — rolls back
+ * the entire batch.
+ *
+ * Use this when several writes must succeed or fail as a unit (e.g. invite
+ * redemption: contact-channel upsert + invite-use record).
+ *
+ * Error handling:
+ * - `requireChanges` violations return `{ ok: false, reason: "require_changes_failed", ... }`.
+ * - Handler-level failures (SQL constraint errors, malformed params) throw
+ *   `IpcHandlerError` so the underlying SQL message is preserved.
+ * - Transport failures (socket missing, daemon unreachable, timeout) throw
+ *   `IpcTransportError`. Use this to distinguish retryable vs.
+ *   non-retryable failures.
+ *
+ * Read-modify-write across steps is not supported. Use SQL-level conditions
+ * (WHERE clauses, ON CONFLICT) plus `requireChanges` for stale-write detection.
+ */
+export async function assistantDbTransaction(
+  steps: AssistantDbTransactionStep[],
+): Promise<AssistantDbTransactionResult> {
+  return (await ipcCallAssistant("db_proxy_transaction", {
+    steps,
+  })) as AssistantDbTransactionResult;
+}
+
+/**
+ * Re-export so callers in this module's domain (gateway DB write helpers)
+ * can identify SQL/handler failures from the assistant DB proxy without
+ * importing from the IPC client directly.
+ */
+export { IpcHandlerError };