@vellumai/assistant 0.12.2-staging.7 → 0.12.2

package/src/persistence/conversation-tool-surface.ts

@@ -1,86 +0,0 @@
-import { createHash } from "node:crypto";
-
-import { eq, sql } from "drizzle-orm";
-
-import type { ToolDefinition } from "../providers/types.js";
-import { getDb } from "./db-connection.js";
-import { conversationToolSurfaces } from "./schema/index.js";
-
-/**
- * Per-conversation record of the tool definitions the most recent live turn
- * sent to the provider (`conversation_tool_surfaces`).
- *
- * The provider prompt cache is a byte-exact prefix match over
- * `tools -> system -> messages`, so a background wake that forks a
- * conversation can only reuse the source's cached prefix by sending the SAME
- * tools array. Re-deriving the array on the fork cannot guarantee that: the
- * fork may run in another process (a different tool registry), with no
- * connected clients (different host-tool gates), or under a presence the
- * persisted message stamps do not encode. Recording the resolved array and
- * replaying it verbatim can.
- */
-
-/** Content hash of the serialized tools array. */
-export function hashConversationToolSurface(
-  tools: readonly ToolDefinition[],
-): string {
-  return hashToolsJson(JSON.stringify(tools));
-}
-
-function hashToolsJson(toolsJson: string): string {
-  return createHash("sha256").update(toolsJson).digest("hex").slice(0, 32);
-}
-
-/**
- * Persist `tools` as the conversation's current wire tool surface and return
- * its hash. `knownHash` is the hash the caller last recorded for this
- * conversation (undefined when it has recorded nothing this process
- * lifetime): a matching hash skips the statement outright. Otherwise the
- * upsert only rewrites a row whose stored hash differs, so a conversation
- * reloaded from disk never rewrites an unchanged surface either.
- */
-export function recordConversationToolSurface(
-  conversationId: string,
-  tools: readonly ToolDefinition[],
-  knownHash?: string,
-): string {
-  const toolsJson = JSON.stringify(tools);
-  const toolsHash = hashToolsJson(toolsJson);
-  if (knownHash === toolsHash) {
-    return toolsHash;
-  }
-  const updatedAt = Date.now();
-  getDb()
-    .insert(conversationToolSurfaces)
-    .values({ conversationId, toolsJson, toolsHash, updatedAt })
-    .onConflictDoUpdate({
-      target: conversationToolSurfaces.conversationId,
-      set: { toolsJson, toolsHash, updatedAt },
-      setWhere: sql`${conversationToolSurfaces.toolsHash} <> excluded.tools_hash`,
-    })
-    .run();
-  return toolsHash;
-}
-
-/**
- * The tool definitions the conversation's most recent live turn sent, or
- * `null` when no turn has recorded one (or the stored JSON is unreadable).
- */
-export function getConversationToolSurface(
-  conversationId: string,
-): ToolDefinition[] | null {
-  const row = getDb()
-    .select({ toolsJson: conversationToolSurfaces.toolsJson })
-    .from(conversationToolSurfaces)
-    .where(eq(conversationToolSurfaces.conversationId, conversationId))
-    .get();
-  if (!row) {
-    return null;
-  }
-  try {
-    const parsed: unknown = JSON.parse(row.toolsJson);
-    return Array.isArray(parsed) ? (parsed as ToolDefinition[]) : null;
-  } catch {
-    return null;
-  }
-}

package/src/persistence/migrations/378-create-conversation-tool-surfaces.test.ts

@@ -1,78 +0,0 @@
-import { Database } from "bun:sqlite";
-import { describe, expect, test } from "bun:test";
-
-import { drizzle } from "drizzle-orm/bun-sqlite";
-
-import * as schema from "../schema.js";
-import { migrateCreateConversationToolSurfaces } from "./378-create-conversation-tool-surfaces.js";
-
-function createTestDb() {
-  const sqlite = new Database(":memory:");
-  sqlite.run("PRAGMA foreign_keys = ON");
-  // Only the parent table the FK points at.
-  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
-  return { sqlite, db: drizzle(sqlite, { schema }) };
-}
-
-function tableDdl(sqlite: Database): string | undefined {
-  const row = sqlite
-    .query(
-      `SELECT sql FROM sqlite_master WHERE type='table' AND name='conversation_tool_surfaces'`,
-    )
-    .get() as { sql: string } | null;
-  return row?.sql;
-}
-
-function insertSurface(sqlite: Database, conversationId: string): void {
-  sqlite
-    .query(
-      /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
-    )
-    .run(conversationId, "[]", "hash", 1);
-}
-
-function surfaceCount(sqlite: Database): number {
-  const row = sqlite
-    .query(`SELECT COUNT(*) AS n FROM conversation_tool_surfaces`)
-    .get() as { n: number };
-  return row.n;
-}
-
-describe("migration 378: conversation_tool_surfaces", () => {
-  test("creates the table keyed by conversation with a cascading FK", () => {
-    const { sqlite, db } = createTestDb();
-    expect(tableDdl(sqlite)).toBeUndefined();
-
-    migrateCreateConversationToolSurfaces(db);
-
-    const ddl = tableDdl(sqlite);
-    expect(ddl).toContain("conversation_id TEXT PRIMARY KEY");
-    expect(ddl).toContain("REFERENCES conversations(id) ON DELETE CASCADE");
-    expect(ddl).toContain("tools_json TEXT NOT NULL");
-    expect(ddl).toContain("tools_hash TEXT NOT NULL");
-    expect(ddl).toContain("updated_at INTEGER NOT NULL");
-  });
-
-  test("deleting a conversation cascades to its surface row", () => {
-    const { sqlite, db } = createTestDb();
-    migrateCreateConversationToolSurfaces(db);
-    sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
-    insertSurface(sqlite, "conv-1");
-    expect(surfaceCount(sqlite)).toBe(1);
-
-    sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
-
-    expect(surfaceCount(sqlite)).toBe(0);
-  });
-
-  test("is idempotent: a second run keeps the table and its rows", () => {
-    const { sqlite, db } = createTestDb();
-    migrateCreateConversationToolSurfaces(db);
-    sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
-    insertSurface(sqlite, "conv-1");
-
-    expect(() => migrateCreateConversationToolSurfaces(db)).not.toThrow();
-
-    expect(surfaceCount(sqlite)).toBe(1);
-  });
-});

package/src/persistence/migrations/378-create-conversation-tool-surfaces.ts

@@ -1,29 +0,0 @@
-import type { DrizzleDb } from "../db-connection.js";
-
-const TABLE = "conversation_tool_surfaces";
-
-/**
- * Create `conversation_tool_surfaces`: one row per conversation holding the
- * tool definitions its most recent live turn sent to the provider, keyed by
- * conversation with a content hash so an unchanged surface is never rewritten.
- *
- * Its own table rather than a column on `conversations` because the payload
- * is a JSON array of every tool definition (tens of kilobytes) that only fork
- * wakes read, while `conversations` rows are read whole on every hot path.
- * The row cascades with its conversation, so a deleted conversation leaves
- * no surface behind.
- *
- * Idempotent via IF NOT EXISTS.
- */
-export function migrateCreateConversationToolSurfaces(
-  database: DrizzleDb,
-): void {
-  database.run(
-    `CREATE TABLE IF NOT EXISTS ${TABLE} (
-       conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
-       tools_json TEXT NOT NULL,
-       tools_hash TEXT NOT NULL,
-       updated_at INTEGER NOT NULL
-     )`,
-  );
-}

package/src/persistence/schema/conversation-tool-surfaces.ts

@@ -1,22 +0,0 @@
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-
-import { conversations } from "./conversations.js";
-
-/**
- * The tool definitions a conversation's most recent live turn sent to the
- * provider, serialized exactly as resolved. Written by the per-turn tool
- * resolver when the array changes; read by fork wakes that replay it so their
- * provider prompt-cache prefix matches the source's live turns. Cascades with
- * its conversation.
- */
-export const conversationToolSurfaces = sqliteTable(
-  "conversation_tool_surfaces",
-  {
-    conversationId: text("conversation_id")
-      .primaryKey()
-      .references(() => conversations.id, { onDelete: "cascade" }),
-    toolsJson: text("tools_json").notNull(),
-    toolsHash: text("tools_hash").notNull(),
-    updatedAt: integer("updated_at").notNull(),
-  },
-);

package/src/plugin-api/plugin-channel-turn-trust.test.ts

@@ -1,133 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-type InboundTrustReadResult =
-  | {
-      ok: true;
-      verdict: {
-        trustClass: string;
-        canonicalSenderId: string | null;
-        contactId?: string;
-        status?: string;
-        resolutionFailed?: boolean;
-      };
-      admissionPolicy: string | null;
-    }
-  | { ok: false };
-
-let nextRead: InboundTrustReadResult = { ok: false };
-
-mock.module("../calls/inbound-trust-reader.js", () => ({
-  readInboundTrust: async () => nextRead,
-}));
-
-import {
-  PluginTurnNotAdmittedError,
-  resolvePluginChannelTurnTrust,
-} from "./plugin-channel-turn-trust.js";
-
-const CHANNEL = {
-  sourceChannel: "plugin" as const,
-  externalChatId: "imessage:+12025550142",
-  externalUserId: "imessage:+12025550142",
-  displayName: "Ada",
-};
-
-beforeEach(() => {
-  nextRead = { ok: false };
-});
-
-describe("resolvePluginChannelTurnTrust", () => {
-  test("returns the gateway verdict as the turn trust context", async () => {
-    nextRead = {
-      ok: true,
-      verdict: {
-        trustClass: "trusted_contact",
-        canonicalSenderId: "imessage:+12025550142",
-        contactId: "c-ada",
-        status: "active",
-      },
-      admissionPolicy: "trusted_contacts",
-    };
-
-    const trust = await resolvePluginChannelTurnTrust(CHANNEL);
-    expect(trust.trustClass).toBe("trusted_contact");
-    expect(trust.sourceChannel).toBe("plugin");
-    expect(trust.requesterChatId).toBe(CHANNEL.externalChatId);
-  });
-
-  test("fails closed when the gateway could not vouch for the sender", async () => {
-    nextRead = {
-      ok: true,
-      verdict: {
-        trustClass: "unknown",
-        canonicalSenderId: null,
-        resolutionFailed: true,
-      },
-      admissionPolicy: "strangers",
-    };
-
-    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
-      name: "PluginTurnNotAdmittedError",
-      reason: "trust_resolution_failed",
-    });
-  });
-
-  test("fails closed when the gateway trust read fails", async () => {
-    nextRead = { ok: false };
-    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
-      name: "PluginTurnNotAdmittedError",
-      reason: "trust_resolution_failed",
-    });
-  });
-
-  test("rejects a sender below the channel admission floor", async () => {
-    nextRead = {
-      ok: true,
-      verdict: { trustClass: "unknown", canonicalSenderId: null },
-      admissionPolicy: "guardian_only",
-    };
-
-    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toEqual(
-      expect.objectContaining({
-        name: "PluginTurnNotAdmittedError",
-        reason: "admission_policy_guardian_only",
-      }),
-    );
-  });
-
-  test("rejects a blocked member regardless of floor", async () => {
-    nextRead = {
-      ok: true,
-      verdict: {
-        trustClass: "trusted_contact",
-        canonicalSenderId: "imessage:+12025550142",
-        contactId: "c-ada",
-        status: "blocked",
-      },
-      admissionPolicy: "strangers",
-    };
-
-    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
-      name: "PluginTurnNotAdmittedError",
-      reason: "member_blocked",
-    });
-  });
-
-  test("admits when the gateway reports no admission policy", async () => {
-    nextRead = {
-      ok: true,
-      verdict: { trustClass: "unknown", canonicalSenderId: null },
-      admissionPolicy: null,
-    };
-
-    const trust = await resolvePluginChannelTurnTrust(CHANNEL);
-    expect(trust.trustClass).toBe("unknown");
-  });
-
-  test("PluginTurnNotAdmittedError names the deny reason", () => {
-    const err = new PluginTurnNotAdmittedError("admission_policy_no_one");
-    expect(err).toBeInstanceOf(Error);
-    expect(err.reason).toBe("admission_policy_no_one");
-    expect(err.message).toContain("admission_policy_no_one");
-  });
-});

package/src/plugin-api/plugin-channel-turn-trust.ts

@@ -1,71 +0,0 @@
-/**
- * Gateway admission and trust for plugin turns addressed by a channel chat.
- *
- * A channel address means an inbound sender, not an internal plugin job.
- * Trust comes from the gateway verdict (`resolve_inbound_trust`); the turn
- * runs only when that sender clears the channel admission floor.
- */
-
-import { meetsAdmissionFloor } from "@vellumai/gateway-client";
-
-import { readInboundTrust } from "../calls/inbound-trust-reader.js";
-import type { ChannelId } from "../channels/types.js";
-import type { TrustContext } from "../daemon/trust-context-types.js";
-import { trustContextFromVerdict } from "../runtime/trust-verdict-consumer.js";
-
-interface PluginChannelTurnAddress {
-  sourceChannel: ChannelId;
-  externalChatId: string;
-  externalUserId?: string | null;
-  displayName?: string | null;
-  username?: string | null;
-}
-
-export class PluginTurnNotAdmittedError extends Error {
-  readonly reason: string;
-
-  constructor(reason: string) {
-    super(`This inbound plugin turn was not admitted (${reason}).`);
-    this.name = "PluginTurnNotAdmittedError";
-    this.reason = reason;
-  }
-}
-
-export async function resolvePluginChannelTurnTrust(
-  channel: PluginChannelTurnAddress,
-): Promise<TrustContext> {
-  const actorExternalId = channel.externalUserId?.trim() || undefined;
-  const read = await readInboundTrust({
-    channelType: channel.sourceChannel,
-    actorExternalId,
-  });
-  if (!read.ok) {
-    throw new PluginTurnNotAdmittedError("trust_resolution_failed");
-  }
-
-  if (read.verdict.resolutionFailed) {
-    throw new PluginTurnNotAdmittedError("trust_resolution_failed");
-  }
-
-  const memberStatus = read.verdict.status;
-  if (memberStatus === "blocked" || memberStatus === "revoked") {
-    throw new PluginTurnNotAdmittedError(`member_${memberStatus}`);
-  }
-
-  const trustClass = read.verdict.trustClass;
-  if (
-    read.admissionPolicy != null &&
-    !meetsAdmissionFloor(read.admissionPolicy, trustClass)
-  ) {
-    throw new PluginTurnNotAdmittedError(
-      `admission_policy_${read.admissionPolicy}`,
-    );
-  }
-
-  return trustContextFromVerdict(read.verdict, {
-    sourceChannel: channel.sourceChannel,
-    conversationExternalId: channel.externalChatId,
-    actorDisplayName: channel.displayName ?? undefined,
-    actorUsername: channel.username ?? undefined,
-  });
-}