@vellumai/assistant 0.4.41 → 0.4.43

package/src/cli/integrations.ts

@@ -1,372 +0,0 @@
-import type { Command } from "commander";
-
-import { DEFAULT_ELEVENLABS_VOICE_ID } from "../config/elevenlabs-schema.js";
-import { getGatewayInternalBaseUrl } from "../config/env.js";
-import { loadRawConfig } from "../config/loader.js";
-import {
-  initAuthSigningKey,
-  isSigningKeyInitialized,
-  loadOrCreateSigningKey,
-  mintEdgeRelayToken,
-} from "../runtime/auth/token-service.js";
-
-type GuardianChannel = "telegram" | "voice" | "sms";
-
-function asRecord(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value as Record<string, unknown>;
-}
-
-export function shouldOutputJson(cmd: Command): boolean {
-  let current: Command | null = cmd;
-  while (current) {
-    if ((current.opts() as { json?: boolean }).json) return true;
-    current = current.parent;
-  }
-  return false;
-}
-
-export function writeOutput(cmd: Command, payload: unknown): void {
-  const compact = shouldOutputJson(cmd);
-  process.stdout.write(
-    compact
-      ? JSON.stringify(payload) + "\n"
-      : JSON.stringify(payload, null, 2) + "\n",
-  );
-}
-
-function getGatewayToken(): string {
-  const existing = process.env.GATEWAY_AUTH_TOKEN?.trim();
-  if (existing) return existing;
-
-  if (!isSigningKeyInitialized()) {
-    initAuthSigningKey(loadOrCreateSigningKey());
-  }
-
-  return mintEdgeRelayToken();
-}
-
-export function toQueryString(
-  params: Record<string, string | undefined>,
-): string {
-  const query = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value) query.set(key, value);
-  }
-  const encoded = query.toString();
-  return encoded ? `?${encoded}` : "";
-}
-
-function readIngressConfig(): {
-  success: true;
-  enabled: boolean;
-  publicBaseUrl?: string;
-  localGatewayTarget: string;
-} {
-  const raw = loadRawConfig();
-  const ingress = asRecord(raw.ingress);
-  const configuredUrl =
-    typeof ingress.publicBaseUrl === "string"
-      ? ingress.publicBaseUrl.trim()
-      : "";
-  const explicitEnabled =
-    typeof ingress.enabled === "boolean" ? ingress.enabled : undefined;
-  const enabled = explicitEnabled ?? configuredUrl.length > 0;
-
-  return {
-    success: true,
-    enabled,
-    publicBaseUrl: configuredUrl || undefined,
-    localGatewayTarget: getGatewayInternalBaseUrl(),
-  };
-}
-
-function readVoiceConfig(): {
-  success: true;
-  callsEnabled: boolean;
-  voiceId: string;
-  configuredVoiceId?: string;
-  usesDefaultVoice: boolean;
-} {
-  const raw = loadRawConfig();
-  const calls = asRecord(raw.calls);
-  const elevenlabs = asRecord(raw.elevenlabs);
-  const configuredVoiceId =
-    typeof elevenlabs.voiceId === "string" ? elevenlabs.voiceId.trim() : "";
-
-  return {
-    success: true,
-    callsEnabled: calls.enabled === true,
-    voiceId: configuredVoiceId || DEFAULT_ELEVENLABS_VOICE_ID,
-    configuredVoiceId: configuredVoiceId || undefined,
-    usesDefaultVoice: configuredVoiceId.length === 0,
-  };
-}
-
-// CLI-specific gateway helper — uses GATEWAY_AUTH_TOKEN env var for out-of-process
-// access. See runtime/gateway-internal-client.ts for daemon-internal usage which
-// mints fresh tokens.
-export async function gatewayGet(path: string): Promise<unknown> {
-  const gatewayBase = getGatewayInternalBaseUrl();
-  const token = getGatewayToken();
-
-  const response = await fetch(`${gatewayBase}${path}`, {
-    method: "GET",
-    headers: {
-      Accept: "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-  });
-
-  const rawBody = await response.text();
-  let parsed: unknown = { ok: false, error: rawBody };
-
-  if (rawBody.length > 0) {
-    try {
-      parsed = JSON.parse(rawBody) as unknown;
-    } catch {
-      parsed = { ok: false, error: rawBody };
-    }
-  }
-
-  if (!response.ok) {
-    const message =
-      typeof parsed === "object" && parsed && "error" in parsed
-        ? String((parsed as { error?: unknown }).error)
-        : `Gateway request failed (${response.status})`;
-    throw new Error(`${message} [${response.status}]`);
-  }
-
-  return parsed;
-}
-
-export async function gatewayPost(
-  path: string,
-  body: unknown,
-): Promise<unknown> {
-  const gatewayBase = getGatewayInternalBaseUrl();
-  const token = getGatewayToken();
-
-  const response = await fetch(`${gatewayBase}${path}`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify(body),
-  });
-
-  const rawBody = await response.text();
-  let parsed: unknown = { ok: false, error: rawBody };
-
-  if (rawBody.length > 0) {
-    try {
-      parsed = JSON.parse(rawBody) as unknown;
-    } catch {
-      parsed = { ok: false, error: rawBody };
-    }
-  }
-
-  if (!response.ok) {
-    const message =
-      typeof parsed === "object" && parsed && "error" in parsed
-        ? String((parsed as { error?: unknown }).error)
-        : `Gateway request failed (${response.status})`;
-    throw new Error(`${message} [${response.status}]`);
-  }
-
-  return parsed;
-}
-
-export async function runRead(
-  cmd: Command,
-  reader: () => Promise<unknown>,
-): Promise<void> {
-  try {
-    const result = await reader();
-    writeOutput(cmd, result);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    writeOutput(cmd, { ok: false, error: message });
-    process.exitCode = 1;
-  }
-}
-
-export function registerIntegrationsCommand(program: Command): void {
-  const integrations = program
-    .command("integrations")
-    .description("Read integration and ingress status through the gateway API")
-    .option("--json", "Machine-readable compact JSON output");
-
-  integrations.addHelpText(
-    "after",
-    `
-Reads integration configuration and status through the gateway API. The
-assistant must be running for most subcommands (telegram, guardian)
-since they query the gateway. Exceptions: "ingress config" and "voice config"
-read from the local config file and do not require the gateway.
-
-Integration categories:
-  telegram     Telegram bot configuration and webhook status
-  guardian     Guardian trust verification system for contacts
-  ingress      Public ingress URL and local gateway target (config-only)
-  voice        Voice/call readiness and ElevenLabs voice ID (config-only)
-
-Examples:
-  $ assistant integrations telegram config
-  $ assistant integrations guardian status --channel sms`,
-  );
-
-  const telegram = integrations
-    .command("telegram")
-    .description("Telegram integration status");
-
-  telegram.addHelpText(
-    "after",
-    `
-Checks the Telegram bot configuration status through the gateway API.
-Requires the assistant to be running.
-
-Examples:
-  $ assistant integrations telegram config
-  $ assistant integrations telegram config --json`,
-  );
-
-  telegram
-    .command("config")
-    .description("Get Telegram integration configuration status")
-    .addHelpText(
-      "after",
-      `
-Returns the Telegram bot token status, webhook URL, and bot username from
-the gateway. Requires the assistant to be running.
-
-The response includes whether a bot token is configured, the current webhook
-endpoint, and the bot's Telegram username.
-
-Examples:
-  $ assistant integrations telegram config
-  $ assistant integrations telegram config --json`,
-    )
-    .action(async (_opts: unknown, cmd: Command) => {
-      await runRead(cmd, async () =>
-        gatewayGet("/v1/integrations/telegram/config"),
-      );
-    });
-
-  const guardian = integrations
-    .command("guardian")
-    .description("Guardian verification status");
-
-  guardian.addHelpText(
-    "after",
-    `
-Guardian is the trust verification system for contacts. It tracks whether
-contacts on each channel have completed identity verification. Requires
-the assistant to be running.
-
-Examples:
-  $ assistant integrations guardian status
-  $ assistant integrations guardian status --channel voice`,
-  );
-
-  guardian
-    .command("status")
-    .description("Get guardian status for a channel")
-    .option("--channel <channel>", "Channel: telegram|voice|sms", "telegram")
-    .addHelpText(
-      "after",
-      `
-Returns the guardian verification state for the specified channel. Requires
-the assistant to be running.
-
-The --channel flag accepts: telegram, voice, sms. Defaults to telegram if
-not specified. The response includes whether guardian verification is active
-and the current verification state for that channel.
-
-Examples:
-  $ assistant integrations guardian status
-  $ assistant integrations guardian status --channel telegram
-  $ assistant integrations guardian status --channel voice
-  $ assistant integrations guardian status --channel sms --json`,
-    )
-    .action(async (opts: { channel?: GuardianChannel }, cmd: Command) => {
-      const channel = opts.channel ?? "telegram";
-      await runRead(cmd, async () =>
-        gatewayGet(
-          `/v1/integrations/guardian/status${toQueryString({ channel })}`,
-        ),
-      );
-    });
-
-  const ingress = integrations
-    .command("ingress")
-    .description("Trusted contact membership and invite status");
-
-  ingress.addHelpText(
-    "after",
-    `
-Shows the public ingress URL and local gateway target URL. Reads from the
-local config file and does not require the gateway to be running.
-
-Examples:
-  $ assistant integrations ingress config`,
-  );
-
-  ingress
-    .command("config")
-    .description("Get public ingress URL and local gateway target")
-    .addHelpText(
-      "after",
-      `
-Shows the public ingress URL and the local gateway target URL. Reads from
-the local config file and does not require the gateway to be running.
-
-The response includes whether ingress is enabled, the configured public base
-URL (if any), and the local gateway target address. Ingress is considered
-enabled if explicitly set to true or if a publicBaseUrl is configured.
-
-Examples:
-  $ assistant integrations ingress config
-  $ assistant integrations ingress config --json`,
-    )
-    .action(async (_opts: unknown, cmd: Command) => {
-      await runRead(cmd, async () => readIngressConfig());
-    });
-
-  const voice = integrations.command("voice").description("Voice setup status");
-
-  voice.addHelpText(
-    "after",
-    `
-Shows voice and call readiness configuration. Reads from the local config
-file and does not require the gateway to be running.
-
-Examples:
-  $ assistant integrations voice config`,
-  );
-
-  voice
-    .command("config")
-    .description("Get voice and call readiness config")
-    .addHelpText(
-      "after",
-      `
-Shows voice and call readiness status. Reads from the local config file and
-does not require the gateway to be running.
-
-The response includes whether calls are enabled, the active ElevenLabs voice
-ID (falls back to default if not configured), whether a custom voice ID is
-set, and whether the default voice is in use.
-
-Examples:
-  $ assistant integrations voice config
-  $ assistant integrations voice config --json`,
-    )
-    .action(async (_opts: unknown, cmd: Command) => {
-      await runRead(cmd, async () => readVoiceConfig());
-    });
-}

package/src/cli/ipc-client.ts

@@ -1,88 +0,0 @@
-import * as net from "node:net";
-
-import {
-  type ClientMessage,
-  createMessageParser,
-  serialize,
-  type ServerMessage,
-} from "../daemon/ipc-protocol.js";
-import { IpcError } from "../util/errors.js";
-import { getSocketPath, readSessionToken } from "../util/platform.js";
-
-export function sendOneMessage(msg: ClientMessage): Promise<ServerMessage> {
-  return new Promise((resolve, reject) => {
-    const socket = net.createConnection(getSocketPath());
-    const parser = createMessageParser();
-    let resolved = false;
-    let authenticated = false;
-
-    socket.on("connect", () => {
-      // Authenticate first — the daemon requires a valid session token
-      // before it will accept any other messages.
-      const token = readSessionToken();
-      if (!token) {
-        resolved = true;
-        reject(
-          new IpcError("Session token not found — is the assistant running?"),
-        );
-        socket.destroy();
-        return;
-      }
-      socket.write(serialize({ type: "auth", token }));
-    });
-
-    socket.on("data", (data) => {
-      const messages = parser.feed(data.toString()) as ServerMessage[];
-      for (const m of messages) {
-        // Handle auth handshake
-        if (!authenticated) {
-          if (m.type === "auth_result") {
-            if ((m as { success: boolean }).success) {
-              authenticated = true;
-              // Now send the actual message
-              socket.write(serialize(msg));
-            } else {
-              resolved = true;
-              reject(
-                new IpcError(
-                  (m as { message?: string }).message ??
-                    "Authentication failed",
-                ),
-              );
-              socket.destroy();
-            }
-          }
-          continue;
-        }
-
-        // Skip push messages that aren't responses to our request
-        if (m.type === "daemon_status") {
-          continue;
-        }
-        // On auto-auth sockets the server may send a second auth_result
-        // in response to the client's auth message after we're already
-        // authenticated — ignore it so it doesn't resolve as the response.
-        if (m.type === "auth_result") {
-          continue;
-        }
-        if (m.type === "session_info" && msg.type !== "session_create") {
-          continue;
-        }
-        resolved = true;
-        socket.end();
-        resolve(m);
-        return;
-      }
-    });
-
-    socket.on("error", (err) => {
-      if (!resolved) reject(err);
-    });
-
-    socket.on("close", () => {
-      if (!resolved) {
-        reject(new IpcError("Socket closed before receiving a response"));
-      }
-    });
-  });
-}

package/src/config/bundled-skills/configure-settings/SKILL.md

@@ -1,86 +0,0 @@
----
-name: "Configure Settings"
-description: "Read, update, or reset assistant configuration values using the assistant config CLI"
-user-invocable: true
-metadata: { "vellum": { "emoji": "⚙️" } }
----
-
-You are helping the user view or change assistant configuration through the `vellum` CLI. Treat CLI commands as the canonical interface. Do **not** read or edit config files directly.
-
-## Domain Status Reads First
-
-When a user asks for setup/status of a specific capability, prefer domain commands before generic `assistant config get`:
-
-```bash
-assistant integrations voice config --json
-assistant integrations ingress config --json
-assistant integrations twilio config --json
-assistant email status --json
-```
-
-Use `assistant config get` for generic keys that do not have a domain command.
-
-## Reading a value
-
-```bash
-assistant config get <key>
-```
-
-Examples:
-
-```bash
-assistant config get platform.baseUrl
-assistant config get memory.qdrant.url
-assistant config get provider
-```
-
-If the result is empty, the compiled default is in effect.
-
-## Setting a value
-
-```bash
-assistant config set <key> <value>
-```
-
-Examples:
-
-```bash
-assistant config set platform.baseUrl "https://platform.vellum.ai"
-assistant config set provider "openai"
-assistant config set memory.enabled false
-assistant config set maxTokens 8000
-```
-
-## Resetting a value to its default
-
-Set the key to an empty string (for strings) or omit it from the config file:
-
-```bash
-assistant config set <key> ""
-```
-
-## Listing all configuration
-
-```bash
-assistant config list
-```
-
-## Common configuration keys
-
-| Key                     | Description                                    |
-| ----------------------- | ---------------------------------------------- |
-| `platform.baseUrl`      | Vellum platform URL for auth and API calls     |
-| `provider`              | Default LLM provider (anthropic, openai, etc.) |
-| `model`                 | Default model name                             |
-| `memory.enabled`        | Enable/disable memory system                   |
-| `memory.qdrant.url`     | Qdrant vector store URL                        |
-| `calls.enabled`         | Enable/disable phone call support              |
-| `sandbox.enabled`       | Enable/disable sandbox for tool execution      |
-| `ingress.publicBaseUrl` | Public ingress URL for webhooks                |
-
-## Notes
-
-- Changes to most settings take effect after the assistant restarts or reconnects
-- Platform URL changes take effect after the macOS app reconnects (Settings > Connect)
-- Boolean values should be `true` or `false`; numeric values are bare numbers
-- The full config schema is defined in `assistant/src/config/core-schema.ts`

package/src/config/bundled-skills/doordash/lib/shared/ipc.ts

@@ -1,32 +0,0 @@
-/**
- * Minimal IPC serialization/parsing for daemon communication.
- * Inlined from assistant/src/daemon/ipc-protocol.ts (stripped of type dependencies).
- */
-
-export function serialize(msg: Record<string, unknown>): string {
-  return JSON.stringify(msg) + "\n";
-}
-
-export function createMessageParser() {
-  let buffer = "";
-
-  return {
-    feed(data: string): Array<Record<string, unknown>> {
-      buffer += data;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      const results: Array<Record<string, unknown>> = [];
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed) {
-          try {
-            results.push(JSON.parse(trimmed) as Record<string, unknown>);
-          } catch {
-            // Skip malformed messages
-          }
-        }
-      }
-      return results;
-    },
-  };
-}