oh-my-knowledge 0.48.0 → 0.49.0

package/dist/executors/claude-protocol.js

@@ -0,0 +1,180 @@
+import { checkedSumTokenCounts, nonNegativeMetric, optionalTokenCount, } from '../shared/token-usage.js';
+import { extractAgentTrace, isClaudeSdkResultMessage } from './claude-sdk-trace.js';
+export function normalizeClaudeSdkMeasurements(result) {
+    const durationMs = optionalTokenCount(result.duration_ms);
+    const durationApiMs = optionalTokenCount(result.duration_api_ms);
+    const numTurns = optionalTokenCount(result.num_turns);
+    const costUSD = nonNegativeMetric(result.total_cost_usd);
+    if (durationMs === undefined
+        || durationApiMs === undefined
+        || numTurns === undefined
+        || costUSD === undefined
+        || costUSD > Number.MAX_SAFE_INTEGER) {
+        return { error: 'claude result contained invalid duration, turn, or cost metrics' };
+    }
+    const rawModelUsage = result.modelUsage;
+    const modelUsageEntries = rawModelUsage
+        && typeof rawModelUsage === 'object'
+        && !Array.isArray(rawModelUsage)
+        ? Object.values(rawModelUsage)
+        : [];
+    const buckets = [[], [], [], []];
+    if (modelUsageEntries.length > 0) {
+        for (const entry of modelUsageEntries) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                return { error: 'claude result contained invalid modelUsage' };
+            }
+            const counts = [
+                optionalTokenCount(entry.inputTokens),
+                optionalTokenCount(entry.outputTokens),
+                optionalTokenCount(entry.cacheReadInputTokens),
+                optionalTokenCount(entry.cacheCreationInputTokens),
+            ];
+            if (counts.some((count) => count === undefined)) {
+                return { error: 'claude result contained invalid modelUsage token counters' };
+            }
+            buckets.forEach((bucket, index) => bucket.push(counts[index]));
+        }
+    }
+    else {
+        const usage = result.usage;
+        const counts = [
+            optionalTokenCount(usage?.input_tokens),
+            optionalTokenCount(usage?.output_tokens),
+            usage?.cache_read_input_tokens === undefined
+                ? 0
+                : optionalTokenCount(usage.cache_read_input_tokens),
+            usage?.cache_creation_input_tokens === undefined
+                ? 0
+                : optionalTokenCount(usage.cache_creation_input_tokens),
+        ];
+        if (counts.some((count) => count === undefined)) {
+            return { error: 'claude result contained missing or invalid token usage' };
+        }
+        buckets.forEach((bucket, index) => bucket.push(counts[index]));
+    }
+    const totals = buckets.map((bucket) => checkedSumTokenCounts(...bucket));
+    if (totals.some((total) => total === undefined)
+        || checkedSumTokenCounts(...totals) === undefined) {
+        return { error: 'claude token usage aggregate exceeds safe integer' };
+    }
+    return {
+        durationMs,
+        durationApiMs,
+        inputTokens: totals[0],
+        outputTokens: totals[1],
+        cacheReadTokens: totals[2],
+        cacheCreationTokens: totals[3],
+        costUSD,
+        numTurns,
+    };
+}
+export function parseClaudeStreamJson(stdout) {
+    const messages = [];
+    let malformedLineCount = 0;
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const value = JSON.parse(trimmed);
+            if (!value
+                || typeof value !== 'object'
+                || Array.isArray(value)
+                || typeof value.type !== 'string') {
+                malformedLineCount += 1;
+            }
+            else {
+                messages.push(value);
+            }
+        }
+        catch {
+            malformedLineCount += 1;
+        }
+    }
+    return { messages, malformedLineCount };
+}
+export function buildClaudeResult(options) {
+    const { messages, wallClockDurationMs, source, malformedLineCount = 0, forcedError, messageTimestamps, } = options;
+    const resultMessages = messages.filter(isClaudeSdkResultMessage);
+    const trace = extractAgentTrace(messages, messageTimestamps);
+    const traceFields = {
+        fullNumTurns: trace.fullNumTurns,
+        numSubAgents: trace.numSubAgents,
+        ...(trace.turns.length > 0 && { turns: trace.turns }),
+        ...(trace.toolCalls.length > 0 && { toolCalls: trace.toolCalls }),
+    };
+    const errors = [];
+    if (forcedError)
+        errors.push(forcedError);
+    if (malformedLineCount > 0) {
+        errors.push(`${source} output contained ${malformedLineCount} malformed line(s)`);
+    }
+    if (resultMessages.length !== 1) {
+        errors.push(resultMessages.length === 0
+            ? `no result message in ${source} output`
+            : `expected exactly one result message in ${source} output, received ${resultMessages.length}`);
+        return {
+            ok: false,
+            error: [...new Set(errors)].join('; '),
+            durationMs: wallClockDurationMs,
+            durationApiMs: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            tokenUsageReportedByExecutor: false,
+            costUSD: 0,
+            costReportedByExecutor: false,
+            output: null,
+            stopReason: 'error',
+            numTurns: 0,
+            ...traceFields,
+        };
+    }
+    const result = resultMessages[0];
+    const measurements = normalizeClaudeSdkMeasurements(result);
+    if ('error' in measurements) {
+        errors.push(measurements.error);
+        return {
+            ok: false,
+            error: [...new Set(errors)].join('; '),
+            durationMs: wallClockDurationMs,
+            durationApiMs: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            tokenUsageReportedByExecutor: false,
+            costUSD: 0,
+            costReportedByExecutor: false,
+            output: typeof result.result === 'string' && result.result ? result.result : null,
+            stopReason: 'error',
+            numTurns: 0,
+            ...traceFields,
+        };
+    }
+    if (result.subtype !== 'success') {
+        errors.push(result.errors?.filter(Boolean).join('; ') || result.subtype || `${source} failed`);
+    }
+    else if (result.errors?.length) {
+        errors.push(result.errors.filter(Boolean).join('; '));
+    }
+    const output = typeof result.result === 'string' && result.result.trim()
+        ? result.result
+        : null;
+    if (!output)
+        errors.push(`${source} completed without an assistant response`);
+    const uniqueErrors = [...new Set(errors.filter(Boolean))];
+    return {
+        ok: uniqueErrors.length === 0,
+        ...(uniqueErrors.length > 0 && { error: uniqueErrors.join('; ') }),
+        ...measurements,
+        ...((forcedError || malformedLineCount > 0) && {
+            tokenUsageReportedByExecutor: false,
+        }),
+        output,
+        stopReason: uniqueErrors.length === 0 ? result.stop_reason || 'end_turn' : 'error',
+        ...traceFields,
+    };
+}

package/dist/executors/claude-sdk-trace.js

@@ -1,4 +1,6 @@
 import { safeSliceForJson } from '../util/safe-slice.js';
+import { isToolResultFailureText } from '../observability/text-signals.js';
+import { normalizeToolIdentity } from '../shared/tool-identity.js';
 export function isClaudeSdkResultMessage(message) {
     return message.type === 'result';
 }
@@ -21,16 +23,36 @@ export function extractAgentTrace(messages, timestamps) {
             const textParts = [];
             const turnToolCalls = [];
             let hasNonThinking = false;
-            for (const block of content) {
+            for (let blockIndex = 0; blockIndex < content.length; blockIndex += 1) {
+                const block = content[blockIndex];
                 if (block.type === 'text' && block.text) {
                     textParts.push(block.text);
                     hasNonThinking = true;
                 }
                 else if (block.type === 'tool_use' && block.name) {
-                    pendingToolUse.set(block.id || '', { tool: block.name, input: block.input });
-                    turnToolCalls.push({ tool: block.name, input: block.input, output: null, success: true });
+                    const toolIdentity = normalizeToolIdentity({ sourceName: block.name });
+                    const toolCall = {
+                        tool: toolIdentity.name,
+                        ...(toolIdentity.sourceName ? { sourceTool: toolIdentity.sourceName } : {}),
+                        ...(toolIdentity.namespace ? { toolNamespace: toolIdentity.namespace } : {}),
+                        ...(toolIdentity.provider ? { toolProvider: toolIdentity.provider } : {}),
+                        input: block.input,
+                        output: null,
+                        status: 'unknown',
+                        statusSource: 'unknown',
+                        success: false,
+                        callInstanceId: `claude-sdk:${msgIdx}:${blockIndex}`,
+                        toolUseId: block.id,
+                    };
+                    if (block.id) {
+                        const pending = pendingToolUse.get(block.id) ?? [];
+                        pending.push(toolCall);
+                        pendingToolUse.set(block.id, pending);
+                    }
+                    turnToolCalls.push(toolCall);
+                    toolCalls.push(toolCall);
                     hasNonThinking = true;
-                    if (block.name === 'Agent')
+                    if (toolIdentity.name === 'Agent')
                         numSubAgents++;
                 }
                 else if (block.type !== 'thinking') {
@@ -52,12 +74,17 @@ export function extractAgentTrace(messages, timestamps) {
             }
         }
         if (msg.type === 'user') {
-            for (const block of content) {
+            for (let blockIndex = 0; blockIndex < content.length; blockIndex += 1) {
+                const block = content[blockIndex];
                 if (block.type !== 'tool_result')
                     continue;
                 const toolUseId = block.tool_use_id || '';
-                const pending = pendingToolUse.get(toolUseId);
-                const isError = block.is_error || false;
+                const pendingQueue = pendingToolUse.get(toolUseId);
+                const pending = pendingQueue?.shift();
+                if (pendingQueue?.length === 0)
+                    pendingToolUse.delete(toolUseId);
+                const runtimeError = block.is_error;
+                const hasRuntimeStatus = typeof runtimeError === 'boolean';
                 const resultContent = block.content;
                 const outputText = typeof resultContent === 'string'
                     ? resultContent
@@ -68,27 +95,29 @@ export function extractAgentTrace(messages, timestamps) {
                 // is_error 因此为 true,但语义上是"mock 成功返回"。识别前缀 → 覆盖 success=true。
                 // 见 src/eval-core/mocks-runtime.ts 的 wrappedReason 前缀。
                 const isMockHit = outputText.startsWith('[mock] simulated tool output');
-                const effectiveSuccess = isMockHit ? true : !isError;
-                const tc = {
-                    tool: pending?.tool || 'unknown',
-                    input: pending?.input || null,
-                    output: safeSliceForJson(outputText, 500, ''),
-                    success: effectiveSuccess,
+                const inferredFailure = !hasRuntimeStatus && isToolResultFailureText(outputText);
+                const tc = pending ?? {
+                    tool: 'unknown',
+                    input: null,
+                    output: null,
+                    status: 'unknown',
+                    statusSource: 'unknown',
+                    success: false,
+                    callInstanceId: `claude-sdk:orphan-result:${msgIdx}:${blockIndex}`,
+                    toolUseId,
                 };
-                toolCalls.push(tc);
-                if (pending) {
-                    for (let i = turns.length - 1; i >= 0; i--) {
-                        const turn = turns[i];
-                        if (turn.role === 'assistant' && turn.toolCalls) {
-                            const placeholder = turn.toolCalls.find((t) => t.tool === pending.tool && t.output === null);
-                            if (placeholder) {
-                                placeholder.output = tc.output;
-                                placeholder.success = effectiveSuccess;
-                                break;
-                            }
-                        }
-                    }
-                }
+                tc.output = safeSliceForJson(outputText, 500, '');
+                tc.status = isMockHit
+                    ? 'success'
+                    : hasRuntimeStatus
+                        ? runtimeError ? 'failure' : 'success'
+                        : inferredFailure ? 'failure' : 'unknown';
+                tc.statusSource = isMockHit
+                    ? 'tool-output'
+                    : hasRuntimeStatus ? 'runtime' : inferredFailure ? 'inferred' : 'unknown';
+                tc.success = tc.status === 'success';
+                if (!pending)
+                    toolCalls.push(tc);
                 const toolDur = msgTs && lastTurnTs ? msgTs - lastTurnTs : undefined;
                 turns.push({
                     role: 'tool',
@@ -97,7 +126,6 @@ export function extractAgentTrace(messages, timestamps) {
                 });
                 if (msgTs)
                     lastTurnTs = msgTs;
-                pendingToolUse.delete(toolUseId);
             }
         }
     }

package/dist/executors/claude-sdk.d.ts

@@ -1,4 +1,5 @@
 import type { ExecResult, ExecutorInput } from '../types/index.js';
+export { normalizeClaudeSdkMeasurements } from './claude-protocol.js';
 /**
  * Map ExecutorInput.allowedSkills to SDK query options for skill isolation.
  *   undefined → {} (SDK default: full ~/.claude/skills/ discovery)

package/dist/executors/claude-sdk.js

@@ -1,9 +1,10 @@
 import { join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { extractAgentTrace, isClaudeSdkResultMessage } from './claude-sdk-trace.js';
-import { asErrorLike, buildExecEnv, DEFAULT_TIMEOUT_MS, errorMessage } from './shared.js';
+import { asErrorLike, buildExecEnv, DEFAULT_TIMEOUT_MS, errorMessage, interruptedExecResult, registerSigintSubscriber, timeoutExecResult, } from './shared.js';
 import { buildSdkHookCallback } from '../eval-core/mocks-runtime.js';
+import { buildClaudeResult } from './claude-protocol.js';
+export { normalizeClaudeSdkMeasurements } from './claude-protocol.js';
 let sdkQuery = null;
 /**
  * Map ExecutorInput.allowedSkills to SDK query options for skill isolation.
@@ -41,7 +42,15 @@ export async function claudeSdkExecutor({ model, system, prompt, cwd, skillDir,
     const isolationOpts = lean ? { skills: [], disallowedTools: ['*'] } : baseIsolationOpts;
     const start = Date.now();
     const abortController = new AbortController();
-    const timer = setTimeout(() => abortController.abort(), timeoutMs);
+    let abortReason;
+    const abort = (reason) => {
+        if (abortReason)
+            return;
+        abortReason = reason;
+        abortController.abort();
+    };
+    const timer = setTimeout(() => abort('timeout'), timeoutMs);
+    const unregisterSigint = registerSigintSubscriber(() => abort('interrupted'));
     const env = buildExecEnv(skillDir);
     const messages = [];
     const messageTimestamps = [];
@@ -74,14 +83,10 @@ export async function claudeSdkExecutor({ model, system, prompt, cwd, skillDir,
                 ...hooksOpts,
             },
         });
-        const resultMsgs = [];
         for await (const msg of stream) {
             messages.push(msg);
             messageTimestamps.push(Date.now());
-            if (isClaudeSdkResultMessage(msg))
-                resultMsgs.push(msg);
         }
-        clearTimeout(timer);
         if (verbose) {
             try {
                 const debugDir = join(tmpdir(), 'omk-debug');
@@ -95,111 +100,52 @@ export async function claudeSdkExecutor({ model, system, prompt, cwd, skillDir,
             }
             catch { }
         }
-        if (resultMsgs.length === 0) {
-            const durationMs = Date.now() - start;
-            process.stderr.write(`[omk] claude-sdk executor: no result message received (${messages.length} messages)\n`);
-            return {
-                ok: false, error: 'no result message received',
-                durationMs, durationApiMs: 0,
-                inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0,
-                costUSD: 0, output: null, stopReason: 'error', numTurns: 0,
-                ...(mockStatsOf() && { mockStats: mockStatsOf() }),
-            };
-        }
-        let output = '';
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let totalCacheReadTokens = 0;
-        let totalCacheCreationTokens = 0;
-        let totalCostUSD = 0;
-        let totalDurationApiMs = 0;
-        let totalNumTurns = 0;
-        let lastSubtype = 'success';
-        for (const r of resultMsgs) {
-            output += r.result || '';
-            // Prefer modelUsage (includes subAgent tokens) over usage (main process only)
-            const modelUsage = r.modelUsage;
-            if (modelUsage) {
-                for (const mu of Object.values(modelUsage)) {
-                    totalInputTokens += mu.inputTokens || 0;
-                    totalOutputTokens += mu.outputTokens || 0;
-                    totalCacheReadTokens += mu.cacheReadInputTokens || 0;
-                    totalCacheCreationTokens += mu.cacheCreationInputTokens || 0;
-                }
-            }
-            else {
-                totalInputTokens += r.usage?.input_tokens || 0;
-                totalOutputTokens += r.usage?.output_tokens || 0;
-                totalCacheReadTokens += r.usage?.cache_read_input_tokens || 0;
-                totalCacheCreationTokens += r.usage?.cache_creation_input_tokens || 0;
-            }
-            totalCostUSD += r.total_cost_usd || 0;
-            totalDurationApiMs += r.duration_api_ms || 0;
-            totalNumTurns += r.num_turns || 0;
-            lastSubtype = r.subtype || lastSubtype;
-        }
-        const durationMs = resultMsgs[resultMsgs.length - 1].duration_ms || (Date.now() - start);
-        const trace = extractAgentTrace(messages, messageTimestamps);
-        if (lastSubtype !== 'success') {
-            const lastErr = resultMsgs[resultMsgs.length - 1];
-            const errMsg = lastErr.errors?.join('; ') || lastErr.subtype;
-            process.stderr.write(`[omk] claude-sdk executor: ${lastErr.subtype}: ${errMsg}\n`);
-            return {
-                ok: false, error: errMsg,
-                durationMs,
-                durationApiMs: totalDurationApiMs,
-                inputTokens: totalInputTokens,
-                outputTokens: totalOutputTokens,
-                cacheReadTokens: totalCacheReadTokens,
-                cacheCreationTokens: totalCacheCreationTokens,
-                costUSD: totalCostUSD,
-                output: null, stopReason: 'error', numTurns: totalNumTurns,
-                fullNumTurns: trace.fullNumTurns,
-                numSubAgents: trace.numSubAgents,
-                ...(trace.turns.length > 0 && { turns: trace.turns }),
-                ...(trace.toolCalls.length > 0 && { toolCalls: trace.toolCalls }),
-                ...(mockStatsOf() && { mockStats: mockStatsOf() }),
-            };
-        }
         return {
-            ok: true,
-            durationMs,
-            durationApiMs: totalDurationApiMs,
-            inputTokens: totalInputTokens,
-            outputTokens: totalOutputTokens,
-            cacheReadTokens: totalCacheReadTokens,
-            cacheCreationTokens: totalCacheCreationTokens,
-            costUSD: totalCostUSD,
-            output,
-            stopReason: 'end',
-            numTurns: totalNumTurns,
-            fullNumTurns: trace.fullNumTurns,
-            numSubAgents: trace.numSubAgents,
-            ...(trace.turns.length > 0 && { turns: trace.turns }),
-            ...(trace.toolCalls.length > 0 && { toolCalls: trace.toolCalls }),
+            ...buildClaudeResult({
+                messages,
+                messageTimestamps,
+                wallClockDurationMs: Date.now() - start,
+                source: 'claude-sdk',
+            }),
             ...(mockStatsOf() && { mockStats: mockStatsOf() }),
         };
     }
     catch (err) {
-        clearTimeout(timer);
         const durationMs = Date.now() - start;
         const details = asErrorLike(err);
         const isAbort = details.name === 'AbortError';
+        if (abortReason === 'interrupted') {
+            return {
+                ...interruptedExecResult(durationMs),
+                ...(mockStatsOf() && { mockStats: mockStatsOf() }),
+            };
+        }
+        if (abortReason === 'timeout') {
+            return {
+                ...timeoutExecResult(timeoutMs, durationMs),
+                ...(mockStatsOf() && { mockStats: mockStatsOf() }),
+            };
+        }
         if (isAbort) {
-            process.stderr.write(`[omk] claude-sdk executor: timed out after ${timeoutMs / 1000}s\n`);
+            process.stderr.write('[omk] claude-sdk executor: execution aborted\n');
         }
         else {
             process.stderr.write(`[omk] claude-sdk executor error: ${errorMessage(err)}\n`);
         }
         return {
             ok: false,
-            error: isAbort ? `execution timed out after ${timeoutMs / 1000}s` : errorMessage(err),
+            error: isAbort ? 'claude-sdk execution aborted' : errorMessage(err),
             durationMs, durationApiMs: 0,
             inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0,
-            costUSD: 0, output: null,
-            stopReason: isAbort ? 'timeout' : 'error',
+            tokenUsageReportedByExecutor: false,
+            costUSD: 0, costReportedByExecutor: false, output: null,
+            stopReason: 'error',
             numTurns: 0,
             ...(mockStatsOf() && { mockStats: mockStatsOf() }),
         };
     }
+    finally {
+        clearTimeout(timer);
+        unregisterSigint();
+    }
 }