discoclaw 1.2.4 → 2.0.0

package/dist/health/config-doctor.js

@@ -13,7 +13,7 @@ export const KNOWN_RUNTIMES = new Set([
     'openai',
     'openrouter',
 ]);
-const KNOWN_RUNTIME_OVERRIDE_KEYS = new Set(['ttsVoice', 'voiceRuntime', 'fastRuntime']);
+const KNOWN_RUNTIME_OVERRIDE_KEYS = new Set(['voiceRuntime', 'fastRuntime']);
 const DEPRECATED_ENV_VARS = {
     DISCOCLAW_FAST_RUNTIME: {
         recommendation: "Replace DISCOCLAW_FAST_RUNTIME with '!models set fast <model>' and remove the env var once the runtime override is no longer needed.",
@@ -146,8 +146,6 @@ async function readRuntimeOverridesFileState(filePath) {
         }
         const obj = parsed;
         const overrides = {};
-        if (typeof obj['ttsVoice'] === 'string')
-            overrides.ttsVoice = obj['ttsVoice'];
         if (typeof obj['voiceRuntime'] === 'string')
             overrides.voiceRuntime = obj['voiceRuntime'];
         if (typeof obj['fastRuntime'] === 'string')
@@ -568,32 +566,12 @@ export function detectMissingSecrets(ctx) {
     }
     const voiceEnabled = parseBoolean(ctx.env.DISCOCLAW_VOICE_ENABLED, false);
     if (voiceEnabled) {
-        const sttProvider = trimValue(ctx.env.DISCOCLAW_STT_PROVIDER) ?? 'deepgram';
-        const ttsProvider = trimValue(ctx.env.DISCOCLAW_TTS_PROVIDER) ?? 'cartesia';
-        const voiceSecretTargets = [];
-        if (sttProvider === 'deepgram') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_STT_PROVIDER', provider: sttProvider, secretKey: 'DEEPGRAM_API_KEY' });
-        }
-        else if (sttProvider === 'openai') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_STT_PROVIDER', provider: sttProvider, secretKey: 'OPENAI_API_KEY' });
-        }
-        if (ttsProvider === 'cartesia') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_TTS_PROVIDER', provider: ttsProvider, secretKey: 'CARTESIA_API_KEY' });
-        }
-        else if (ttsProvider === 'deepgram') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_TTS_PROVIDER', provider: ttsProvider, secretKey: 'DEEPGRAM_API_KEY' });
-        }
-        else if (ttsProvider === 'openai') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_TTS_PROVIDER', provider: ttsProvider, secretKey: 'OPENAI_API_KEY' });
-        }
-        for (const target of voiceSecretTargets) {
-            if (hasSecret(ctx.env, target.secretKey))
-                continue;
+        if (!hasSecret(ctx.env, 'GEMINI_API_KEY')) {
             findings.push({
-                id: `missing-secret:${target.label}:${target.secretKey}`,
+                id: 'missing-secret:DISCOCLAW_VOICE_ENABLED:GEMINI_API_KEY',
                 severity: 'error',
-                message: `${target.label}=${target.provider} requires ${target.secretKey}, but it is not set.`,
-                recommendation: `Set ${target.secretKey} or switch ${target.label} to a provider that is already configured.`,
+                message: 'DISCOCLAW_VOICE_ENABLED=1 requires GEMINI_API_KEY, but it is not set.',
+                recommendation: 'Set GEMINI_API_KEY or disable voice on this install.',
                 autoFixable: false,
             });
         }

package/dist/health/config-doctor.test.js

@@ -242,8 +242,6 @@ describe('detectMissingSecrets', () => {
         await writeEnv(cwd, [
             'PRIMARY_RUNTIME=openrouter',
             'DISCOCLAW_VOICE_ENABLED=1',
-            'DISCOCLAW_STT_PROVIDER=deepgram',
-            'DISCOCLAW_TTS_PROVIDER=cartesia',
             'DISCOCLAW_COLD_STORAGE_ENABLED=1',
             'DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1',
             'IMAGEGEN_DEFAULT_MODEL=imagen-4.0-generate-001',
@@ -256,8 +254,7 @@ describe('detectMissingSecrets', () => {
         expect(findings.map((finding) => finding.id)).toEqual([
             'missing-secret:PRIMARY_RUNTIME:OPENROUTER_API_KEY',
             'missing-secret:runtime-overrides.voiceRuntime:OPENAI_API_KEY',
-            'missing-secret:DISCOCLAW_STT_PROVIDER:DEEPGRAM_API_KEY',
-            'missing-secret:DISCOCLAW_TTS_PROVIDER:CARTESIA_API_KEY',
+            'missing-secret:DISCOCLAW_VOICE_ENABLED:GEMINI_API_KEY',
             'missing-secret:DISCOCLAW_COLD_STORAGE_ENABLED:COLD_STORAGE_API_KEY-or-OPENAI_API_KEY',
             'missing-secret:DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN:OPENAI_API_KEY-or-IMAGEGEN_GEMINI_API_KEY',
             'missing-secret:IMAGEGEN_DEFAULT_MODEL:IMAGEGEN_GEMINI_API_KEY',

package/dist/index.js

@@ -19,7 +19,7 @@ import { buildDurableMemorySection } from './discord/prompt-common.js';
 import { parseDiscordActions, executeDiscordActions, buildTieredDiscordActionsPromptSection, buildAllResultLines, appendActionResults } from './discord/actions.js';
 import { DiscordTransportClient } from './discord/transport-client.js';
 import { buildVoiceActionFlags } from './voice/voice-action-flags.js';
-import { loadVoiceIdentity, buildVoicePrompt, buildVoiceFollowUpPrompt, buildVoicePromptSectionEstimates } from './voice/voice-prompt-builder.js';
+import { loadVoiceIdentity, buildVoicePrompt, buildVoiceFollowUpPrompt, buildVoicePromptSectionEstimates, buildVoiceSystemInstruction, } from './voice/voice-prompt-builder.js';
 import { sanitizeForVoice, sanitizeVoiceReplyForSpeech } from './voice/voice-sanitize.js';
 import { shouldTriggerFollowUp } from './discord/action-categories.js';
 import { configureDeferredScheduler } from './discord/deferred-runner.js';
@@ -1105,9 +1105,6 @@ if (currentOverridesState.fastRuntime) {
         log.warn({ fastRuntime: currentOverridesState.fastRuntime, availableRuntimes: runtimeRegistry.list() }, 'runtime-overrides: fastRuntime is not a registered runtime; ignoring');
     }
 }
-if (currentOverridesState.ttsVoice) {
-    log.info({ ttsVoice: currentOverridesState.ttsVoice }, 'runtime-overrides: ttsVoice override will be applied');
-}
 // Track which roles have active file-backed overrides (used by !models show).
 // Only mark as override if the stored value differs from env defaults.
 const overrideSources = detectOverrideSources(currentModelConfig, envModelDefaults);
@@ -1261,8 +1258,6 @@ const botParams = {
     spawnCtx: undefined,
     voiceCtx: undefined,
     voiceStatusCtx: undefined,
-    setTtsVoice: undefined,
-    getTtsVoice: undefined,
     configCtx: undefined,
     deferOpts: undefined,
     messageHistoryBudget,
@@ -1325,13 +1320,8 @@ const botParams = {
     voiceEnabled: cfg.voiceEnabled,
     voiceAutoJoin: cfg.voiceAutoJoin,
     voiceModelCtx: voiceModelRef,
-    voiceSttProvider: cfg.voiceSttProvider,
-    voiceTtsProvider: cfg.voiceTtsProvider,
     voiceHomeChannel: cfg.voiceHomeChannel,
-    deepgramApiKey: cfg.deepgramApiKey,
-    deepgramSttModel: cfg.deepgramSttModel,
-    deepgramTtsVoice: cfg.deepgramTtsVoice,
-    cartesiaApiKey: cfg.cartesiaApiKey,
+    geminiApiKey: cfg.geminiApiKey,
     botStatus: cfg.botStatus,
     botActivity: cfg.botActivity,
     botActivityType: cfg.botActivityType,
@@ -2077,30 +2067,35 @@ if (taskCtx) {
                 }
             };
         }
+        const buildGeminiSystemInstruction = async () => {
+            const identity = await loadVoiceIdentity(workspaceCwd);
+            return buildVoiceSystemInstruction({
+                identity,
+                durableMemory: '',
+                voiceSystemPrompt: cfg.voiceSystemPrompt,
+                actionsSection: '',
+            });
+        };
         audioPipeline = new AudioPipelineManager({
             log,
             voiceConfig: {
                 enabled: cfg.voiceEnabled,
-                sttProvider: cfg.voiceSttProvider,
-                ttsProvider: cfg.voiceTtsProvider,
                 homeChannel: cfg.voiceHomeChannel,
-                deepgramApiKey: cfg.deepgramApiKey,
-                deepgramSttModel: cfg.deepgramSttModel,
-                deepgramTtsVoice: overrides.ttsVoice ?? cfg.deepgramTtsVoice,
-                deepgramTtsSpeed: cfg.deepgramTtsSpeed,
-                cartesiaApiKey: cfg.cartesiaApiKey,
-                openaiApiKey: cfg.openaiApiKey,
             },
             allowedUserIds: allowUserIds,
             createDecoder: opusDecoderFactory,
+            geminiApiKey: cfg.geminiApiKey,
+            enabledTools: runtimeTools,
             invokeAi: voiceInvokeAi,
             runtime: voiceRuntimeRef.runtime.id,
             runtimeModel: voiceModelRef.model,
             runtimeCwd: workspaceCwd,
             runtimeTimeoutMs,
+            sessionRotationMs: cfg.geminiSessionRotationMs,
             transcriptMirror,
             botDisplayName,
             backfill,
+            buildGeminiSystemInstruction,
             onTranscription: (guildId, result) => {
                 if (result.isFinal && result.text.trim()) {
                     log.info({ guildId, text: result.text, confidence: result.confidence }, 'voice:transcription');
@@ -2120,14 +2115,6 @@ if (taskCtx) {
             },
         });
         botParams.voiceStatusCtx = { voiceManager };
-        botParams.setTtsVoice = async (voice) => {
-            const count = await audioPipeline.setTtsVoice(voice);
-            botParams.deepgramTtsVoice = voice;
-            currentOverridesState.ttsVoice = voice;
-            saveOverrides(overridesPath, currentOverridesState).catch((err) => log.warn({ err, voice }, 'runtime-overrides: ttsVoice save failed'));
-            return count;
-        };
-        botParams.getTtsVoice = () => audioPipeline.ttsVoice;
         if (cfg.discordActionsVoice) {
             botParams.voiceCtx = { voiceManager };
             log.info('voice:action context initialized with audio pipeline');

package/dist/observability/trace-store.js

@@ -88,6 +88,62 @@ export class TraceStore {
             .slice(0, limit)
             .map(cloneTrace);
     }
+    get size() {
+        return this.traces.size;
+    }
+    summary() {
+        const allTraces = [...this.traces.values()];
+        const flows = ['message', 'reaction', 'cron', 'defer'];
+        const byFlow = {};
+        for (const flow of flows) {
+            const matching = allTraces.filter((t) => t.flow === flow);
+            const completed = matching.filter((t) => t.outcome !== 'in_progress');
+            const succeeded = completed.filter((t) => t.outcome === 'success').length;
+            const totalDuration = completed.reduce((sum, t) => sum + t.durationMs, 0);
+            byFlow[flow] = {
+                total: matching.length,
+                succeeded,
+                failed: completed.length - succeeded,
+                inProgress: matching.length - completed.length,
+                avgDurationMs: completed.length > 0 ? Math.round(totalDuration / completed.length) : 0,
+            };
+        }
+        const byOutcome = {};
+        for (const trace of allTraces) {
+            byOutcome[trace.outcome] = (byOutcome[trace.outcome] ?? 0) + 1;
+        }
+        const MAX_RECENT_ERRORS = 10;
+        const recentErrors = [];
+        const sorted = [...allTraces].sort((a, b) => b.startedAt - a.startedAt);
+        for (const trace of sorted) {
+            if (recentErrors.length >= MAX_RECENT_ERRORS)
+                break;
+            if (trace.outcome === 'success' || trace.outcome === 'in_progress')
+                continue;
+            const lastError = [...trace.events].reverse().find((e) => e.type === 'error');
+            recentErrors.push({
+                traceId: trace.traceId,
+                flow: trace.flow,
+                message: lastError && 'message' in lastError ? lastError.message : trace.outcome,
+                at: trace.startedAt,
+            });
+        }
+        let oldestAt = null;
+        let newestAt = null;
+        if (allTraces.length > 0) {
+            oldestAt = Math.min(...allTraces.map((t) => t.startedAt));
+            newestAt = Math.max(...allTraces.map((t) => t.startedAt));
+        }
+        return {
+            total: allTraces.length,
+            inProgress: allTraces.filter((t) => t.outcome === 'in_progress').length,
+            oldestAt,
+            newestAt,
+            byFlow,
+            byOutcome,
+            recentErrors,
+        };
+    }
     makeRoomForNewTrace() {
         this.pruneToLimit(this.maxEntries - 1);
     }

package/dist/observability/trace-utils.js

@@ -0,0 +1,31 @@
+/**
+ * Shared trace-event helpers for summarizing values before they enter trace events.
+ */
+export function summarizeTraceText(value, maxChars = 160) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.length <= maxChars) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(1, maxChars - 1))}…`;
+}
+export function summarizeTraceValue(value, maxChars = 160) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return summarizeTraceText(value, maxChars);
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized) {
+            return summarizeTraceText(serialized, maxChars);
+        }
+    }
+    catch {
+        // Fall through to String(value).
+    }
+    return summarizeTraceText(String(value), maxChars);
+}

package/dist/runtime/codex-cli.js

@@ -21,7 +21,8 @@ function mergeSystemPrompt(systemPrompt, appendSystemPrompt) {
 function normalizeInvokeParams(params, opts) {
     const requestedModel = params.model || opts.defaultModel;
     const remappedModel = remapCrossRuntimeTierModel(requestedModel, 'codex');
-    const effectiveModel = remappedModel?.model ?? requestedModel;
+    const normalizedModel = remappedModel?.model ?? requestedModel;
+    const effectiveModel = normalizedModel || opts.defaultModel;
     const effectiveReasoningEffort = params.reasoningEffort
         ?? (remappedModel ? resolveReasoningEffort(remappedModel.sourceTier, 'codex') : undefined);
     if (remappedModel) {
@@ -34,7 +35,7 @@ function normalizeInvokeParams(params, opts) {
     }
     return {
         ...params,
-        model: effectiveModel,
+        model: normalizedModel,
         ...(effectiveReasoningEffort ? { reasoningEffort: effectiveReasoningEffort } : {}),
         systemPrompt: mergeSystemPrompt(params.systemPrompt, opts.appendSystemPrompt),
         ...(opts.disableSessions ? { sessionKey: undefined } : {}),

package/dist/runtime/codex-cli.test.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CODEX_RUNTIME_CAPABILITIES } from './tool-capabilities.js';
+import { initTierOverrides } from './model-tiers.js';
 const { mockExeca } = vi.hoisted(() => {
     return {
         mockExeca: vi.fn(),
@@ -129,10 +130,12 @@ describe('Codex CLI runtime adapter', () => {
     const originalStableHome = process.env.DISCOCLAW_CODEX_STABLE_HOME;
     beforeEach(() => {
         mockExeca.mockReset();
+        initTierOverrides({});
         delete process.env.DISCOCLAW_CLI_LAUNCHER_STATE_HARDENING;
         delete process.env.DISCOCLAW_CODEX_STABLE_HOME;
     });
     afterEach(() => {
+        initTierOverrides({});
         if (originalHardening === undefined) {
             delete process.env.DISCOCLAW_CLI_LAUNCHER_STATE_HARDENING;
         }
@@ -294,6 +297,36 @@ describe('Codex CLI runtime adapter', () => {
             sourceTier: 'fast',
         }), 'codex:model remapped to codex-compatible tier default');
     });
+    it('falls back to the codex default model when the codex fast tier is configured as adapter-default sentinel', async () => {
+        initTierOverrides({ DISCOCLAW_TIER_CODEX_FAST: '' });
+        const log = {
+            debug: vi.fn(),
+            warn: vi.fn(),
+        };
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'cli remap ok',
+            exitCode: 0,
+        }));
+        const rt = createCodexCliRuntime({
+            codexBin: 'codex',
+            defaultModel: 'gpt-5.4',
+            log,
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Summarize',
+            model: 'gpt-5-mini',
+            cwd: '/tmp/non-default-cwd',
+        }));
+        const callArgs = mockExeca.mock.calls[0][1];
+        const modelIdx = callArgs.indexOf('-m');
+        expect(callArgs[modelIdx + 1]).toBe('gpt-5.4');
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({
+            requestedModel: 'gpt-5-mini',
+            effectiveModel: 'gpt-5.4',
+            sourceRuntimeId: 'openai',
+            sourceTier: 'fast',
+        }), 'codex:model remapped to codex-compatible tier default');
+    });
     it('large prompt uses stdin instead of positional arg', async () => {
         const largePrompt = 'x'.repeat(200_000);
         mockExeca.mockReturnValue(createMockSubprocess({

package/dist/runtime/model-tiers.js

@@ -168,7 +168,7 @@ export function remapCrossRuntimeTierModel(model, targetRuntimeId) {
     if (!sourceTier)
         return null;
     const targetModel = tierMap[targetRuntimeId]?.[sourceTier];
-    if (!targetModel || normalizeModelLookup(targetModel) === normalized)
+    if (targetModel === undefined || normalizeModelLookup(targetModel) === normalized)
         return null;
     return {
         sourceRuntimeId,

package/dist/runtime/model-tiers.test.js

@@ -238,6 +238,15 @@ describe('remapCrossRuntimeTierModel', () => {
             model: 'gpt-5.4',
         });
     });
+    it('preserves adapter-default sentinels when the target runtime tier is intentionally blank', () => {
+        initTierOverrides({ DISCOCLAW_TIER_CODEX_FAST: '' });
+        expect(remapCrossRuntimeTierModel('gpt-5-mini', 'codex')).toEqual({
+            sourceRuntimeId: 'openai',
+            sourceTier: 'fast',
+            targetRuntimeId: 'codex',
+            model: '',
+        });
+    });
     it('does not remap ambiguous cross-runtime models', () => {
         expect(remapCrossRuntimeTierModel('gpt-5.4', 'codex')).toBeNull();
     });

package/dist/runtime/openai-tool-schemas.js

@@ -3,7 +3,11 @@
  *
  * Maps internal tool names (Read, Write, …) to OpenAI function names
  * (read_file, write_file, …) and provides JSON Schema parameter definitions.
+ *
+ * Also provides `buildGeminiToolDeclarations()` to produce Gemini-compatible
+ * function declarations for the Multimodal Live API (Phase 2.1).
  */
+import { toGeminiTools } from '../voice/providers/gemini-tool-mapper.js';
 /** Discoclaw tool name → OpenAI function names */
 const DISCO_TO_OPENAI_NAMES = {
     Read: ['read_file'],
@@ -369,3 +373,16 @@ export function buildToolSchemas(enabledTools) {
     }
     return schemas;
 }
+/**
+ * Build Gemini-compatible function declarations for the given enabled tools.
+ *
+ * Composes `buildToolSchemas()` → `toGeminiTools()` so callers (e.g.
+ * AudioPipelineManager) can get Gemini Live–ready declarations in one call.
+ * Returns `undefined` when no tools match (same semantics as `toGeminiTools`).
+ */
+export function buildGeminiToolDeclarations(enabledTools, opts = {}) {
+    const schemas = buildToolSchemas(enabledTools);
+    return toGeminiTools(schemas, opts.nonBlocking
+        ? { nonBlockingFunctionNames: schemas.map((schema) => schema.function.name) }
+        : undefined);
+}

package/dist/runtime-overrides.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { parseRuntimeNameForPlacement } from './runtime/runtime-path-contract.js';
 const OVERRIDES_FILENAME = 'runtime-overrides.json';
-const KNOWN_OVERRIDE_KEYS = ['ttsVoice', 'voiceRuntime', 'fastRuntime'];
+const KNOWN_OVERRIDE_KEYS = ['voiceRuntime', 'fastRuntime'];
 export function normalizeRuntimeOverrides(overrides) {
     const next = { ...overrides };
     let changed = false;
@@ -57,8 +57,6 @@ export async function loadOverrides(filePath, onWarn) {
     }
     const obj = parsed;
     const overrides = {};
-    if (typeof obj['ttsVoice'] === 'string')
-        overrides.ttsVoice = obj['ttsVoice'];
     if (typeof obj['voiceRuntime'] === 'string')
         overrides.voiceRuntime = obj['voiceRuntime'];
     if (typeof obj['fastRuntime'] === 'string')
@@ -75,6 +73,7 @@ export async function saveOverrides(filePath, overrides) {
     const tmpPath = `${filePath}.tmp.${process.pid}`;
     try {
         const preserved = await readExistingRawObject(filePath);
+        delete preserved['ttsVoice'];
         for (const key of KNOWN_OVERRIDE_KEYS) {
             delete preserved[key];
         }