discoclaw 1.2.3 → 1.3.0

package/dist/discord/reaction-handler.js

@@ -21,6 +21,8 @@ import { downloadMessageImages, resolveMediaType } from './image-download.js';
 import { downloadTextAttachments, classifyAttachments, downloadDocumentAttachments } from './file-download.js';
 import { mapRuntimeErrorToUserMessage } from './user-errors.js';
 import { globalMetrics } from '../observability/metrics.js';
+import { globalTraceStore } from '../observability/trace-store.js';
+import { summarizeTraceValue } from '../observability/trace-utils.js';
 import { resolveModel } from '../runtime/model-tiers.js';
 import { resolveGroundedToolCapabilities } from '../runtime/tool-capabilities.js';
 import { adaptRuntimeEventText } from './runtime-event-text-adapter.js';
@@ -522,6 +524,9 @@ function createReactionHandler(mode, params, queue, statusRef) {
                     let currentPrompt = prompt;
                     let pendingFollowUp = null;
                     const actionHistory = [];
+                    const traceId = `reaction_${randomUUID()}`;
+                    let traceOutcome = 'success';
+                    globalTraceStore.startTrace(traceId, sessionKey, 'reaction', reaction.message.channelId);
                     try {
                         // -- auto-follow-up loop --
                         while (true) {
@@ -606,8 +611,15 @@ function createReactionHandler(mode, params, queue, statusRef) {
                             const t0 = Date.now();
                             const previewMode = params.streamPreviewMode ?? 'compact';
                             const debugStreamPreviewLines = Boolean(params.debugStreamPreviewLines);
+                            const toolStartTimesByName = new Map();
                             metrics.recordInvokeStart('reaction');
                             params.log?.info({ flow: 'reaction', sessionKey }, 'obs.invoke.start');
+                            globalTraceStore.addEvent(traceId, {
+                                type: 'invoke_start',
+                                at: t0,
+                                summary: followUpDepth === 0 ? 'initial invoke' : `follow-up ${followUpDepth}`,
+                                promptPreview: summarizeTraceValue(currentPrompt, 220),
+                            });
                             let invokeError = null;
                             let lastEditAt = 0;
                             let streamEditTimeoutStreak = 0;
@@ -819,10 +831,39 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                     lastEventAt = Date.now();
                                     stallWarned = false;
                                     lastStallProgressAt = 0;
-                                    if (evt.type === 'tool_start')
+                                    if (evt.type === 'tool_start') {
                                         activeToolCount++;
-                                    else if (evt.type === 'tool_end')
+                                        const startedAt = Date.now();
+                                        const existingStarts = toolStartTimesByName.get(evt.name) ?? [];
+                                        existingStarts.push(startedAt);
+                                        toolStartTimesByName.set(evt.name, existingStarts);
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'tool_start',
+                                            at: startedAt,
+                                            toolName: evt.name,
+                                            inputSummary: summarizeTraceValue(evt.input),
+                                        });
+                                    }
+                                    else if (evt.type === 'tool_end') {
                                         activeToolCount = Math.max(0, activeToolCount - 1);
+                                        const endedAt = Date.now();
+                                        const existingStarts = toolStartTimesByName.get(evt.name) ?? [];
+                                        const startedAt = existingStarts.shift();
+                                        if (existingStarts.length > 0) {
+                                            toolStartTimesByName.set(evt.name, existingStarts);
+                                        }
+                                        else {
+                                            toolStartTimesByName.delete(evt.name);
+                                        }
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'tool_end',
+                                            at: endedAt,
+                                            toolName: evt.name,
+                                            ok: evt.ok,
+                                            durationMs: startedAt == null ? undefined : Math.max(0, endedAt - startedAt),
+                                            outputSummary: summarizeTraceValue(evt.output),
+                                        });
+                                    }
                                     if (evt.type === 'text_final') {
                                         hadTextFinal = true;
                                         finalText = evt.text;
@@ -845,6 +886,14 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                     }
                                     else if (evt.type === 'error') {
                                         invokeError = evt.message;
+                                        traceOutcome = 'error';
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'error',
+                                            at: Date.now(),
+                                            message: evt.message,
+                                            stage: 'runtime',
+                                            summary: followUpDepth === 0 ? 'initial invoke' : `follow-up ${followUpDepth}`,
+                                        });
                                         metrics.recordInvokeResult('reaction', Date.now() - t0, false, evt.message);
                                         params.log?.error({ sessionKey, error: evt.message }, `${logPrefix}:runtime error`);
                                         params.log?.warn({ flow: 'reaction', sessionKey, error: evt.message }, 'obs.invoke.error');
@@ -864,6 +913,15 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                 streamEditQueue = Promise.resolve();
                             }
                             metrics.recordInvokeResult('reaction', Date.now() - t0, !invokeError, invokeError ?? undefined);
+                            if (invokeError) {
+                                traceOutcome = 'error';
+                            }
+                            globalTraceStore.addEvent(traceId, {
+                                type: 'invoke_end',
+                                at: Date.now(),
+                                ok: !invokeError,
+                                summary: followUpDepth === 0 ? 'initial invoke' : `follow-up ${followUpDepth}`,
+                            });
                             params.log?.info({ flow: 'reaction', sessionKey, ms: Date.now() - t0, ok: !invokeError }, 'obs.invoke.end');
                             let processedText = finalText || deltaText || (collectedImages.length > 0 ? '' : '(no output)');
                             params.log?.info({ sessionKey, sessionId, ms: Date.now() - t0, hadError: Boolean(invokeError) }, `${logPrefix}:invoke:end`);
@@ -939,8 +997,18 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                         spawnCtx: params.spawnCtx,
                                     });
                                     actionResults = results;
-                                    for (const result of results) {
+                                    for (let i = 0; i < results.length; i++) {
+                                        const result = results[i];
                                         metrics.recordActionResult(result.ok);
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'action_result',
+                                            at: Date.now(),
+                                            action: parsed.actions[i]?.type ?? 'unknown',
+                                            ok: result.ok,
+                                            detail: result.ok
+                                                ? summarizeTraceValue(result.summary, 220)
+                                                : summarizeTraceValue(result.error, 220),
+                                        });
                                         params.log?.info({ flow: 'reaction', sessionKey, ok: result.ok }, 'obs.action.result');
                                     }
                                     // Record action history for follow-up dedup.
@@ -1089,6 +1157,15 @@ function createReactionHandler(mode, params, queue, statusRef) {
                         } // end while (true)
                     }
                     catch (innerErr) {
+                        traceOutcome = 'error';
+                        globalTraceStore.addEvent(traceId, {
+                            type: 'error',
+                            at: Date.now(),
+                            message: innerErr instanceof Error ? innerErr.message : String(innerErr),
+                            name: innerErr instanceof Error ? innerErr.name : undefined,
+                            stack: innerErr instanceof Error ? summarizeTraceValue(innerErr.stack, 400) : undefined,
+                            stage: 'reaction_flow',
+                        });
                         // Inner catch: attempt to show the error in the reply before the finally
                         // block runs dispose(). Setting replyFinalized = true on success prevents
                         // the finally's safety-net delete from removing the error message.
@@ -1107,6 +1184,7 @@ function createReactionHandler(mode, params, queue, statusRef) {
                         throw innerErr;
                     }
                     finally {
+                        globalTraceStore.endTrace(traceId, traceOutcome);
                         // Safety net runs before dispose() so cold-start recovery can still see
                         // the in-flight entry if the delete fails.
                         if (!replyFinalized && reply && !isShuttingDown()) {

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';
@@ -2077,6 +2077,15 @@ if (taskCtx) {
                 }
             };
         }
+        const buildGeminiSystemInstruction = async () => {
+            const identity = await loadVoiceIdentity(workspaceCwd);
+            return buildVoiceSystemInstruction({
+                identity,
+                durableMemory: '',
+                voiceSystemPrompt: cfg.voiceSystemPrompt,
+                actionsSection: '',
+            });
+        };
         audioPipeline = new AudioPipelineManager({
             log,
             voiceConfig: {
@@ -2093,14 +2102,19 @@ if (taskCtx) {
             },
             allowedUserIds: allowUserIds,
             createDecoder: opusDecoderFactory,
+            voiceProvider: cfg.voicePipelineProvider,
+            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');

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);
+}