@vellumai/assistant 0.4.23 → 0.4.26

package/src/tools/network/script-proxy/types.ts

@@ -1,125 +1,19 @@
-/** Unique identifier for a proxy session. */
-export type ProxySessionId = string;
-
-export type ProxySessionStatus = 'starting' | 'active' | 'stopping' | 'stopped';
-
-export interface ProxySession {
-  id: ProxySessionId;
-  conversationId: string;
-  credentialIds: string[];
-  status: ProxySessionStatus;
-  createdAt: Date;
-  /** Ephemeral port assigned once the session starts listening. */
-  port: number | null;
-}
-
-export interface ProxySessionConfig {
-  /** How long (ms) an idle session stays alive before auto-stopping. */
-  idleTimeoutMs: number;
-  /** Maximum concurrent sessions per conversation. */
-  maxSessionsPerConversation: number;
-}
-
-export interface ProxyEnvVars {
-  HTTP_PROXY: string;
-  HTTPS_PROXY: string;
-  NO_PROXY: string;
-  NODE_EXTRA_CA_CERTS?: string;
-  /** Combined CA bundle (system roots + proxy CA) for non-Node TLS clients (curl, Python, etc.). */
-  SSL_CERT_FILE?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Policy engine types
-// ---------------------------------------------------------------------------
-
-import type { CredentialInjectionTemplate } from '../../credentials/policy-types.js';
-
-/** A single credential matched — inject it. */
-export interface PolicyDecisionMatched {
-  kind: 'matched';
-  credentialId: string;
-  template: CredentialInjectionTemplate;
-}
-
-/** Multiple credentials match — caller must disambiguate. */
-export interface PolicyDecisionAmbiguous {
-  kind: 'ambiguous';
-  candidates: Array<{ credentialId: string; template: CredentialInjectionTemplate }>;
-}
-
-/** No credential matches the target host/path. */
-export interface PolicyDecisionMissing {
-  kind: 'missing';
-}
-
-/** No credential_ids were requested — pass-through. */
-export interface PolicyDecisionUnauthenticated {
-  kind: 'unauthenticated';
-}
-
-// ---------------------------------------------------------------------------
-// Approval hook outcomes — structured data for triggering permission prompts.
-// ---------------------------------------------------------------------------
-
-/** Context about the outbound request target, used to build permission prompts. */
-export interface RequestTargetContext {
-  hostname: string;
-  port: number | null;
-  path: string;
-  /** The protocol scheme of the original request ('http' or 'https'). */
-  scheme: 'http' | 'https';
-}
-
-/**
- * The target host matches a known credential template pattern, but the
- * session has no credential bound for it. The UI should prompt the user
- * to bind or create a credential.
- */
-export interface PolicyDecisionAskMissingCredential {
-  kind: 'ask_missing_credential';
-  target: RequestTargetContext;
-  /** Host patterns from the known registry that matched the target. */
-  matchingPatterns: string[];
-}
-
-/**
- * The request doesn't match any known credential template and the session
- * has no credentials. The UI should prompt the user to allow or deny the
- * unauthenticated request.
- */
-export interface PolicyDecisionAskUnauthenticated {
-  kind: 'ask_unauthenticated';
-  target: RequestTargetContext;
-}
-
-export type PolicyDecision =
-  | PolicyDecisionMatched
-  | PolicyDecisionAmbiguous
-  | PolicyDecisionMissing
-  | PolicyDecisionUnauthenticated
-  | PolicyDecisionAskMissingCredential
-  | PolicyDecisionAskUnauthenticated;
-
-// ---------------------------------------------------------------------------
-// Proxy approval callback — wires policy "ask" decisions to the UI prompter.
-// ---------------------------------------------------------------------------
-
-/**
- * Payload passed to the approval callback when the policy engine emits an
- * `ask_missing_credential` or `ask_unauthenticated` decision. Contains
- * enough context for the prompter to build a meaningful confirmation dialog.
- */
-export interface ProxyApprovalRequest {
-  /** The policy decision that triggered the approval prompt. */
-  decision: PolicyDecisionAskMissingCredential | PolicyDecisionAskUnauthenticated;
-  /** The proxy session ID that originated the request. */
-  sessionId: ProxySessionId;
-}
-
-/**
- * Callback signature for proxy approval prompts. The proxy service calls
- * this when an outbound request requires user confirmation. Returns `true`
- * if the user approves, `false` if denied.
- */
-export type ProxyApprovalCallback = (request: ProxyApprovalRequest) => Promise<boolean>;
+export type {
+  CredentialInjectionTemplate,
+  CredentialInjectionType,
+  PolicyDecision,
+  PolicyDecisionAmbiguous,
+  PolicyDecisionAskMissingCredential,
+  PolicyDecisionAskUnauthenticated,
+  PolicyDecisionMatched,
+  PolicyDecisionMissing,
+  PolicyDecisionUnauthenticated,
+  ProxyApprovalCallback,
+  ProxyApprovalRequest,
+  ProxyEnvVars,
+  ProxySession,
+  ProxySessionConfig,
+  ProxySessionId,
+  ProxySessionStatus,
+  RequestTargetContext,
+} from "@vellumai/proxy-sidecar";

package/src/tools/system/voice-config.ts

@@ -1,3 +1,4 @@
+import { invalidateConfigCache, loadRawConfig, saveRawConfig, setNestedValue } from '../../config/loader.js';
 import { normalizeActivationKey } from '../../daemon/handlers/config-voice.js';
 import { RiskLevel } from '../../permissions/types.js';
 import type { ToolDefinition } from '../../providers/types.js';
@@ -11,6 +12,7 @@ const VOICE_SETTINGS = {
   wake_word_enabled: { userDefaultsKey: 'wakeWordEnabled', type: 'boolean' as const },
   wake_word_keyword: { userDefaultsKey: 'wakeWordKeyword', type: 'string' as const },
   wake_word_timeout: { userDefaultsKey: 'wakeWordTimeoutSeconds', type: 'number' as const },
+  tts_voice_id: { userDefaultsKey: 'ttsVoiceId', type: 'string' as const },
 } as const;
 
 type VoiceSettingName = keyof typeof VOICE_SETTINGS;
@@ -55,6 +57,16 @@ function validateSetting(setting: string, value: unknown): { ok: true; coerced:
       }
       return { ok: true, coerced: num };
     }
+    case 'tts_voice_id': {
+      if (typeof value !== 'string' || value.trim().length === 0) {
+        return { ok: false, error: 'tts_voice_id must be a non-empty string (ElevenLabs voice ID)' };
+      }
+      const trimmed = value.trim();
+      if (!/^[a-zA-Z0-9]+$/.test(trimmed)) {
+        return { ok: false, error: 'tts_voice_id must contain only alphanumeric characters (ElevenLabs voice ID format)' };
+      }
+      return { ok: true, coerced: trimmed };
+    }
     default:
       return { ok: false, error: `Unknown setting "${setting}"` };
   }
@@ -65,12 +77,13 @@ const FRIENDLY_NAMES: Record<VoiceSettingName, string> = {
   wake_word_enabled: 'Wake word',
   wake_word_keyword: 'Wake word keyword',
   wake_word_timeout: 'Wake word timeout',
+  tts_voice_id: 'ElevenLabs voice',
 };
 
 export class VoiceConfigUpdateTool implements Tool {
   name = 'voice_config_update';
   description =
-    'Update a voice configuration setting (PTT activation key, wake word enabled/keyword/timeout). ' +
+    'Update a voice configuration setting (TTS voice ID, PTT activation key, wake word enabled/keyword/timeout). ' +
     'Changes take effect immediately via IPC broadcast to the desktop client.';
   category = 'system';
   defaultRiskLevel = RiskLevel.Low;
@@ -141,6 +154,15 @@ export class VoiceConfigUpdateTool implements Tool {
       });
     }
 
+    // For tts_voice_id, also persist to the config file (elevenlabs.voiceId)
+    // so phone calls and other consumers pick it up.
+    if (setting === 'tts_voice_id') {
+      const raw = loadRawConfig();
+      setNestedValue(raw, 'elevenlabs.voiceId', validation.coerced);
+      saveRawConfig(raw);
+      invalidateConfigCache();
+    }
+
     return {
       content: `${friendlyName} updated to ${JSON.stringify(validation.coerced)}. The change has been broadcast to the desktop client.`,
       isError: false,

package/src/util/logger.ts

@@ -156,7 +156,10 @@ function getRootLogger(): pino.Logger {
 
     try {
       const logPath = getLogPath();
-      const fileDest = pino.destination({ dest: logPath, sync: false, mkdir: true, mode: 0o600 });
+      // Use sync: true so the fd is opened immediately. This prevents
+      // "sonic boom is not ready yet" errors when commander calls
+      // process.exit(0) for --help/--version before the async fd is ready.
+      const fileDest = pino.destination({ dest: logPath, sync: true, mkdir: true, mode: 0o600 });
       // Tighten permissions on pre-existing log files that may have been created with looser modes
       try { chmodSync(logPath, 0o600); } catch { /* best-effort */ }
       const fileStream = pinoPretty(prettyOpts({ destination: fileDest, colorize: false }));

package/src/__tests__/elevenlabs-config.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-// ── Mocks (must come before source imports) ──────────────────────────
-
-let mockApiKey: string | null = null;
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKey: (key: string) => {
-    if (key === "credential:elevenlabs:api_key") return mockApiKey;
-    return null;
-  },
-}));
-
-let mockVoiceConfig = {
-  elevenlabs: {
-    agentId: "agent-123",
-    apiBaseUrl: "https://api.elevenlabs.io",
-    registerCallTimeoutMs: 5000,
-  },
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    calls: { voice: mockVoiceConfig },
-  }),
-}));
-
-import { getElevenLabsConfig } from "../calls/elevenlabs-config.js";
-
-describe("elevenlabs-config", () => {
-  test("returns config when API key and agent ID are set", () => {
-    mockApiKey = "sk-test-key-123";
-    mockVoiceConfig = {
-      elevenlabs: {
-        agentId: "agent-abc",
-        apiBaseUrl: "https://api.elevenlabs.io",
-        registerCallTimeoutMs: 10000,
-      },
-    };
-
-    const config = getElevenLabsConfig();
-    expect(config.apiKey).toBe("sk-test-key-123");
-    expect(config.agentId).toBe("agent-abc");
-    expect(config.apiBaseUrl).toBe("https://api.elevenlabs.io");
-    expect(config.registerCallTimeoutMs).toBe(10000);
-  });
-
-  test("throws ConfigError when API key is missing", () => {
-    mockApiKey = null;
-    mockVoiceConfig = {
-      elevenlabs: {
-        agentId: "agent-abc",
-        apiBaseUrl: "https://api.elevenlabs.io",
-        registerCallTimeoutMs: 5000,
-      },
-    };
-
-    expect(() => getElevenLabsConfig()).toThrow(/API key is not configured/);
-  });
-
-  test("throws ConfigError when API key is empty string", () => {
-    mockApiKey = "";
-    mockVoiceConfig = {
-      elevenlabs: {
-        agentId: "agent-abc",
-        apiBaseUrl: "https://api.elevenlabs.io",
-        registerCallTimeoutMs: 5000,
-      },
-    };
-
-    expect(() => getElevenLabsConfig()).toThrow(/API key is not configured/);
-  });
-
-  test("throws ConfigError when agent ID is missing", () => {
-    mockApiKey = "sk-valid";
-    mockVoiceConfig = {
-      elevenlabs: {
-        agentId: "",
-        apiBaseUrl: "https://api.elevenlabs.io",
-        registerCallTimeoutMs: 5000,
-      },
-    };
-
-    expect(() => getElevenLabsConfig()).toThrow(/agent ID is not configured/);
-  });
-});