@fenixforce/kernel 0.1.0

package/dist/tools/skill-discovery.d.ts

@@ -0,0 +1,32 @@
+export interface Skill {
+    id: string;
+    name: string;
+    description: string;
+    edition: "all" | "pro";
+    triggers: string[];
+    version?: string;
+    author?: string;
+    body: string;
+    files: string[];
+    root: string;
+}
+export interface SkillValidationError {
+    path: string;
+    errors: string[];
+}
+export declare function discoverSkills(roots: string[]): Promise<{
+    skills: Skill[];
+    errors: SkillValidationError[];
+}>;
+export declare function extractFrontmatter(raw: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+};
+export declare function formatSkillForAgent(skill: Skill): string;
+/**
+ * Match skills by trigger substring against an inbound message.
+ * Returns skills whose triggers appear as substrings in the
+ * lowercased message, sorted by number of matching triggers.
+ */
+export declare function matchSkillsByTrigger(skills: Skill[], message: string): Skill[];
+export declare function searchSkills(skills: Skill[], query: string, limit?: number): string[];

package/dist/tools/skill-loader.d.ts

@@ -0,0 +1,76 @@
+import { type Skill } from "./skill-discovery.js";
+import type { ToolRegistry, ToolDefinition } from "./registry.js";
+export interface SkillLoaderConfig {
+    /** Root directory containing skills/{builtin,community,user}/ */
+    projectRoot: string;
+    /** Override search directories (default: builtin → community → user) */
+    searchDirs?: string[];
+}
+export interface SkillLoadResult {
+    loaded: string[];
+    failed: Array<{
+        name: string;
+        error: string;
+    }>;
+    skipped: string[];
+}
+/** Lightweight metadata registered at startup (no body, no tools). */
+export interface SkillStub {
+    id: string;
+    name: string;
+    description: string;
+    edition: "all" | "pro";
+    triggers: string[];
+    root: string;
+}
+/**
+ * Lazy skill registry. At startup only metadata stubs are loaded.
+ * Full skill content (body, file list) and index.ts tools are
+ * loaded on first access via `resolve()`.
+ */
+export declare class LazySkillRegistry {
+    private stubs;
+    private resolved;
+    private tools;
+    /** Register a lightweight stub (startup). */
+    registerStub(stub: SkillStub): void;
+    /** List all registered skill names and descriptions (cheap). */
+    listStubs(): SkillStub[];
+    /** Check if a skill name is registered. */
+    has(name: string): boolean;
+    /** Number of registered skills (stubs + resolved). */
+    get size(): number;
+    /**
+     * Resolve a skill on first trigger: read full SKILL.md body,
+     * import index.ts tools. Caches for subsequent calls.
+     */
+    resolve(name: string): Promise<{
+        skill: Skill;
+        tools: ToolDefinition[];
+    } | null>;
+    /** Get the formatted agent prompt for a resolved skill. */
+    format(name: string): string | null;
+    /** Check whether a skill has been fully resolved. */
+    isResolved(name: string): boolean;
+}
+/**
+ * Discover skills lazily: parse only frontmatter metadata at startup.
+ * Returns a LazySkillRegistry that resolves full content on demand.
+ */
+export declare function loadSkillsLazy(config: SkillLoaderConfig): Promise<{
+    registry: LazySkillRegistry;
+    errors: Array<{
+        name: string;
+        error: string;
+    }>;
+}>;
+/**
+ * Discover skills from SKILL.md files and register their tools.
+ *
+ * Search order: skills/builtin/ → skills/community/ → skills/user/.
+ * Later roots override earlier ones by name (user overrides community).
+ *
+ * For each discovered skill directory, attempts to import index.ts
+ * and extract tool definitions from the `tools` or default export.
+ */
+export declare function loadSkills(registry: ToolRegistry, config: SkillLoaderConfig): Promise<SkillLoadResult>;

package/dist/tools/skill-types.d.ts

@@ -0,0 +1,21 @@
+export interface SkillDefinition {
+    id: string;
+    name: string;
+    edition: "all" | "pro";
+    category: SkillCategory;
+    description: string;
+    triggers: string[];
+    manifest: string;
+    dependencies?: string[];
+    mcpServers?: McpServerRef[];
+}
+export interface McpServerRef {
+    name: string;
+    url: string;
+    auth: "none" | {
+        type: "header";
+        key: string;
+        envVar: string;
+    };
+}
+export type SkillCategory = "build" | "deploy" | "documents" | "content" | "design" | "code-quality" | "workflow" | "integrations" | "data" | "security" | "offsec" | "research" | "decision" | "communication" | "support" | "governance" | "agentic" | "finance" | "voice" | "rag" | "teams" | "discipline" | "domain";

package/dist/voice/audio-intelligence.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Audio Intelligence — post-transcription analysis features.
+ *
+ * Available from providers that support them (e.g., Speechmatics batch mode).
+ *
+ * Features:
+ *   Sentiment Analysis — per-utterance sentiment scoring
+ *   Topic Detection    — identify topics discussed in conversation
+ *   Summarization      — generate summary of conversation
+ *   Channel Diarization — separate speakers by audio channel (stereo)
+ *
+ * Fenix applications:
+ *   Call center analytics (customer-support skill)
+ *   Student engagement tracking (Ejiogbe Voices)
+ *   Lesson summaries and topic tracking
+ */
+export interface AudioIntelligenceConfig {
+    sentimentAnalysis?: boolean;
+    topicDetection?: boolean;
+    summarization?: boolean;
+    channelDiarization?: {
+        enabled: boolean;
+        /** Channel labels (e.g., ["Teacher", "Student"] or ["Agent", "Customer"]) */
+        channelLabels?: string[];
+    };
+}
+export interface SentimentResult {
+    speakerId: string;
+    text: string;
+    sentiment: "positive" | "negative" | "neutral";
+    confidence: number;
+}
+export interface TopicResult {
+    topic: string;
+    confidence: number;
+    segments: string[];
+}
+export interface AudioIntelligenceResult {
+    sentiment?: SentimentResult[];
+    topics?: TopicResult[];
+    summary?: string;
+}

package/dist/voice/barge-in.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Barge-In Handler — manages user interruptions during agent speech.
+ *
+ * When the user starts speaking while the agent is generating or
+ * playing audio, the barge-in handler:
+ *   1. Stops current TTS playback
+ *   2. Aborts pending LLM generation
+ *   3. Checkpoints conversation state (what was said before interruption)
+ *   4. Resumes listening for new user input
+ *
+ * Validated against Pipecat pipeline architecture:
+ *   Mic → VAD → STT → UserAggregator → LLM → TTS → Speakers → AssistantAggregator
+ *
+ * Pipeline patterns supported:
+ *   - Pipecat: composable processors, interruption built in
+ *   - LiveKit: WebRTC transport, Speechmatics STT + ElevenLabs TTS
+ *   - Twilio SIP: phone → SIP trunk → room → STT → LLM → TTS → phone
+ */
+import type { SpeechIntent } from "./speech-intent.js";
+export interface BargeInState {
+    /** What the agent had said before being interrupted */
+    spokenText: string;
+    /** What the agent was about to say (remaining queued text) */
+    pendingText: string;
+    /** Turn number when interruption occurred */
+    turnNumber: number;
+    /** Timestamp of the interruption */
+    interruptedAt: number;
+}
+export interface BargeInHandler {
+    /** Handle user barge-in: stop TTS, abort LLM, checkpoint state */
+    onBargeIn(): Promise<BargeInState>;
+}
+export interface BargeInDeps {
+    /** Stop current TTS playback, return text spoken so far */
+    stopTTS(): Promise<{
+        spokenText: string;
+    }>;
+    /** Abort pending LLM generation, return buffered unsent text */
+    abortLLM(): Promise<{
+        pendingText: string;
+    }>;
+    /** Get current turn number */
+    getCurrentTurn(): number;
+    /** Get the speech queue for flushing */
+    getSpeechQueue(): {
+        flush(): void;
+        current(): SpeechIntent | null;
+    };
+}
+export declare function createBargeInHandler(deps: BargeInDeps): BargeInHandler;

package/dist/voice/index.d.ts

@@ -0,0 +1,22 @@
+export { SidecarManager } from "./sidecar-manager.js";
+export type { SidecarConfig, SidecarState, StartFn, HealthCheckFn, } from "./sidecar-manager.js";
+export { SpeechQueue } from "./speech-intent.js";
+export type { SpeechIntent, SpeechEventType, SpeechEventHandler, } from "./speech-intent.js";
+export { parseMarkers, stripMarkers, DEFAULT_VOCABULARY, } from "./marker-parser.js";
+export type { MarkerSegment, MarkerVocabulary, } from "./marker-parser.js";
+export type { TranscriptChunk } from "./transcript.js";
+export { applySpeakerFocus, formatSpeakerTranscript, DEFAULT_SPEAKER_FORMAT, } from "./speaker-focus.js";
+export type { SpeakerFocusConfig, SpeakerActiveFormat, } from "./speaker-focus.js";
+export { loadSpeakerVoiceprints, saveSpeakerVoiceprints, serializeVoiceprint, deserializeVoiceprint, } from "./speaker-voiceprint.js";
+export type { SpeakerVoiceprint, SerializedVoiceprint, } from "./speaker-voiceprint.js";
+export { resolveTurnDetection, listTurnDetectionPresets, EDITION_TURN_DEFAULTS, } from "./turn-detection.js";
+export type { TurnDetectionConfig, TurnDetectionPreset, TurnDetectionMode, VoiceSessionControl, } from "./turn-detection.js";
+export { PROVIDER_CAPABILITIES, checkProviderCapability, } from "./stt-provider.js";
+export type { CustomVocabularyEntry, STTProviderCapabilities, } from "./stt-provider.js";
+export type { AudioIntelligenceConfig, AudioIntelligenceResult, SentimentResult, TopicResult, } from "./audio-intelligence.js";
+export { createBargeInHandler } from "./barge-in.js";
+export type { BargeInHandler, BargeInState, BargeInDeps, } from "./barge-in.js";
+export { SpeechmaticsSTT } from "./speechmatics-stt.js";
+export type { SpeechmaticsSTTConfig, SpeechmaticsRealtimeSession, SpeechmaticsBatchResult, } from "./speechmatics-stt.js";
+export { SpeechmaticsTTS } from "./speechmatics-tts.js";
+export type { SpeechmaticsTTSConfig, TTSSynthesisResult, TTSStreamChunk, } from "./speechmatics-tts.js";

package/dist/voice/marker-parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * LLM Marker Parser — extract inline emotion/expression markers from LLM output.
+ *
+ * Input:  "[happy]Hello there![/happy] [thoughtful]Let me think...[/thoughtful]"
+ * Output: structured MarkerSegment[] with emotion metadata + clean text.
+ *
+ * Handles nested markers, unclosed markers (treat as plain text),
+ * and unknown marker types (pass through as metadata).
+ */
+export interface MarkerSegment {
+    text: string;
+    emotion?: string;
+    intensity?: number;
+    speed?: number;
+}
+export interface MarkerVocabulary {
+    [emotion: string]: {
+        intensity?: number;
+        speed?: number;
+    };
+}
+export declare const DEFAULT_VOCABULARY: MarkerVocabulary;
+/**
+ * Parse inline markers into structured segments.
+ * Matched markers become annotated segments; unmatched text becomes plain segments.
+ */
+export declare function parseMarkers(rawText: string, vocabulary?: MarkerVocabulary): MarkerSegment[];
+/**
+ * Strip all markers from text, returning clean output for text channels.
+ */
+export declare function stripMarkers(rawText: string): string;

package/dist/voice/sidecar-manager.d.ts

@@ -0,0 +1,68 @@
+/**
+ * SidecarManager — voice-only sidecar lifecycle management.
+ *
+ * Manages voice providers (Parakeet STT, Qwen3-TTS, MOSS-TTS):
+ *   - cooldownUntilMs per sidecar
+ *   - inFailureCooldown(), markFailure(), clearFailure()
+ *   - Exponential backoff: 5s → 15s → 45s → 135s (base 5s, multiplier 3x)
+ *   - Health check loop (configurable interval)
+ *   - Restart on crash, fallback to cloud API after max retries
+ *   - Yields voice:sidecar:started, voice:sidecar:crashed, sidecar:cooldown events
+ */
+import type { AgentEvent } from "../events/types.js";
+export interface SidecarConfig {
+    /** Unique sidecar ID (e.g. "parakeet-stt", "qwen3-tts") */
+    id: string;
+    /** Shell command or endpoint to start/reach the sidecar */
+    command: string;
+    /** HTTP health check endpoint */
+    healthEndpoint: string;
+    /** Max restart attempts before entering cooldown. Default: 3 */
+    maxRestartAttempts?: number;
+    /** Base cooldown duration in ms. Default: 5_000 (5s) */
+    baseCooldownMs?: number;
+    /** Backoff multiplier. Default: 3 (5s→15s→45s→135s) */
+    backoffMultiplier?: number;
+    /** Maximum cooldown in ms. Default: 300_000 (5 min) */
+    maxCooldownMs?: number;
+    /** Health check poll interval in ms. Default: 30_000 (30s) */
+    healthCheckIntervalMs?: number;
+    /** Cloud API fallback provider ID during cooldown */
+    fallbackProvider?: string;
+}
+export type SidecarState = "stopped" | "starting" | "running" | "restarting" | "cooldown";
+export type StartFn = (command: string) => Promise<boolean>;
+export type HealthCheckFn = (endpoint: string) => Promise<boolean>;
+export declare class SidecarManager {
+    private sidecars;
+    private startFn;
+    private healthCheckFn;
+    private pendingEvents;
+    constructor(startFn: StartFn, healthCheckFn: HealthCheckFn);
+    /** Register a voice sidecar. */
+    add(config: SidecarConfig): void;
+    /** Start a sidecar and its health check loop. */
+    start(sidecarId: string, sessionId?: string): AsyncGenerator<AgentEvent, boolean>;
+    /** Check if a sidecar is in failure cooldown. */
+    inFailureCooldown(sidecarId: string): boolean;
+    /** Get the cooldown expiry timestamp (0 if not in cooldown). */
+    cooldownUntil(sidecarId: string): number;
+    /** Manually mark a sidecar as failed. */
+    markFailure(sidecarId: string, sessionId?: string): AsyncGenerator<AgentEvent, void>;
+    /** Clear failure state and restart. */
+    clearFailure(sidecarId: string, sessionId?: string): AsyncGenerator<AgentEvent, boolean>;
+    /** Get the active fallback provider for a sidecar in cooldown. */
+    activeFallback(sidecarId: string): string | null;
+    /** Get current state of a sidecar. */
+    getState(sidecarId: string): SidecarState | null;
+    /** Stop a sidecar and clean up timers. */
+    stop(sidecarId: string): void;
+    /** Stop all sidecars. */
+    stopAll(): void;
+    /** Drain any pending events (for non-generator callers). */
+    drainEvents(): AgentEvent[];
+    private handleFailure;
+    private enterCooldown;
+    private probeAfterCooldown;
+    private startHealthLoop;
+}

package/dist/voice/speaker-focus.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Speaker Focus System — controls how the agent handles multi-speaker audio.
+ *
+ * Two modes:
+ *   IGNORE  — Non-focused speakers completely filtered from output.
+ *             The agent never sees their speech.
+ *   RETAIN  — Non-focused speakers appear in transcript marked as "passive"
+ *             but don't drive conversation (no turn detection, no agent response).
+ *
+ * Use cases:
+ *   IGNORE: Agent ignoring its own TTS playback, classroom focus on one student,
+ *           call center where only the customer drives the agent.
+ *   RETAIN: Meeting transcription prioritizing one speaker but recording all,
+ *           language lesson focusing on student but observing group.
+ */
+import type { TranscriptChunk } from "./transcript.js";
+export interface SpeakerFocusConfig {
+    /** Speaker labels to focus on (e.g., ["S1", "Monroe"]) */
+    focusSpeakers: string[];
+    /** How to handle non-focused speakers */
+    focusMode: "ignore" | "retain";
+}
+export interface SpeakerActiveFormat {
+    /** Template for focused speakers. e.g., "<{speaker_id}>{text}</{speaker_id}>" */
+    active: string;
+    /** Template for non-focused speakers. e.g., "<PASSIVE><{speaker_id}>{text}</{speaker_id}></PASSIVE>" */
+    passive: string;
+}
+export declare const DEFAULT_SPEAKER_FORMAT: SpeakerActiveFormat;
+/**
+ * Filter a transcript chunk based on speaker focus configuration.
+ *
+ * Returns null if the chunk should be dropped (ignore mode, non-focused speaker).
+ * Returns the chunk (possibly with isActiveSpeaker set) otherwise.
+ */
+export declare function applySpeakerFocus(chunk: TranscriptChunk, config: SpeakerFocusConfig | undefined): TranscriptChunk | null;
+/**
+ * Format a transcript chunk with speaker attribution tags.
+ * Injects speaker identity into the text before it reaches the agent loop.
+ */
+export declare function formatSpeakerTranscript(chunk: TranscriptChunk, format?: SpeakerActiveFormat): string;

package/dist/voice/speaker-voiceprint.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Speaker Voiceprint Persistence — recognize speakers across sessions.
+ *
+ * After a voice session, the STT provider extracts acoustic fingerprints
+ * for each detected speaker. On session start, known voiceprints are
+ * loaded and passed to the STT provider as knownSpeakers.
+ *
+ * Storage: workspace/speakers/{label}.json
+ *
+ * Ejiogbe Voices applications:
+ *   - Recognizing returning students without re-enrollment
+ *   - Tracking individual student progress
+ *   - Personalizing pronunciation feedback per student voice
+ *   - Teacher vs student voice separation in classroom recordings
+ */
+export interface SpeakerVoiceprint {
+    /** Human-readable name (e.g., "Monroe") */
+    label: string;
+    /** Opaque acoustic fingerprints from STT provider */
+    speakerIdentifiers: string[];
+    /** Which STT provider generated these voiceprints */
+    providerId: string;
+    /** When this voiceprint was first created */
+    createdAt: Date;
+    /** When this speaker was last detected */
+    lastSeenAt: Date;
+}
+export interface SerializedVoiceprint {
+    label: string;
+    speakerIdentifiers: string[];
+    providerId: string;
+    createdAt: string;
+    lastSeenAt: string;
+}
+export declare function serializeVoiceprint(vp: SpeakerVoiceprint): SerializedVoiceprint;
+export declare function deserializeVoiceprint(raw: SerializedVoiceprint): SpeakerVoiceprint;
+/**
+ * Load all speaker voiceprints for a workspace.
+ * Reads from workspace/speakers/*.json
+ */
+export declare function loadSpeakerVoiceprints(workspaceDir: string): Promise<SpeakerVoiceprint[]>;
+/**
+ * Save speaker voiceprints for a workspace.
+ * Merges with existing voiceprints — updates lastSeenAt for known speakers,
+ * adds new speakers.
+ */
+export declare function saveSpeakerVoiceprints(workspaceDir: string, newPrints: SpeakerVoiceprint[]): Promise<void>;

package/dist/voice/speech-intent.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Intent-Based Speech Queue — priority-aware speech output management.
+ *
+ * When multiple modules generate speech simultaneously (agent response,
+ * notification, reminder, alarm), the intent system manages what plays,
+ * what queues, and what gets interrupted.
+ *
+ * Interrupt modes:
+ *   force — stop current speech immediately, play new intent
+ *   soft  — wait for current sentence boundary, then switch
+ *   queue — append to end of queue
+ */
+export interface SpeechIntent {
+    id: string;
+    source: string;
+    priority: number;
+    interruptMode: "force" | "soft" | "queue";
+    text: string;
+    voiceId?: string;
+    metadata?: {
+        emotion?: string;
+        speed?: number;
+    };
+}
+export type SpeechEventType = "speech:started" | "speech:interrupted" | "speech:completed" | "speech:queued";
+export type SpeechEventHandler = (type: SpeechEventType, intent: SpeechIntent) => void;
+export declare class SpeechQueue {
+    private queue;
+    private playing;
+    private listener?;
+    /** Subscribe to speech lifecycle events. */
+    onEvent(handler: SpeechEventHandler): void;
+    /** Enqueue a speech intent with priority-aware insertion. */
+    enqueue(intent: SpeechIntent): void;
+    /** Force-interrupt: stop current speech and play this intent immediately. */
+    private forceInterrupt;
+    /** Interrupt a specific intent by ID (remove from queue or stop if playing). */
+    interrupt(intentId: string): boolean;
+    /** Mark current speech as completed and advance to next in queue. */
+    completeCurrent(): void;
+    /** Get the currently playing intent. */
+    current(): SpeechIntent | null;
+    /** Get all pending intents in priority order. */
+    pending(): SpeechIntent[];
+    /** Total items (playing + queued). */
+    get size(): number;
+    /** Clear all queued intents (does not stop current). */
+    flush(): void;
+    private advance;
+    private emit;
+}

package/dist/voice/speechmatics-stt.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Speechmatics STT Provider — real-time and batch speech-to-text.
+ *
+ * Uses speechmatics-rt for real-time WebSocket streaming (live voice)
+ * and speechmatics-batch for async file transcription (content pipeline).
+ *
+ * Features: 50+ languages, speaker diarization, speaker identification,
+ * speaker focus, custom vocabulary with sounds-like, sentiment analysis,
+ * topic detection, summarization.
+ */
+import type { CustomVocabularyEntry, STTProviderCapabilities } from "./stt-provider.js";
+import type { SpeakerFocusConfig } from "./speaker-focus.js";
+import type { SpeakerVoiceprint } from "./speaker-voiceprint.js";
+import type { TurnDetectionConfig } from "./turn-detection.js";
+import type { AudioIntelligenceConfig, AudioIntelligenceResult } from "./audio-intelligence.js";
+import type { TranscriptChunk } from "./transcript.js";
+export interface SpeechmaticsSTTConfig {
+    apiKey: string;
+    /** "cloud" (default) | "on-prem" | "air-gapped" */
+    deployment?: "cloud" | "on-prem" | "air-gapped";
+    /** On-prem/air-gapped endpoint URL */
+    endpoint?: string;
+    /** Language code (e.g., "en", "yo", "ig"). Default: "en" */
+    language?: string;
+    /** Enable speaker diarization */
+    diarization?: boolean;
+    /** Speaker focus configuration */
+    speakerFocus?: SpeakerFocusConfig;
+    /** Known speaker voiceprints for recognition */
+    knownSpeakers?: SpeakerVoiceprint[];
+    /** Custom vocabulary with sounds-like mappings */
+    customVocabulary?: CustomVocabularyEntry[];
+    /** Turn detection settings */
+    turnDetection?: TurnDetectionConfig;
+    /** Audio intelligence (batch mode only) */
+    audioIntelligence?: AudioIntelligenceConfig;
+}
+export interface SpeechmaticsRealtimeSession {
+    /** Send audio chunk to the WebSocket stream */
+    sendAudio(chunk: Uint8Array): void;
+    /** Force end of utterance (external turn control) */
+    forceEndOfUtterance(): Promise<void>;
+    /** Subscribe to transcript chunks */
+    onTranscript(handler: (chunk: TranscriptChunk) => void): void;
+    /** Close the session and extract speaker voiceprints */
+    close(): Promise<{
+        voiceprints: SpeakerVoiceprint[];
+    }>;
+}
+export interface SpeechmaticsBatchResult {
+    transcript: string;
+    confidence: number;
+    durationMs: number;
+    speakers?: Array<{
+        id: string;
+        segments: Array<{
+            start: number;
+            end: number;
+            text: string;
+        }>;
+    }>;
+    intelligence?: AudioIntelligenceResult;
+}
+export declare class SpeechmaticsSTT {
+    readonly id: "speechmatics";
+    private config;
+    constructor(config: SpeechmaticsSTTConfig);
+    capabilities(): STTProviderCapabilities;
+    /** Transcribe a file (batch mode). Supports audio intelligence features. */
+    transcribeBatch(audioUrl: string, overrides?: Partial<SpeechmaticsSTTConfig>): Promise<SpeechmaticsBatchResult>;
+    /** Start a real-time streaming session via WebSocket. */
+    startRealtimeSession(overrides?: Partial<SpeechmaticsSTTConfig>): Promise<SpeechmaticsRealtimeSession>;
+    private resolveEndpoint;
+    private resolveWsEndpoint;
+    private pollBatchJob;
+    private parseBatchResult;
+}

package/dist/voice/speechmatics-tts.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Speechmatics TTS Provider — text-to-speech synthesis.
+ *
+ * Supports streaming and batch modes, multiple voices.
+ * Uses the speechmatics-tts SDK under the hood.
+ */
+export interface SpeechmaticsTTSConfig {
+    apiKey: string;
+    /** Deployment mode. Default: "cloud" */
+    deployment?: "cloud" | "on-prem" | "air-gapped";
+    /** On-prem/air-gapped endpoint URL */
+    endpoint?: string;
+    /** Voice ID to use */
+    voiceId?: string;
+    /** Output audio format. Default: "mp3" */
+    format?: "mp3" | "wav" | "pcm";
+    /** Speaking rate multiplier. Default: 1.0 */
+    speed?: number;
+}
+export interface TTSSynthesisResult {
+    audioData: Uint8Array;
+    durationMs: number;
+    format: string;
+}
+export interface TTSStreamChunk {
+    audioData: Uint8Array;
+    index: number;
+    isFinal: boolean;
+}
+export declare class SpeechmaticsTTS {
+    readonly id: "speechmatics-tts";
+    private config;
+    constructor(config: SpeechmaticsTTSConfig);
+    /** Synthesize text to audio (batch). */
+    synthesize(text: string, overrides?: Partial<SpeechmaticsTTSConfig>): Promise<TTSSynthesisResult>;
+    /** Stream TTS synthesis chunk by chunk. */
+    stream(text: string, overrides?: Partial<SpeechmaticsTTSConfig>): AsyncGenerator<TTSStreamChunk>;
+    private resolveEndpoint;
+}

package/dist/voice/stt-provider.d.ts

@@ -0,0 +1,40 @@
+/**
+ * STT Provider Contract — shared interface for all speech-to-text providers.
+ *
+ * Defines capability flags, custom vocabulary, and the provider capabilities
+ * matrix. Not all providers support all features.
+ */
+export interface CustomVocabularyEntry {
+    /** Correct transcription (e.g., "Ekaabo") */
+    content: string;
+    /** Phonetic alternatives the STT might hear (e.g., ["eh kah bo", "eka abo"]) */
+    soundsLike?: string[];
+}
+export interface STTProviderCapabilities {
+    supportsCustomVocabulary: boolean;
+    supportsDiarization: boolean;
+    supportsSpeakerFocus: boolean;
+    supportsSpeakerIdentification: boolean;
+    supportsSentimentAnalysis: boolean;
+    supportsTopicDetection: boolean;
+    supportsSummarization: boolean;
+}
+/**
+ * Known capabilities for each STT provider.
+ *
+ * Provider       STT  TTS  Diarize  SpeakerID  Focus  Vocab  Sentiment  Topics  Summary  OnPrem
+ * Speechmatics    Y    Y     Y         Y         Y      Y       Y         Y       Y       Y
+ * Parakeet        Y    N     N         N         N      N       N         N       N       Y
+ * Groq Whisper    Y    N     N         N         N      N       N         N       N       N
+ * Deepgram        Y    Y     Y         N         N      Y       N         N       N       N
+ * Google          Y    Y     Y         N         N      Y       N         N       N       N
+ * ElevenLabs      N    Y     N         N         N      N       N         N       N       N
+ * Qwen3-TTS       N    Y     N         N         N      N       N         N       N       Y
+ * MOSS-TTS        N    Y     N         N         N      N       N         N       N       Y
+ */
+export declare const PROVIDER_CAPABILITIES: Record<string, STTProviderCapabilities>;
+/**
+ * Check if a provider supports a specific capability.
+ * Logs a warning if the capability is configured but not supported.
+ */
+export declare function checkProviderCapability(providerId: string, capability: keyof STTProviderCapabilities): boolean;

package/dist/voice/transcript.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TranscriptChunk — the unit of speech-to-text output flowing
+ * through the realtime voice pipeline.
+ *
+ * Extended with speaker attribution for diarization and
+ * speaker focus systems.
+ */
+export interface TranscriptChunk {
+    /** Transcribed text content */
+    text: string;
+    /** Whether this is a final (not partial) transcript */
+    isFinal: boolean;
+    /** STT confidence score (0-1) */
+    confidence: number;
+    /** Speaker label from diarization (e.g., "S1", "Monroe") */
+    speakerId?: string;
+    /** Whether this speaker is the active/focused speaker */
+    isActiveSpeaker?: boolean;
+}