@vellumai/cli 0.10.11-dev.202607242127.a6bf2b2 → 0.10.11-staging.2

package/node_modules/@vellumai/service-contracts/node_modules/zod/v4/package.json

@@ -1,6 +0,0 @@
-{ 
-  "type": "module",
-  "main": "./index.cjs",
-  "module": "./index.js",
-  "types": "./index.d.cts" 
-}

package/node_modules/@vellumai/service-contracts/node_modules/zod/v4-mini/index.cjs

@@ -1,32 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.z = void 0;
-const z = __importStar(require("../v4/mini/external.cjs"));
-exports.z = z;
-__exportStar(require("../v4/mini/external.cjs"), exports);

package/node_modules/@vellumai/service-contracts/node_modules/zod/v4-mini/index.d.cts

@@ -1,3 +0,0 @@
-import * as z from "../v4/mini/external.cjs";
-export * from "../v4/mini/external.cjs";
-export { z };

package/node_modules/@vellumai/service-contracts/node_modules/zod/v4-mini/index.d.ts

@@ -1,3 +0,0 @@
-import * as z from "../v4/mini/external.js";
-export * from "../v4/mini/external.js";
-export { z };

package/node_modules/@vellumai/service-contracts/node_modules/zod/v4-mini/index.js

@@ -1,3 +0,0 @@
-import * as z from "../v4/mini/external.js";
-export * from "../v4/mini/external.js";
-export { z };

package/node_modules/@vellumai/service-contracts/node_modules/zod/v4-mini/package.json

@@ -1,6 +0,0 @@
-{ 
-  "type": "module",
-  "main": "./index.cjs",
-  "module": "./index.js",
-  "types": "./index.d.cts" 
-}

package/node_modules/@vellumai/service-contracts/package.json

@@ -1,34 +0,0 @@
-{
-  "name": "@vellumai/service-contracts",
-  "version": "0.0.1",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts",
-    "./channels": "./src/channels.ts",
-    "./client-metadata": "./src/client-metadata.ts",
-    "./credential-rpc": "./src/credential-rpc.ts",
-    "./ingress": "./src/ingress.ts",
-    "./remote-web-pairing": "./src/remote-web-pairing.ts",
-    "./twilio-ingress": "./src/twilio-ingress.ts",
-    "./trust-rules": "./src/trust-rules.ts",
-    "./handles": "./src/handles.ts",
-    "./rpc": "./src/rpc.ts",
-    "./attachment-naming": "./src/attachment-naming.ts",
-    "./redacted-credential": "./src/redacted-credential.ts",
-    "./secret-detection": "./src/secret-detection.ts",
-    "./error": "./src/error.ts"
-  },
-  "scripts": {
-    "typecheck": "bunx tsc --noEmit",
-    "test": "bun test src/"
-  },
-  "dependencies": {
-    "zod": "4.3.6"
-  },
-  "devDependencies": {
-    "@types/bun": "1.2.4",
-    "typescript": "5.7.3"
-  }
-}

package/node_modules/@vellumai/service-contracts/src/__tests__/attachment-naming.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  inferMimeType,
-  resolveAttachmentFilename,
-} from "../attachment-naming.js";
-
-describe("inferMimeType", () => {
-  test("maps known extensions case-insensitively", () => {
-    expect(inferMimeType("shot.PNG")).toBe("image/png");
-    expect(inferMimeType("report.pdf")).toBe("application/pdf");
-  });
-
-  test("falls back to octet-stream for unknown or missing extensions", () => {
-    expect(inferMimeType("desktop")).toBe("application/octet-stream");
-    expect(inferMimeType("archive.xyz")).toBe("application/octet-stream");
-  });
-});
-
-describe("resolveAttachmentFilename", () => {
-  test("uses explicit filenames verbatim", () => {
-    expect(
-      resolveAttachmentFilename("custom.dat", "/tmp/shot.png", "explicit"),
-    ).toBe("custom.dat");
-  });
-
-  test("honors labels with recognized extensions", () => {
-    expect(
-      resolveAttachmentFilename("nice-name.png", "/tmp/shot.png", "label"),
-    ).toBe("nice-name.png");
-  });
-
-  test("keeps bare labels and appends the POSIX path extension", () => {
-    expect(resolveAttachmentFilename("desktop", "/tmp/shot.png", "label")).toBe(
-      "desktop.png",
-    );
-  });
-
-  test("keeps bare labels and appends the Windows path extension", () => {
-    expect(
-      resolveAttachmentFilename(
-        "desktop",
-        "C:\\Users\\user1\\Pictures\\shot.png",
-        "label",
-      ),
-    ).toBe("desktop.png");
-  });
-
-  test("bare labels to files sharing a basename resolve to unique names", () => {
-    expect(
-      resolveAttachmentFilename("first", "/workspace/a/result.png", "label"),
-    ).toBe("first.png");
-    expect(
-      resolveAttachmentFilename("second", "/workspace/b/result.png", "label"),
-    ).toBe("second.png");
-  });
-
-  test("does not duplicate an unknown extension the label already has", () => {
-    expect(
-      resolveAttachmentFilename(
-        "report.xlsx",
-        "/workspace/report.xlsx",
-        "label",
-      ),
-    ).toBe("report.xlsx");
-  });
-
-  test("matches the existing extension case-insensitively", () => {
-    expect(
-      resolveAttachmentFilename("data.YAML", "/workspace/data.yaml", "label"),
-    ).toBe("data.YAML");
-  });
-
-  test("still appends when the label ends differently", () => {
-    expect(
-      resolveAttachmentFilename(
-        "summary.v2",
-        "/workspace/data.parquet",
-        "label",
-      ),
-    ).toBe("summary.v2.parquet");
-  });
-
-  test("falls back to the basename when the path has no extension", () => {
-    expect(resolveAttachmentFilename("label", "/tmp/rawfile", "label")).toBe(
-      "rawfile",
-    );
-  });
-
-  test("uses the basename when no preferred name is given", () => {
-    expect(
-      resolveAttachmentFilename(undefined, "C:\\temp\\report.pdf", "label"),
-    ).toBe("report.pdf");
-    expect(resolveAttachmentFilename(undefined, "/tmp/report.pdf")).toBe(
-      "report.pdf",
-    );
-  });
-
-  test("ignores trailing separators", () => {
-    expect(resolveAttachmentFilename(undefined, "/tmp/dir/", "label")).toBe(
-      "dir",
-    );
-  });
-});

package/node_modules/@vellumai/service-contracts/src/__tests__/channels.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { CHANNEL_IDS, isChannelId } from "../channels.js";
-
-describe("isChannelId", () => {
-  test("accepts every canonical channel id", () => {
-    for (const id of CHANNEL_IDS) {
-      expect(isChannelId(id)).toBe(true);
-    }
-  });
-
-  test("includes the internal channels no external surface ingresses", () => {
-    // `platform` (control plane) and `vellum` (native app) are part of the
-    // canonical vocabulary even though the gateway never ingresses them. The
-    // gateway's narrower list is a compile-time-asserted subset of this set,
-    // so these must remain canonical for that assertion to mean anything.
-    expect(isChannelId("platform")).toBe(true);
-    expect(isChannelId("vellum")).toBe(true);
-  });
-
-  test("rejects unknown strings and non-string values", () => {
-    expect(isChannelId("discord")).toBe(false);
-    expect(isChannelId("")).toBe(false);
-    expect(isChannelId(undefined)).toBe(false);
-    expect(isChannelId(null)).toBe(false);
-    expect(isChannelId(42)).toBe(false);
-  });
-});

package/node_modules/@vellumai/service-contracts/src/__tests__/contracts.test.ts

@@ -1,299 +0,0 @@
-/**
- * Tests for @vellumai/service-contracts
- *
- * These tests verify:
- * 1. The package can be consumed independently (no assistant/ or CES imports).
- * 2. All exported schemas parse valid payloads and reject invalid ones.
- * 3. The transport message union correctly discriminates by `type`.
- */
-
-import { describe, expect, test } from "bun:test";
-import {
-  CES_PROTOCOL_VERSION,
-  HandshakeAckSchema,
-  HandshakeRequestSchema,
-  RpcEnvelopeSchema,
-  RpcErrorSchema,
-  ToolRequestBaseSchema,
-  ToolResponseBaseSchema,
-  TransportMessageSchema,
-} from "../index.js";
-
-// ---------------------------------------------------------------------------
-// Independence guard — the package must not pull in assistant or CES modules.
-// ---------------------------------------------------------------------------
-
-describe("package independence", () => {
-  const sourceFiles = [
-    "../index.ts",
-    "../handles.ts",
-    "../rpc.ts",
-    "../transport.ts",
-    "../credential-rpc.ts",
-    "../trust-rules.ts",
-    "../ingress.ts",
-    "../twilio-ingress.ts",
-    "../error.ts",
-  ];
-
-  for (const file of sourceFiles) {
-    test(`${file} does not import from assistant/ or credential-executor/`, () => {
-      const src = require("node:fs").readFileSync(
-        require("node:path").resolve(__dirname, file),
-        "utf-8",
-      );
-      expect(src).not.toMatch(/from\s+['"].*assistant\//);
-      expect(src).not.toMatch(/from\s+['"].*credential-executor\//);
-      expect(src).not.toMatch(/require\(['"].*assistant\//);
-      expect(src).not.toMatch(/require\(['"].*credential-executor\//);
-    });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Protocol version
-// ---------------------------------------------------------------------------
-
-describe("CES_PROTOCOL_VERSION", () => {
-  test("is a valid semver string", () => {
-    expect(CES_PROTOCOL_VERSION).toMatch(/^\d+\.\d+\.\d+$/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Handshake schemas
-// ---------------------------------------------------------------------------
-
-describe("HandshakeRequestSchema", () => {
-  test("parses a valid handshake request", () => {
-    const result = HandshakeRequestSchema.parse({
-      type: "handshake_request",
-      protocolVersion: CES_PROTOCOL_VERSION,
-      sessionId: "sess-001",
-    });
-    expect(result.type).toBe("handshake_request");
-    expect(result.protocolVersion).toBe(CES_PROTOCOL_VERSION);
-    expect(result.sessionId).toBe("sess-001");
-  });
-
-  test("rejects a request with wrong type literal", () => {
-    expect(() =>
-      HandshakeRequestSchema.parse({
-        type: "handshake_ack",
-        protocolVersion: CES_PROTOCOL_VERSION,
-        sessionId: "sess-001",
-      }),
-    ).toThrow();
-  });
-
-  test("rejects a request missing sessionId", () => {
-    expect(() =>
-      HandshakeRequestSchema.parse({
-        type: "handshake_request",
-        protocolVersion: CES_PROTOCOL_VERSION,
-      }),
-    ).toThrow();
-  });
-});
-
-describe("HandshakeAckSchema", () => {
-  test("parses an accepted ack", () => {
-    const result = HandshakeAckSchema.parse({
-      type: "handshake_ack",
-      protocolVersion: CES_PROTOCOL_VERSION,
-      sessionId: "sess-001",
-      accepted: true,
-    });
-    expect(result.accepted).toBe(true);
-    expect(result.reason).toBeUndefined();
-  });
-
-  test("parses a rejected ack with reason", () => {
-    const result = HandshakeAckSchema.parse({
-      type: "handshake_ack",
-      protocolVersion: CES_PROTOCOL_VERSION,
-      sessionId: "sess-001",
-      accepted: false,
-      reason: "Unsupported protocol version",
-    });
-    expect(result.accepted).toBe(false);
-    expect(result.reason).toBe("Unsupported protocol version");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RPC envelope
-// ---------------------------------------------------------------------------
-
-describe("RpcEnvelopeSchema", () => {
-  test("parses a valid request envelope", () => {
-    const result = RpcEnvelopeSchema.parse({
-      id: "1",
-      kind: "request",
-      method: "tool.execute",
-      payload: { foo: "bar" },
-      timestamp: new Date().toISOString(),
-    });
-    expect(result.kind).toBe("request");
-    expect(result.method).toBe("tool.execute");
-  });
-
-  test("parses a valid response envelope", () => {
-    const result = RpcEnvelopeSchema.parse({
-      id: "1",
-      kind: "response",
-      method: "tool.execute",
-      payload: { success: true },
-      timestamp: new Date().toISOString(),
-    });
-    expect(result.kind).toBe("response");
-  });
-
-  test("rejects an envelope with invalid kind", () => {
-    expect(() =>
-      RpcEnvelopeSchema.parse({
-        id: "1",
-        kind: "notification",
-        method: "tool.execute",
-        payload: null,
-        timestamp: new Date().toISOString(),
-      }),
-    ).toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RPC error
-// ---------------------------------------------------------------------------
-
-describe("RpcErrorSchema", () => {
-  test("parses a minimal error", () => {
-    const result = RpcErrorSchema.parse({
-      code: "CREDENTIAL_EXPIRED",
-      message: "The credential has expired",
-    });
-    expect(result.code).toBe("CREDENTIAL_EXPIRED");
-    expect(result.details).toBeUndefined();
-  });
-
-  test("parses an error with details", () => {
-    const result = RpcErrorSchema.parse({
-      code: "TOOL_FAILED",
-      message: "Execution timed out",
-      details: { timeoutMs: 30000 },
-    });
-    expect(result.details).toEqual({ timeoutMs: 30000 });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tool request / response base shapes
-// ---------------------------------------------------------------------------
-
-describe("ToolRequestBaseSchema", () => {
-  test("parses a valid tool request", () => {
-    const result = ToolRequestBaseSchema.parse({
-      toolName: "browser.navigate",
-      credentialHandle: "cred-abc-123",
-      params: { url: "https://example.com" },
-    });
-    expect(result.toolName).toBe("browser.navigate");
-    expect(result.credentialHandle).toBe("cred-abc-123");
-    expect(result.params).toEqual({ url: "https://example.com" });
-  });
-
-  test("rejects a request missing credentialHandle", () => {
-    expect(() =>
-      ToolRequestBaseSchema.parse({
-        toolName: "browser.navigate",
-        params: {},
-      }),
-    ).toThrow();
-  });
-});
-
-describe("ToolResponseBaseSchema", () => {
-  test("parses a successful response", () => {
-    const result = ToolResponseBaseSchema.parse({
-      success: true,
-      result: { html: "<html></html>" },
-    });
-    expect(result.success).toBe(true);
-    if (!result.success) throw new Error("Expected successful response");
-    expect(result.result).toEqual({ html: "<html></html>" });
-  });
-
-  test("parses a successful response without result", () => {
-    const result = ToolResponseBaseSchema.parse({
-      success: true,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  test("parses a failed response with error", () => {
-    const result = ToolResponseBaseSchema.parse({
-      success: false,
-      error: {
-        code: "TOOL_FAILED",
-        message: "Network error",
-      },
-    });
-    expect(result.success).toBe(false);
-    if (result.success) throw new Error("Expected failed response");
-    expect(result.error.code).toBe("TOOL_FAILED");
-  });
-
-  test("rejects a failed response without error", () => {
-    expect(() =>
-      ToolResponseBaseSchema.parse({
-        success: false,
-      }),
-    ).toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Transport message union
-// ---------------------------------------------------------------------------
-
-describe("TransportMessageSchema", () => {
-  test("discriminates a handshake request", () => {
-    const msg = TransportMessageSchema.parse({
-      type: "handshake_request",
-      protocolVersion: CES_PROTOCOL_VERSION,
-      sessionId: "sess-001",
-    });
-    expect(msg.type).toBe("handshake_request");
-  });
-
-  test("discriminates a handshake ack", () => {
-    const msg = TransportMessageSchema.parse({
-      type: "handshake_ack",
-      protocolVersion: CES_PROTOCOL_VERSION,
-      sessionId: "sess-001",
-      accepted: true,
-    });
-    expect(msg.type).toBe("handshake_ack");
-  });
-
-  test("discriminates an rpc envelope", () => {
-    const msg = TransportMessageSchema.parse({
-      type: "rpc",
-      id: "42",
-      kind: "request",
-      method: "tool.execute",
-      payload: {},
-      timestamp: new Date().toISOString(),
-    });
-    expect(msg.type).toBe("rpc");
-  });
-
-  test("rejects an unknown message type", () => {
-    expect(() =>
-      TransportMessageSchema.parse({
-        type: "unknown",
-        data: {},
-      }),
-    ).toThrow();
-  });
-});

package/node_modules/@vellumai/service-contracts/src/__tests__/ingress.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  normalizeHttpPublicBaseUrl,
-  normalizePublicBaseUrl,
-  velayHostForPlatformHost,
-} from "../ingress.js";
-import {
-  buildTwilioMediaStreamUrl,
-  buildTwilioPhoneNumberWebhookUrls,
-  buildTwilioVoiceWebhookUrl,
-  resolveTwilioPublicBaseUrl,
-} from "../twilio-ingress.js";
-
-describe("velayHostForPlatformHost", () => {
-  test("maps the prod platform host to prod velay", () => {
-    expect(velayHostForPlatformHost("platform.vellum.ai")).toBe(
-      "velay.vellum.ai",
-    );
-  });
-
-  test("maps env-prefixed platform hosts to their env velay", () => {
-    expect(velayHostForPlatformHost("staging-platform.vellum.ai")).toBe(
-      "velay-staging.vellum.ai",
-    );
-    expect(velayHostForPlatformHost("dev-platform.vellum.ai")).toBe(
-      "velay-dev.vellum.ai",
-    );
-  });
-
-  test("returns null for hosts outside the deployment convention", () => {
-    expect(velayHostForPlatformHost("localhost")).toBeNull();
-    expect(velayHostForPlatformHost("platform.example.com")).toBeNull();
-    expect(
-      velayHostForPlatformHost("staging-platform.vellum.ai.evil.com"),
-    ).toBeNull();
-  });
-});
-
-describe("normalizePublicBaseUrl", () => {
-  test("trims whitespace and trailing slashes", () => {
-    expect(normalizePublicBaseUrl(" https://example.test/path/// ")).toBe(
-      "https://example.test/path",
-    );
-  });
-
-  test("rejects non-string and empty values", () => {
-    expect(normalizePublicBaseUrl(undefined)).toBeUndefined();
-    expect(normalizePublicBaseUrl("   ")).toBeUndefined();
-  });
-});
-
-describe("normalizeHttpPublicBaseUrl", () => {
-  test("normalizes valid HTTP and HTTPS URLs", () => {
-    expect(normalizeHttpPublicBaseUrl(" HTTPS://EXAMPLE.TEST/twilio ")).toBe(
-      "https://example.test/twilio",
-    );
-    expect(normalizeHttpPublicBaseUrl("https://example.test/twilio///")).toBe(
-      "https://example.test/twilio",
-    );
-    expect(normalizeHttpPublicBaseUrl("https://example.test")).toBe(
-      "https://example.test/",
-    );
-  });
-
-  test("rejects non-HTTP URLs and malformed values", () => {
-    expect(normalizeHttpPublicBaseUrl("ftp://example.test")).toBeUndefined();
-    expect(normalizeHttpPublicBaseUrl("notaurl")).toBeUndefined();
-    expect(normalizeHttpPublicBaseUrl("")).toBeUndefined();
-  });
-
-  test("rejects query strings and fragments instead of mutating them", () => {
-    expect(
-      normalizeHttpPublicBaseUrl("https://example.test/twilio?token=abc/"),
-    ).toBeUndefined();
-    expect(
-      normalizeHttpPublicBaseUrl("https://example.test/twilio#section/"),
-    ).toBeUndefined();
-    expect(
-      normalizeHttpPublicBaseUrl("https://example.test/twilio?"),
-    ).toBeUndefined();
-    expect(
-      normalizeHttpPublicBaseUrl("https://example.test/twilio#"),
-    ).toBeUndefined();
-  });
-});
-
-describe("Twilio ingress helpers", () => {
-  test("resolves public base URL with fallback", () => {
-    expect(
-      resolveTwilioPublicBaseUrl({
-        publicBaseUrl: " https://twilio.example.test/twilio/ ",
-      }),
-    ).toBe("https://twilio.example.test/twilio");
-    expect(
-      resolveTwilioPublicBaseUrl({
-        publicBaseUrl: " ",
-      }),
-    ).toBeUndefined();
-    expect(
-      resolveTwilioPublicBaseUrl({
-        publicBaseUrl: " ",
-      }, "https://fallback.example.test/"),
-    ).toBe("https://fallback.example.test");
-    expect(
-      resolveTwilioPublicBaseUrl({}, "https://fallback.example.test/"),
-    ).toBe("https://fallback.example.test");
-  });
-
-  test("builds Twilio webhook and WebSocket URLs from one base URL", () => {
-    expect(buildTwilioVoiceWebhookUrl("https://example.test")).toBe(
-      "https://example.test/webhooks/twilio/voice",
-    );
-    expect(buildTwilioVoiceWebhookUrl("https://example.test", "call-123")).toBe(
-      "https://example.test/webhooks/twilio/voice?callSessionId=call-123",
-    );
-    expect(buildTwilioMediaStreamUrl("http://example.test")).toBe(
-      "ws://example.test/webhooks/twilio/media-stream",
-    );
-    expect(buildTwilioPhoneNumberWebhookUrls("https://example.test")).toEqual({
-      statusCallbackUrl: "https://example.test/webhooks/twilio/status",
-      voiceUrl: "https://example.test/webhooks/twilio/voice",
-    });
-  });
-});