skyloom 1.12.0 → 1.13.0

package/src/web/tts.ts

@@ -1,93 +1,93 @@
-/**
- * Text-to-Speech integration using Volcano Engine (Doubao) TTS API.
- * Uses POST to https://openspeech.bytedance.com/api/v3/tts/unidirectional.
- */
-
-const HTTP_ENDPOINT = 'https://openspeech.bytedance.com/api/v3/tts/unidirectional';
-
-export interface VoiceOption {
-  key: string;
-  name: string;
-  desc: string;
-  voiceType: string;
-}
-
-export const VOICE_CATALOG: VoiceOption[] = [
-  { key: 'xiaohe', name: '小河', desc: '温柔自然女声', voiceType: 'zh_female_xiaohe_uranus_bigtts' },
-  { key: 'qingxinnvsheng', name: '清新女声', desc: '清澈自然女声', voiceType: 'zh_female_qingxinnvsheng_uranus_bigtts' },
-  { key: 'cancan', name: '灿灿', desc: '活力甜美少女音', voiceType: 'zh_female_cancan_uranus_bigtts' },
-  { key: 'sajiaoxuemei', name: '撒娇雪梅', desc: '甜美撒娇少女音', voiceType: 'zh_female_sajiaoxuemei_uranus_bigtts' },
-  { key: 'meilinvyou', name: '魅力女游', desc: '温柔魅力女声', voiceType: 'zh_female_meilinvyou_uranus_bigtts' },
-  { key: 'xiaoshan', name: '小杉', desc: '温暖磁性男声', voiceType: 'zh_male_xiaoshan_uranus_bigtts' },
-];
-
-export interface TTSOptions {
-  text: string;
-  voice?: string;
-  speed?: number;
-  pitch?: number;
-  apiKey?: string;
-}
-
-export interface TTSResult {
-  success: boolean;
-  audioBase64?: string;
-  format?: string;
-  error?: string;
-}
-
-/**
- * Convert text to speech using Volcano Engine TTS API.
- */
-export async function textToSpeech(options: TTSOptions): Promise<TTSResult> {
-  const { text, voice = 'zh_female_xiaohe_uranus_bigtts', speed = 1.0, pitch = 1.0 } = options;
-
-  if (!text || !text.trim()) {
-    return { success: false, error: 'Text is required' };
-  }
-
-  const apiKey = options.apiKey || process.env.VOLC_ACCESS_TOKEN;
-  if (!apiKey) {
-    return { success: false, error: 'API key not configured. Set VOLC_ACCESS_TOKEN or pass apiKey.' };
-  }
-
-  const payload = {
-    app: { appid: process.env.VOLC_APP_ID || '' },
-    user: { uid: 'skyloom' },
-    request: {
-      reqid: Math.random().toString(36).slice(2, 14),
-      text,
-      text_type: 'plain',
-      operation: 'query',
-      frontend_type: 'unitTson',
-      voice: { voice_type: voice, speed_rate: speed, pitch_rate: pitch },
-      audio: { audio_type: 'mp3' },
-    },
-  };
-
-  try {
-    const response = await fetch(HTTP_ENDPOINT, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify(payload),
-    });
-
-    const data: any = await response.json();
-    if (data.code !== 3000) {
-      return { success: false, error: `API error: ${data.code} - ${data.message || 'unknown'}` };
-    }
-    return { success: true, audioBase64: data.data, format: 'mp3' };
-  } catch (e: any) {
-    return { success: false, error: `TTS request failed: ${e.message || e}` };
-  }
-}
-
-/**
- * List available TTS voices.
- */
-export function listVoices(): VoiceOption[] {
-  return [...VOICE_CATALOG];
-}
+/**
+ * Text-to-Speech integration using Volcano Engine (Doubao) TTS API.
+ * Uses POST to https://openspeech.bytedance.com/api/v3/tts/unidirectional.
+ */
+
+const HTTP_ENDPOINT = 'https://openspeech.bytedance.com/api/v3/tts/unidirectional';
+
+export interface VoiceOption {
+  key: string;
+  name: string;
+  desc: string;
+  voiceType: string;
+}
+
+export const VOICE_CATALOG: VoiceOption[] = [
+  { key: 'xiaohe', name: '小河', desc: '温柔自然女声', voiceType: 'zh_female_xiaohe_uranus_bigtts' },
+  { key: 'qingxinnvsheng', name: '清新女声', desc: '清澈自然女声', voiceType: 'zh_female_qingxinnvsheng_uranus_bigtts' },
+  { key: 'cancan', name: '灿灿', desc: '活力甜美少女音', voiceType: 'zh_female_cancan_uranus_bigtts' },
+  { key: 'sajiaoxuemei', name: '撒娇雪梅', desc: '甜美撒娇少女音', voiceType: 'zh_female_sajiaoxuemei_uranus_bigtts' },
+  { key: 'meilinvyou', name: '魅力女游', desc: '温柔魅力女声', voiceType: 'zh_female_meilinvyou_uranus_bigtts' },
+  { key: 'xiaoshan', name: '小杉', desc: '温暖磁性男声', voiceType: 'zh_male_xiaoshan_uranus_bigtts' },
+];
+
+export interface TTSOptions {
+  text: string;
+  voice?: string;
+  speed?: number;
+  pitch?: number;
+  apiKey?: string;
+}
+
+export interface TTSResult {
+  success: boolean;
+  audioBase64?: string;
+  format?: string;
+  error?: string;
+}
+
+/**
+ * Convert text to speech using Volcano Engine TTS API.
+ */
+export async function textToSpeech(options: TTSOptions): Promise<TTSResult> {
+  const { text, voice = 'zh_female_xiaohe_uranus_bigtts', speed = 1.0, pitch = 1.0 } = options;
+
+  if (!text || !text.trim()) {
+    return { success: false, error: 'Text is required' };
+  }
+
+  const apiKey = options.apiKey || process.env.VOLC_ACCESS_TOKEN;
+  if (!apiKey) {
+    return { success: false, error: 'API key not configured. Set VOLC_ACCESS_TOKEN or pass apiKey.' };
+  }
+
+  const payload = {
+    app: { appid: process.env.VOLC_APP_ID || '' },
+    user: { uid: 'skyloom' },
+    request: {
+      reqid: Math.random().toString(36).slice(2, 14),
+      text,
+      text_type: 'plain',
+      operation: 'query',
+      frontend_type: 'unitTson',
+      voice: { voice_type: voice, speed_rate: speed, pitch_rate: pitch },
+      audio: { audio_type: 'mp3' },
+    },
+  };
+
+  try {
+    const response = await fetch(HTTP_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    const data: any = await response.json();
+    if (data.code !== 3000) {
+      return { success: false, error: `API error: ${data.code} - ${data.message || 'unknown'}` };
+    }
+    return { success: true, audioBase64: data.data, format: 'mp3' };
+  } catch (e: any) {
+    return { success: false, error: `TTS request failed: ${e.message || e}` };
+  }
+}
+
+/**
+ * List available TTS voices.
+ */
+export function listVoices(): VoiceOption[] {
+  return [...VOICE_CATALOG];
+}

package/tests/agent_helpers.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { parseExtractedFacts, synthesizeDelegationSummary } from "../src/core/agent_helpers";
+
+describe("parseExtractedFacts", () => {
+  it("parses a raw JSON array", () => {
+    const out = parseExtractedFacts('[{"key":"lang","value":"ts"}]');
+    expect(out).toEqual([{ key: "lang", value: "ts" }]);
+  });
+
+  it("parses JSON inside a markdown fence", () => {
+    const out = parseExtractedFacts('```json\n[{"key":"a","value":1}]\n```');
+    expect(out).toEqual([{ key: "a", value: 1 }]);
+  });
+
+  it("extracts a JSON array embedded in prose", () => {
+    const out = parseExtractedFacts('Sure! Here are the facts: [{"key":"x","value":true}] done.');
+    expect(out).toEqual([{ key: "x", value: true }]);
+  });
+
+  it("returns [] for empty or non-JSON input", () => {
+    expect(parseExtractedFacts("")).toEqual([]);
+    expect(parseExtractedFacts("no json here")).toEqual([]);
+    expect(parseExtractedFacts("   ")).toEqual([]);
+  });
+
+  it("returns [] when JSON is an object, not an array", () => {
+    expect(parseExtractedFacts('{"key":"x"}')).toEqual([]);
+  });
+
+  it("filters out non-object array members", () => {
+    const out = parseExtractedFacts('[{"key":"a","value":1}, "junk", 42, null]');
+    // null is typeof 'object' in JS, so it survives the filter — assert the real members
+    expect(out).toContainEqual({ key: "a", value: 1 });
+    expect(out).not.toContain("junk");
+    expect(out).not.toContain(42);
+  });
+});
+
+describe("synthesizeDelegationSummary", () => {
+  it("summarizes successes and failures", () => {
+    expect(synthesizeDelegationSummary([["fog", true], ["rain", false]])).toBe(
+      "[Delegated: fog | Failed: rain]"
+    );
+  });
+  it("returns empty string when no delegations", () => {
+    expect(synthesizeDelegationSummary([])).toBe("");
+  });
+});

package/tests/bus.test.ts

@@ -1,121 +1,121 @@
-/**
- * Tests for the event bus.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { MessageBus, Event, EventType } from '../src/core/bus';
-
-describe('MessageBus', () => {
-  it('subscribe and publish broadcasts to subscribers', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function handler(event: Event) {
-      received.push(event);
-    }
-
-    bus.subscribe('test_agent', handler);
-    const event = new Event(EventType.SYSTEM_EVENT, 'system', null, { msg: 'hello' });
-    await bus.publish(event);
-
-    expect(received).toHaveLength(1);
-    expect(received[0].type).toBe(EventType.SYSTEM_EVENT);
-    expect(received[0].data).toEqual({ msg: 'hello' });
-  });
-
-  it('direct message goes to target agent only', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function handler(event: Event) {
-      received.push(event);
-    }
-
-    bus.subscribe('target_agent', handler);
-    const event = new Event(EventType.TASK_ASSIGNED, 'snow', 'target_agent', { task: 'test' });
-    await bus.publish(event);
-
-    expect(received).toHaveLength(1);
-  });
-
-  it('unsubscribe removes handler', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function handler(event: Event) {
-      received.push(event);
-    }
-
-    bus.subscribe('agent', handler);
-    bus.unsubscribe('agent');
-    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
-    expect(received).toHaveLength(0);
-  });
-
-  it('state listener receives state change events', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function listener(event: Event) {
-      received.push(event);
-    }
-
-    bus.onStateChange(listener);
-    await bus.notifyStateChange(
-      new Event(EventType.STATE_CHANGE, 'fog', null, { old_state: 'idle', new_state: 'thinking' })
-    );
-
-    expect(received).toHaveLength(1);
-    expect(received[0].type).toBe(EventType.STATE_CHANGE);
-    expect(received[0].source).toBe('fog');
-  });
-
-  it('state listener ignores non-state events', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function listener(event: Event) {
-      received.push(event);
-    }
-
-    bus.onStateChange(listener);
-    await bus.notifyStateChange(new Event(EventType.TASK_ASSIGNED, 'snow'));
-    expect(received).toHaveLength(0);
-  });
-
-  it('history tracks published events', async () => {
-    const bus = new MessageBus();
-    for (let i = 0; i < 5; i++) {
-      await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
-    }
-    expect(bus.getHistory()).toHaveLength(5);
-    expect(bus.getHistory(undefined, undefined, 2)).toHaveLength(2);
-  });
-
-  it('broadcast skips source agent', async () => {
-    const bus = new MessageBus();
-    const called: string[] = [];
-
-    async function fogHandler(_event: Event) { called.push('fog'); }
-    async function rainHandler(_event: Event) { called.push('rain'); }
-
-    bus.subscribe('fog', fogHandler);
-    bus.subscribe('rain', rainHandler);
-    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
-
-    expect(called).not.toContain('fog');
-    expect(called).toContain('rain');
-  });
-
-  it('handler exception does not block other handlers', async () => {
-    const bus = new MessageBus();
-    const good: Event[] = [];
-
-    async function failing(_event: Event) { throw new Error('failed'); }
-    async function ok(event: Event) { good.push(event); }
-
-    bus.subscribe('rain', failing);
-    bus.subscribe('dew', ok);
-    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
-    expect(good).toHaveLength(1);
-  });
-});
+/**
+ * Tests for the event bus.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { MessageBus, Event, EventType } from '../src/core/bus';
+
+describe('MessageBus', () => {
+  it('subscribe and publish broadcasts to subscribers', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('test_agent', handler);
+    const event = new Event(EventType.SYSTEM_EVENT, 'system', null, { msg: 'hello' });
+    await bus.publish(event);
+
+    expect(received).toHaveLength(1);
+    expect(received[0].type).toBe(EventType.SYSTEM_EVENT);
+    expect(received[0].data).toEqual({ msg: 'hello' });
+  });
+
+  it('direct message goes to target agent only', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('target_agent', handler);
+    const event = new Event(EventType.TASK_ASSIGNED, 'snow', 'target_agent', { task: 'test' });
+    await bus.publish(event);
+
+    expect(received).toHaveLength(1);
+  });
+
+  it('unsubscribe removes handler', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('agent', handler);
+    bus.unsubscribe('agent');
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
+    expect(received).toHaveLength(0);
+  });
+
+  it('state listener receives state change events', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function listener(event: Event) {
+      received.push(event);
+    }
+
+    bus.onStateChange(listener);
+    await bus.notifyStateChange(
+      new Event(EventType.STATE_CHANGE, 'fog', null, { old_state: 'idle', new_state: 'thinking' })
+    );
+
+    expect(received).toHaveLength(1);
+    expect(received[0].type).toBe(EventType.STATE_CHANGE);
+    expect(received[0].source).toBe('fog');
+  });
+
+  it('state listener ignores non-state events', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function listener(event: Event) {
+      received.push(event);
+    }
+
+    bus.onStateChange(listener);
+    await bus.notifyStateChange(new Event(EventType.TASK_ASSIGNED, 'snow'));
+    expect(received).toHaveLength(0);
+  });
+
+  it('history tracks published events', async () => {
+    const bus = new MessageBus();
+    for (let i = 0; i < 5; i++) {
+      await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
+    }
+    expect(bus.getHistory()).toHaveLength(5);
+    expect(bus.getHistory(undefined, undefined, 2)).toHaveLength(2);
+  });
+
+  it('broadcast skips source agent', async () => {
+    const bus = new MessageBus();
+    const called: string[] = [];
+
+    async function fogHandler(_event: Event) { called.push('fog'); }
+    async function rainHandler(_event: Event) { called.push('rain'); }
+
+    bus.subscribe('fog', fogHandler);
+    bus.subscribe('rain', rainHandler);
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
+
+    expect(called).not.toContain('fog');
+    expect(called).toContain('rain');
+  });
+
+  it('handler exception does not block other handlers', async () => {
+    const bus = new MessageBus();
+    const good: Event[] = [];
+
+    async function failing(_event: Event) { throw new Error('failed'); }
+    async function ok(event: Event) { good.push(event); }
+
+    bus.subscribe('rain', failing);
+    bus.subscribe('dew', ok);
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
+    expect(good).toHaveLength(1);
+  });
+});

package/tests/catalog.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  loadCatalog,
+  listProviders,
+  modelsFor,
+  allModels,
+  getModelInfo,
+  isKnownModel,
+  providerLabel,
+  validateModel,
+  resetCatalogCache,
+  PROVIDER_META,
+} from "../src/core/catalog";
+
+describe("catalog", () => {
+  beforeEach(() => resetCatalogCache());
+
+  it("loads providers from models.yaml", () => {
+    const providers = listProviders();
+    expect(providers.length).toBeGreaterThan(0);
+    expect(providers).toContain("openai");
+    expect(providers).toContain("deepseek");
+  });
+
+  it("orders providers by wizard order", () => {
+    const providers = listProviders();
+    const orders = providers.map((p) => PROVIDER_META[p]?.order ?? 99);
+    const sorted = [...orders].sort((a, b) => a - b);
+    expect(orders).toEqual(sorted);
+  });
+
+  it("parses real model fields (context + cost)", () => {
+    const gpt4o = getModelInfo("gpt-4o");
+    expect(gpt4o).not.toBeNull();
+    expect(gpt4o!.provider).toBe("openai");
+    expect(gpt4o!.context).toBeGreaterThan(0);
+    expect(gpt4o!.costIn).toBeGreaterThan(0);
+  });
+
+  it("contains all real, API-verified deepseek models", () => {
+    // Verified live against https://api.deepseek.com/v1/models
+    expect(isKnownModel("deepseek-chat")).toBe(true);
+    expect(isKnownModel("deepseek-reasoner")).toBe(true);
+    expect(isKnownModel("deepseek-v4-flash")).toBe(true);
+    expect(isKnownModel("deepseek-v4-pro")).toBe(true);
+  });
+
+  it("still rejects genuinely unknown model ids", () => {
+    expect(isKnownModel("deepseek-v9-ultra")).toBe(false);
+    expect(isKnownModel("gpt-5-imaginary")).toBe(false);
+  });
+
+  it("marks ollama / zero-cost models as local", () => {
+    const local = allModels().filter((m) => m.local);
+    expect(local.every((m) => m.costIn === 0 && m.costOut === 0)).toBe(true);
+  });
+
+  it("tolerates provider/ prefix when resolving", () => {
+    // openrouter lists "openai/gpt-4.1"; bare "gpt-4.1" should also resolve
+    const direct = getModelInfo("gpt-4.1");
+    expect(direct).not.toBeNull();
+  });
+
+  it("validateModel passes for a real model and fails with suggestions otherwise", () => {
+    expect(validateModel("gpt-4o").ok).toBe(true);
+    const bad = validateModel("totally-made-up-model");
+    expect(bad.ok).toBe(false);
+    expect(bad.suggestions.length).toBeGreaterThan(0);
+    expect(bad.suggestions.every((s) => isKnownModel(s))).toBe(true);
+  });
+
+  it("provides display labels", () => {
+    expect(providerLabel("openai")).toBe("OpenAI");
+    expect(providerLabel("unknown-xyz")).toBe("unknown-xyz");
+  });
+
+  it("modelsFor returns empty for unknown provider", () => {
+    expect(modelsFor("nope")).toEqual([]);
+  });
+
+  it("caches the catalog across calls", () => {
+    const a = loadCatalog();
+    const b = loadCatalog();
+    expect(a).toBe(b);
+  });
+});

package/tests/config.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { mergeConfigs } from "../src/core/config";
+
+describe("mergeConfigs", () => {
+  it("preserves top-level default_model / default_provider (regression)", () => {
+    // Previously these were dropped, so the wizard's chosen model never applied.
+    const def: any = { agents: { fog: { temperature: 0.7 } }, llm: { default_model: "gpt-4o" } };
+    const user: any = { default_model: "deepseek-v4-flash", default_provider: "deepseek" };
+    const merged: any = mergeConfigs(def, user);
+    expect(merged.default_model).toBe("deepseek-v4-flash");
+    expect(merged.default_provider).toBe("deepseek");
+  });
+
+  it("deep-merges the llm block with the user winning", () => {
+    const def: any = { agents: {}, llm: { default_model: "gpt-4o", temperature: 0.7 } };
+    const user: any = { llm: { default_model: "deepseek-chat" } };
+    const merged: any = mergeConfigs(def, user);
+    expect(merged.llm.default_model).toBe("deepseek-chat");
+    expect(merged.llm.temperature).toBe(0.7); // preserved from default
+  });
+
+  it("merges agents (user overrides, defaults retained)", () => {
+    const def: any = { agents: { fog: { temperature: 0.7 }, rain: { temperature: 0.5 } } };
+    const user: any = { agents: { fog: { model: "deepseek-v4-pro", temperature: 0.2 } } };
+    const merged: any = mergeConfigs(def, user);
+    expect(merged.agents.fog.model).toBe("deepseek-v4-pro");
+    expect(merged.agents.rain.temperature).toBe(0.5);
+  });
+
+  it("returns the default config unchanged when no user config", () => {
+    const def: any = { agents: { fog: {} }, default_model: "gpt-4o" };
+    expect(mergeConfigs(def, null)).toBe(def);
+  });
+
+  it("preserves passthrough top-level blocks (memory, workspace)", () => {
+    const def: any = { agents: {}, memory: { short_term_limit: 100 }, workspace: { path: "auto" } };
+    const merged: any = mergeConfigs(def, { agents: {} } as any);
+    expect(merged.memory.short_term_limit).toBe(100);
+    expect(merged.workspace.path).toBe("auto");
+  });
+});