@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/node_modules/@slack/types/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@slack/types",
+  "version": "2.21.1",
+  "description": "Shared type definitions for the Node Slack SDK",
+  "author": "Slack Technologies, LLC",
+  "license": "MIT",
+  "keywords": [
+    "slack",
+    "typescript",
+    "types",
+    "api"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "engines": {
+    "node": ">= 12.13.0",
+    "npm": ">= 6.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slackapi/node-slack-sdk.git"
+  },
+  "homepage": "https://docs.slack.dev/tools/node-slack-sdk/reference/types/",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/slackapi/node-slack-sdk/issues"
+  },
+  "scripts": {
+    "build": "npm run build:clean && tsc",
+    "build:clean": "shx rm -rf ./dist",
+    "docs": "npx typedoc --plugin typedoc-plugin-markdown",
+    "prepack": "npm run build",
+    "test": "npm run build && npm run test:types",
+    "test:types": "tsd"
+  },
+  "devDependencies": {
+    "tsd": "^0.33.0"
+  },
+  "tsd": {
+    "directory": "test"
+  }
+}

package/node_modules/@vellumai/gateway-client/bun.lock

@@ -5,6 +5,7 @@
     "": {
       "name": "@vellumai/gateway-client",
       "dependencies": {
+        "@slack/types": "2.21.1",
         "@vellumai/service-contracts": "file:../service-contracts",
         "zod": "4.3.6",
       },
@@ -15,6 +16,8 @@
     },
   },
   "packages": {
+    "@slack/types": ["@slack/types@2.21.1", "", {}, "sha512-I8vmSjNYWsaxuWPx6dz4yeh0h7vRBWbgAMK14LEmblbZ404BtrPbXs6jDPx4cYgGf8msDGF4A9opLZBu21FViQ=="],
+
     "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
 
     "@types/node": ["@types/node@25.6.0", "", { "dependencies": { "undici-types": "~7.19.0" } }, "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ=="],

package/node_modules/@vellumai/gateway-client/package.json

@@ -15,6 +15,7 @@
     "test": "bun test src/"
   },
   "dependencies": {
+    "@slack/types": "2.21.1",
     "@vellumai/service-contracts": "file:../service-contracts",
     "zod": "4.3.6"
   },

package/node_modules/@vellumai/gateway-client/src/__tests__/contact-read-contracts.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Tests for the contact read IPC contracts in gateway-ipc-contracts.ts.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  ContactReadSchema,
+  GetContactIpcParamsSchema,
+  ListContactsIpcParamsSchema,
+} from "../gateway-ipc-contracts.js";
+
+describe("contact read contracts", () => {
+  test("ContactReadSchema parses a fully-populated contact", () => {
+    const contact = {
+      id: "c1",
+      displayName: "Example User",
+      role: "guardian",
+      notes: "primary guardian",
+      contactType: "human",
+      lastInteraction: 1700000000,
+      interactionCount: 12,
+      createdAt: 1699000000,
+      updatedAt: 1700000000,
+      channels: [
+        {
+          id: "ch1",
+          contactId: "c1",
+          type: "imessage",
+          address: "+15555550100",
+          isPrimary: true,
+          externalUserId: "+15555550100",
+          status: "active",
+          policy: "allow",
+          verifiedAt: 1699999999,
+          verifiedVia: "voice",
+          lastSeenAt: 1700000001,
+          interactionCount: 12,
+          lastInteraction: 1700000000,
+          revokedReason: null,
+          blockedReason: null,
+        },
+      ],
+    };
+
+    const parsed = ContactReadSchema.parse(contact);
+    expect(parsed.createdAt).toBe(1699000000);
+    expect(parsed.updatedAt).toBe(1700000000);
+  });
+
+  test("ContactReadSchema requires createdAt/updatedAt", () => {
+    const withoutTimestamps = {
+      id: "c1",
+      displayName: "Example User",
+      role: "contact",
+      interactionCount: 0,
+      channels: [],
+    };
+    expect(() => ContactReadSchema.parse(withoutTimestamps)).toThrow();
+  });
+
+  test("ListContactsIpcParamsSchema defaults to {} when given undefined", () => {
+    expect(ListContactsIpcParamsSchema.parse(undefined)).toEqual({});
+  });
+
+  test("GetContactIpcParamsSchema rejects an empty object", () => {
+    expect(() => GetContactIpcParamsSchema.parse({})).toThrow();
+  });
+});

package/node_modules/@vellumai/gateway-client/src/__tests__/trust-verdict-contract.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Tests for the shared trust verdict contract and its optional placement on
+ * the inbound payload's sourceMetadata.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { SourceMetadataSchema } from "../inbound-contract.js";
+import {
+  TrustVerdictSchema,
+  type TrustVerdict,
+} from "../trust-verdict-contract.js";
+
+const fullVerdict: TrustVerdict = {
+  trustClass: "trusted_contact",
+  canonicalSenderId: "+15555550100",
+  guardianExternalUserId: "g-ext-1",
+  guardianDeliveryChatId: "chat-1",
+  guardianPrincipalId: "g-principal-1",
+  guardianDisplayName: "Guardian Name",
+  contactId: "c1",
+  channelId: "ch1",
+  type: "imessage",
+  address: "+15555550100",
+  externalChatId: "ext-chat-1",
+  status: "active",
+  policy: "allow",
+  verifiedAt: 1699999999,
+  verifiedVia: "voice",
+  memberDisplayName: "Member Name",
+};
+
+describe("TrustVerdictSchema", () => {
+  test("round-trips a fully-populated verdict", () => {
+    expect(TrustVerdictSchema.parse(fullVerdict)).toEqual(fullVerdict);
+  });
+
+  test("parses a minimal verdict", () => {
+    const minimal = {
+      trustClass: "unknown",
+      canonicalSenderId: null,
+    } satisfies TrustVerdict;
+    expect(TrustVerdictSchema.parse(minimal)).toEqual(minimal);
+  });
+
+  test("rejects an invalid trustClass", () => {
+    expect(() =>
+      TrustVerdictSchema.parse({
+        trustClass: "definitely_not_a_class",
+        canonicalSenderId: null,
+      }),
+    ).toThrow();
+  });
+});
+
+describe("SourceMetadataSchema trustVerdict back-compat", () => {
+  test("parses an empty payload (no trustVerdict)", () => {
+    expect(SourceMetadataSchema.parse({})).toEqual({});
+  });
+
+  test("round-trips a payload carrying trustVerdict", () => {
+    const parsed = SourceMetadataSchema.parse({ trustVerdict: fullVerdict });
+    expect(parsed.trustVerdict).toEqual(fullVerdict);
+  });
+});

package/node_modules/@vellumai/gateway-client/src/gateway-ipc-contracts.ts

@@ -85,3 +85,165 @@ export const TrustRulesListIpcResponseSchema = z.object({
 export type TrustRulesListIpcResponse = z.infer<
   typeof TrustRulesListIpcResponseSchema
 >;
+
+export const UpdateContactChannelIpcParamsSchema = z.object({
+  contactChannelId: z.string().min(1),
+  status: z.string().optional(),
+  policy: z.string().optional(),
+  reason: z.string().optional(),
+});
+
+export type UpdateContactChannelIpcParams = z.infer<
+  typeof UpdateContactChannelIpcParamsSchema
+>;
+
+export const UpdateContactChannelIpcResponseSchema = z.object({
+  ok: z.boolean(),
+  // The gateway-native handler owns the full contact payload shape; pass it
+  // through verbatim rather than re-declaring channel fields here.
+  contact: z.object({}).passthrough().optional(),
+});
+
+export type UpdateContactChannelIpcResponse = z.infer<
+  typeof UpdateContactChannelIpcResponseSchema
+>;
+
+export const MarkChannelVerifiedIpcParamsSchema = z.object({
+  contactChannelId: z.string().min(1),
+  // Audit source for the verification. CLI/session-driven verifications
+  // pass "challenge"; manual guardian attest uses "manual" (HTTP path).
+  verifiedVia: z.enum(["challenge", "manual"]).default("challenge"),
+});
+
+export type MarkChannelVerifiedIpcParams = z.infer<
+  typeof MarkChannelVerifiedIpcParamsSchema
+>;
+
+export const MarkChannelVerifiedIpcResponseSchema = z.object({
+  ok: z.boolean(),
+  didWrite: z.boolean(),
+  channel: z.object({
+    id: z.string(),
+    contactId: z.string(),
+    type: z.string(),
+    address: z.string(),
+    status: z.string(),
+    verifiedAt: z.number().nullable(),
+    verifiedVia: z.string().nullable(),
+  }),
+});
+
+export type MarkChannelVerifiedIpcResponse = z.infer<
+  typeof MarkChannelVerifiedIpcResponseSchema
+>;
+
+export const MarkChannelRevokedIpcParamsSchema = z.object({
+  contactChannelId: z.string().min(1),
+  // Audit reason for the downgrade. The verification-revoke flow passes
+  // "guardian_binding_revoked", the only reason allowed to downgrade a
+  // guardian channel (guardian guard, invariant 4).
+  reason: z.string().optional(),
+});
+
+export type MarkChannelRevokedIpcParams = z.infer<
+  typeof MarkChannelRevokedIpcParamsSchema
+>;
+
+export const MarkChannelRevokedIpcResponseSchema = z.object({
+  ok: z.boolean(),
+  didWrite: z.boolean(),
+  channel: z.object({
+    id: z.string(),
+    contactId: z.string(),
+    type: z.string(),
+    address: z.string(),
+    status: z.string(),
+    revokedReason: z.string().nullable(),
+  }),
+});
+
+export type MarkChannelRevokedIpcResponse = z.infer<
+  typeof MarkChannelRevokedIpcResponseSchema
+>;
+
+export const ContactReadChannelSchema = z.object({
+  id: z.string(),
+  contactId: z.string(),
+  type: z.string(),
+  address: z.string(),
+  isPrimary: z.boolean(),
+  externalUserId: z.string().nullable(),
+  status: z.string(),
+  policy: z.string(),
+  verifiedAt: z.number().nullable(),
+  verifiedVia: z.string().nullable(),
+  lastSeenAt: z.number().nullable(),
+  interactionCount: z.number(),
+  lastInteraction: z.number().nullable(),
+  revokedReason: z.string().nullable(),
+  blockedReason: z.string().nullable(),
+});
+
+export type ContactReadChannel = z.infer<typeof ContactReadChannelSchema>;
+
+export const ContactReadSchema = z.object({
+  id: z.string(),
+  displayName: z.string(),
+  role: z.string(),
+  notes: z.string().nullable().optional(),
+  contactType: z.string().nullable().optional(),
+  lastInteraction: z.number().nullable().optional(),
+  interactionCount: z.number(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  channels: z.array(ContactReadChannelSchema),
+});
+
+export type ContactRead = z.infer<typeof ContactReadSchema>;
+
+export const AssistantContactMetadataSchema = z.object({
+  contactId: z.string(),
+  species: z.string(),
+  metadata: z.object({}).passthrough().nullable(),
+});
+
+export type AssistantContactMetadata = z.infer<
+  typeof AssistantContactMetadataSchema
+>;
+
+export const ListContactsIpcParamsSchema = z
+  .object({
+    limit: z.number().optional(),
+    role: z.string().optional(),
+  })
+  .strict()
+  .default({});
+
+export type ListContactsIpcParams = z.infer<
+  typeof ListContactsIpcParamsSchema
+>;
+
+export const ListContactsIpcResponseSchema = z.object({
+  ok: z.boolean(),
+  contacts: z.array(ContactReadSchema),
+});
+
+export type ListContactsIpcResponse = z.infer<
+  typeof ListContactsIpcResponseSchema
+>;
+
+export const GetContactIpcParamsSchema = z
+  .object({ contactId: z.string() })
+  .strict();
+
+export type GetContactIpcParams = z.infer<typeof GetContactIpcParamsSchema>;
+
+export const GetContactIpcResponseSchema = z.object({
+  ok: z.boolean(),
+  contact: ContactReadSchema,
+  assistantMetadata: AssistantContactMetadataSchema.optional(),
+});
+
+export type GetContactIpcResponse = z.infer<
+  typeof GetContactIpcResponseSchema
+>;

package/node_modules/@vellumai/gateway-client/src/inbound-contract.ts

@@ -13,6 +13,7 @@
 import { z } from "zod";
 
 import { AdmissionPolicySchema } from "./admission-policy-contract.js";
+import { TrustVerdictSchema } from "./trust-verdict-contract.js";
 
 // ---------------------------------------------------------------------------
 // Command intent (channel-initiated commands, e.g. Telegram /start)
@@ -77,6 +78,13 @@ export const SourceMetadataSchema = z
      */
     admissionPolicy: AdmissionPolicySchema.optional(),
 
+    /**
+     * Per-actor trust verdict resolved by the gateway from its ACL DB;
+     * absent until the gateway stamps it. Consumers must treat absence as
+     * "not provided", never as a decision.
+     */
+    trustVerdict: TrustVerdictSchema.optional(),
+
     // Email-specific fields
     /** Email subject line. */
     emailSubject: z.string().optional(),

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -70,3 +70,17 @@ export {
 } from "./admission-policy-contract.js";
 
 export type { AdmissionPolicy } from "./admission-policy-contract.js";
+
+// Trust verdict contract (gateway → daemon) — Zod schemas + derived types
+export {
+  ResolveInboundTrustRequestSchema,
+  TRUST_CLASS_VALUES,
+  TrustClassSchema,
+  TrustVerdictSchema,
+} from "./trust-verdict-contract.js";
+
+export type {
+  ResolveInboundTrustRequest,
+  TrustClass,
+  TrustVerdict,
+} from "./trust-verdict-contract.js";

package/node_modules/@vellumai/gateway-client/src/ipc-client.ts

@@ -219,11 +219,13 @@ export class PersistentIpcClient {
   async call(
     method: string,
     params?: Record<string, unknown>,
+    timeoutMs?: number,
   ): Promise<unknown> {
     await this.ensureConnected();
 
     const id = String(this.nextId++);
     const req: IpcRequest = { id, method, params };
+    const callTimeoutMs = timeoutMs ?? this.callTimeoutMs;
 
     return new Promise<unknown>((resolve, reject) => {
       const timer = setTimeout(() => {
@@ -232,11 +234,11 @@ export class PersistentIpcClient {
           this.pending.delete(id);
           entry.reject(
             new Error(
-              `IPC call "${method}" timed out after ${this.callTimeoutMs}ms`,
+              `IPC call "${method}" timed out after ${callTimeoutMs}ms`,
             ),
           );
         }
-      }, this.callTimeoutMs);
+      }, callTimeoutMs);
       timer.unref();
 
       this.pending.set(id, { resolve, reject, timer });

package/node_modules/@vellumai/gateway-client/src/outbound-contract.ts

@@ -10,6 +10,7 @@
  * to the target channel provider.
  */
 
+import type { KnownBlock } from "@slack/types";
 import { z } from "zod";
 
 // ---------------------------------------------------------------------------
@@ -68,7 +69,7 @@ export const ChannelReplyPayloadSchema = z.object({
   chatId: z.string(),
   text: z.string().optional(),
   /** Pre-formatted Block Kit blocks for Slack delivery. */
-  blocks: z.array(z.unknown()).optional(),
+  blocks: z.array(z.custom<KnownBlock>()).optional(),
   assistantId: z.string().optional(),
   attachments: z.array(AttachmentMetadataSchema).optional(),
   approval: ApprovalUIMetadataSchema.optional(),
@@ -82,7 +83,7 @@ export const ChannelReplyPayloadSchema = z.object({
   user: z.string().optional(),
   /** When provided, update an existing message instead of posting a new one. */
   messageTs: z.string().optional(),
-  /** When true, auto-generate Block Kit blocks from text via textToBlocks(). */
+  /** When true, the daemon generates Block Kit blocks from the text before delivery. */
   useBlocks: z.boolean().optional(),
   /** When provided, add or remove an emoji reaction on a message. */
   reaction: z

package/node_modules/@vellumai/gateway-client/src/trust-verdict-contract.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared per-actor trust verdict carried on the gateway→runtime wire.
+ *
+ * The gateway resolves this verdict from its ACL DB and stamps it onto the
+ * inbound payload's `sourceMetadata`; the runtime consumes it. Keeping the
+ * type here avoids the runtime importing from `gateway/src` and lets the
+ * daemon's `trustClass` union (`actor-trust-resolver.ts`) converge on this
+ * one source of truth.
+ *
+ * This contract carries ACL + identity keys + minimal labels only — never
+ * info fields (notes, userFile, contactType). `status` / `policy` / `type`
+ * stay loose `z.string()` to match the gateway schema columns and avoid
+ * coupling to a still-evolving status vocabulary; the consumer interprets
+ * them.
+ */
+
+import { z } from "zod";
+
+/**
+ * Verification-purpose trust classification. Mirrors the daemon's
+ * `TrustClass` union (`actor-trust-resolver.ts`), ordered most- to
+ * least-trusted.
+ */
+export const TRUST_CLASS_VALUES = [
+  "guardian",
+  "trusted_contact",
+  "unverified_contact",
+  "unknown",
+] as const;
+
+export const TrustClassSchema = z.enum(TRUST_CLASS_VALUES);
+
+export type TrustClass = (typeof TRUST_CLASS_VALUES)[number];
+
+/**
+ * Per-actor trust verdict resolved by the gateway from its ACL DB. ACL +
+ * identity keys + minimal labels only. Guardian binding and member
+ * identity/ACL fields are optional — present only when the corresponding
+ * record resolves.
+ */
+export const TrustVerdictSchema = z.object({
+  trustClass: TrustClassSchema,
+  canonicalSenderId: z.string().nullable(),
+
+  // Guardian binding — present only when a guardian binding matches.
+  guardianExternalUserId: z.string().optional(),
+  guardianDeliveryChatId: z.string().nullable().optional(),
+  guardianPrincipalId: z.string().optional(),
+  guardianDisplayName: z.string().optional(),
+
+  // Member identity + ACL — present only when a member channel resolves.
+  contactId: z.string().optional(),
+  channelId: z.string().optional(),
+  type: z.string().optional(),
+  address: z.string().optional(),
+  externalChatId: z.string().nullable().optional(),
+  status: z.string().optional(),
+  policy: z.string().optional(),
+  verifiedAt: z.number().nullable().optional(),
+  verifiedVia: z.string().nullable().optional(),
+  memberDisplayName: z.string().optional(),
+});
+
+export type TrustVerdict = z.infer<typeof TrustVerdictSchema>;
+
+/**
+ * IPC request for `resolve_inbound_trust`. Per-actor identity keys the
+ * gateway resolver needs to classify the inbound sender. The response reuses
+ * {@link TrustVerdictSchema}.
+ */
+export const ResolveInboundTrustRequestSchema = z.object({
+  channelType: z.string().min(1),
+  actorExternalId: z.string().optional(),
+});
+
+export type ResolveInboundTrustRequest = z.infer<
+  typeof ResolveInboundTrustRequestSchema
+>;