@agnt5/sdk 0.3.5 → 0.3.7

package/dist/scorer.js

@@ -39,13 +39,14 @@ const SCORER_MARKER = Symbol('scorer');
  * );
  * ```
  */
-export function scorer(name, description) {
+export function scorer(name, description, scope = 'item') {
     return function (handler) {
         const scorerName = name || handler.name || 'unnamed_scorer';
         const config = {
             name: scorerName,
             handler,
             description: description || '',
+            scope,
             isAsync: handler.constructor.name === 'AsyncFunction',
         };
         handler[SCORER_MARKER] = config;
@@ -337,6 +338,8 @@ Respond with a JSON object containing:
 - "explanation": brief explanation of your evaluation
 
 Respond ONLY with the JSON object, no other text.`;
+const CORRECTNESS_JUDGE_CRITERIA = 'Evaluate whether the output correctly answers the input and matches the expected output. Score 1.0 for fully correct answers, 0.5 for partially correct answers, and 0.0 for incorrect or unsupported answers.';
+const FAITHFULNESS_JUDGE_CRITERIA = 'Evaluate whether the output is faithful to the provided context. Penalize claims that are unsupported, contradicted by context, or omit critical context needed for the answer.';
 /**
  * LLM-as-judge scorer: ask an LM to score the output against criteria.
  *
@@ -359,12 +362,13 @@ Respond ONLY with the JSON object, no other text.`;
 export async function llmJudge(request, ctx) {
     const cfg = request.config ?? {};
     const criteria = typeof cfg.criteria === 'string' ? cfg.criteria : '';
-    if (!criteria) {
+    const promptTemplate = typeof cfg.prompt_template === 'string' ? cfg.prompt_template : '';
+    if (!criteria && !promptTemplate) {
         return new ScorerResult({
             score: 0.0,
             passed: false,
             label: 'config_error',
-            explanation: 'llm_judge requires `config.criteria`',
+            explanation: 'llm_judge requires `config.criteria` or `config.prompt_template`',
         });
     }
     const providerName = typeof cfg.provider === 'string' ? cfg.provider : 'openai';
@@ -380,15 +384,52 @@ export async function llmJudge(request, ctx) {
     const systemPrompt = typeof cfg.system_prompt === 'string' ? cfg.system_prompt : LLM_JUDGE_DEFAULT_SYSTEM_PROMPT;
     const temperature = typeof cfg.temperature === 'number' ? cfg.temperature : 0.0;
     const includeInput = cfg.include_input === true;
+    const contextData = cfg.context_data ?? cfg.context;
+    const choiceScoresResult = parseChoiceScores(cfg.choice_scores);
+    if (choiceScoresResult.error) {
+        return new ScorerResult({
+            score: 0.0,
+            passed: false,
+            label: 'config_error',
+            explanation: choiceScoresResult.error,
+        });
+    }
+    const choiceScores = choiceScoresResult.scores;
     // Build the user prompt the same way Rust/Python do — keeps judge
     // verdicts comparable across languages.
-    let userContent = `## Evaluation Criteria\n${criteria}\n\n`;
-    if (includeInput && request.input !== undefined && request.input !== null) {
-        userContent += `## Input\n${formatJudgeValue(request.input)}\n\n`;
+    let userContent;
+    if (promptTemplate) {
+        const rendered = renderPromptTemplate(promptTemplate, {
+            input: request.input,
+            output: request.output,
+            expected: request.expected,
+            context: contextData,
+        });
+        if (rendered.error) {
+            return new ScorerResult({
+                score: 0.0,
+                passed: false,
+                label: 'config_error',
+                explanation: rendered.error,
+            });
+        }
+        userContent = `${rendered.text.trimEnd()}\n\n`;
+    }
+    else {
+        userContent = `## Evaluation Criteria\n${criteria}\n\n`;
+        if (includeInput && request.input !== undefined && request.input !== null) {
+            userContent += `## Input\n${formatJudgeValue(request.input)}\n\n`;
+        }
+        if (contextData !== undefined && contextData !== null) {
+            userContent += `## Context\n${formatJudgeValue(contextData)}\n\n`;
+        }
+        userContent += `## Output to Evaluate\n${formatJudgeValue(request.output)}\n\n`;
+        if (request.expected !== undefined && request.expected !== null) {
+            userContent += `## Expected Output (Reference)\n${formatJudgeValue(request.expected)}\n\n`;
+        }
     }
-    userContent += `## Output to Evaluate\n${formatJudgeValue(request.output)}\n\n`;
-    if (request.expected !== undefined && request.expected !== null) {
-        userContent += `## Expected Output (Reference)\n${formatJudgeValue(request.expected)}\n\n`;
+    if (choiceScores) {
+        userContent += `Choose exactly one label from: ${Object.keys(choiceScores).sort().join(', ')}. Return that label in the JSON \`label\` field. The platform will map labels to scores.\n\n`;
     }
     userContent += 'Please evaluate the output and respond with a JSON object.';
     // Tests / advanced usage can inject an LM via the context. Default
@@ -426,7 +467,7 @@ export async function llmJudge(request, ctx) {
             explanation: `LLM call failed: ${e.message}`,
         });
     }
-    return parseLlmJudgeResponse(response.text ?? '');
+    return applyChoiceScores(parseLlmJudgeResponse(response.text ?? ''), choiceScores);
 }
 function formatJudgeValue(v) {
     if (typeof v === 'string')
@@ -516,15 +557,237 @@ function extractJudgeJson(raw) {
     }
     return s;
 }
+function renderPromptTemplate(template, values) {
+    try {
+        return {
+            text: template.replace(/{{\s*([^{}]+?)\s*}}/g, (_match, selector) => formatJudgeValue(templateSelectedValue(values, String(selector).trim()))),
+        };
+    }
+    catch (e) {
+        return { error: `prompt_template variable not found: ${e.message}` };
+    }
+}
+function templateSelectedValue(values, selector) {
+    const [root, ...parts] = selector.split('.');
+    if (!(root in values))
+        throw new Error(selector);
+    let value = values[root];
+    for (const part of parts) {
+        if (!part)
+            throw new Error(selector);
+        if (value && typeof value === 'object' && !Array.isArray(value) && part in value) {
+            value = value[part];
+            continue;
+        }
+        if (Array.isArray(value) && /^\d+$/.test(part)) {
+            const index = Number(part);
+            if (index < value.length) {
+                value = value[index];
+                continue;
+            }
+        }
+        throw new Error(selector);
+    }
+    return value;
+}
+function parseChoiceScores(raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { error: 'llm_judge `config.choice_scores` must be an object mapping label to score' };
+    }
+    const scores = {};
+    for (const [label, score] of Object.entries(raw)) {
+        if (!label.trim()) {
+            return { error: 'llm_judge `config.choice_scores` labels must be non-empty' };
+        }
+        if (typeof score !== 'number' || score < 0 || score > 1) {
+            return { error: `llm_judge choice score for label '${label}' must be between 0 and 1` };
+        }
+        scores[label] = score;
+    }
+    if (Object.keys(scores).length === 0) {
+        return { error: 'llm_judge `config.choice_scores` must include at least one label' };
+    }
+    return { scores };
+}
+function applyChoiceScores(result, choiceScores) {
+    if (!choiceScores || result.label === 'parse_error' || result.label === 'config_error') {
+        return result;
+    }
+    const labels = Object.keys(choiceScores).sort();
+    if (!result.label || !(result.label in choiceScores)) {
+        return new ScorerResult({
+            score: 0.0,
+            passed: false,
+            label: 'invalid_label',
+            explanation: `Judge returned label ${JSON.stringify(result.label)}; expected one of: ${labels.join(', ')}`,
+            metadata: {
+                ...(result.metadata ?? {}),
+                allowed_labels: labels,
+                ...(result.label ? { invalid_label: result.label } : {}),
+            },
+        });
+    }
+    const score = Math.max(0, Math.min(1, choiceScores[result.label]));
+    return new ScorerResult({
+        score,
+        passed: score >= 0.7,
+        label: result.label,
+        explanation: result.explanation,
+        metadata: {
+            ...(result.metadata ?? {}),
+            choice_scores: choiceScores,
+            selected_label: result.label,
+        },
+    });
+}
+export async function correctness(request, ctx) {
+    const cfg = request.config ?? {};
+    let output;
+    let expected;
+    try {
+        output = optionalSelectedValue(request, cfg.answer_field, request.output);
+        expected = optionalSelectedValue(request, cfg.reference_field, request.expected);
+    }
+    catch (e) {
+        return judgeConfigError(`correctness field selector not found: ${e.message}`);
+    }
+    if (expected === undefined || expected === null) {
+        return judgeConfigError('correctness requires expected output or config.reference_field');
+    }
+    const result = await llmJudge({
+        ...request,
+        output,
+        expected,
+        config: {
+            provider: cfg.provider ?? 'openai',
+            model: cfg.model ?? 'gpt-4o-mini',
+            criteria: CORRECTNESS_JUDGE_CRITERIA,
+            include_input: cfg.include_input ?? true,
+            temperature: cfg.temperature ?? 0.0,
+        },
+    }, ctx);
+    return mergeJudgeMetadata(result, {
+        judge_preset: 'correctness',
+    });
+}
+export async function faithfulness(request, ctx) {
+    const cfg = request.config ?? {};
+    const fields = contextFields(cfg);
+    if (fields.length === 0) {
+        return judgeConfigError('faithfulness requires config.context_fields or config.context_field');
+    }
+    let output;
+    const context = {};
+    try {
+        output = optionalSelectedValue(request, cfg.answer_field, request.output);
+        for (const field of fields) {
+            context[field] = selectedValue(request, field);
+        }
+    }
+    catch (e) {
+        return judgeConfigError(`faithfulness field selector not found: ${e.message}`);
+    }
+    const result = await llmJudge({
+        ...request,
+        output,
+        config: {
+            provider: cfg.provider ?? 'openai',
+            model: cfg.model ?? 'gpt-4o-mini',
+            criteria: FAITHFULNESS_JUDGE_CRITERIA,
+            include_input: cfg.include_input ?? false,
+            temperature: cfg.temperature ?? 0.0,
+            context_data: context,
+        },
+    }, ctx);
+    return mergeJudgeMetadata(result, {
+        judge_preset: 'faithfulness',
+        context_fields: fields,
+    });
+}
+function judgeConfigError(explanation) {
+    return new ScorerResult({
+        score: 0.0,
+        passed: false,
+        label: 'config_error',
+        explanation,
+    });
+}
+function mergeJudgeMetadata(result, metadata) {
+    return new ScorerResult({
+        score: result.score,
+        passed: result.passed,
+        label: result.label,
+        explanation: result.explanation,
+        metadata: { ...(result.metadata ?? {}), ...metadata },
+    });
+}
+function contextFields(config) {
+    const fields = [];
+    if (typeof config.context_field === 'string' && config.context_field.trim()) {
+        fields.push(config.context_field.trim());
+    }
+    if (Array.isArray(config.context_fields)) {
+        for (const field of config.context_fields) {
+            if (typeof field === 'string' && field.trim())
+                fields.push(field.trim());
+        }
+    }
+    return fields;
+}
+function optionalSelectedValue(request, selector, fallback) {
+    if (selector === undefined || selector === null || selector === '')
+        return fallback;
+    if (typeof selector !== 'string')
+        throw new Error(String(selector));
+    return selectedValue(request, selector);
+}
+function selectedValue(request, selector) {
+    const [root, ...parts] = selector.trim().split('.');
+    if (!root || parts.length === 0)
+        throw new Error(selector);
+    let value;
+    switch (root) {
+        case 'input':
+            value = request.input;
+            break;
+        case 'output':
+            value = request.output;
+            break;
+        case 'expected':
+            value = request.expected;
+            break;
+        default:
+            throw new Error(selector);
+    }
+    for (const part of parts) {
+        if (value && typeof value === 'object' && !Array.isArray(value) && part in value) {
+            value = value[part];
+            continue;
+        }
+        if (Array.isArray(value) && /^\d+$/.test(part)) {
+            const index = Number(part);
+            if (index < value.length) {
+                value = value[index];
+                continue;
+            }
+        }
+        throw new Error(selector);
+    }
+    return value;
+}
 // Register built-in scorers
-ScorerRegistry.register({ name: 'exact_match', handler: (_ctx, req) => exactMatch(req), description: 'Exact string match', isAsync: false });
-ScorerRegistry.register({ name: 'contains', handler: (_ctx, req) => contains(req), description: 'Substring containment check', isAsync: false });
-ScorerRegistry.register({ name: 'json_valid', handler: (_ctx, req) => jsonValid(req), description: 'Valid JSON check', isAsync: false });
-ScorerRegistry.register({ name: 'json_schema', handler: (_ctx, req) => jsonSchema(req), description: 'Validate against a JSON Schema', isAsync: false });
-ScorerRegistry.register({ name: 'numeric_range', handler: (_ctx, req) => numericRange(req), description: 'Numeric output is in [min, max]', isAsync: false });
-ScorerRegistry.register({ name: 'regex_match', handler: (_ctx, req) => regexMatch(req), description: 'Regex pattern match', isAsync: false });
-ScorerRegistry.register({ name: 'levenshtein', handler: (_ctx, req) => levenshtein(req), description: 'Levenshtein edit distance', isAsync: false });
-ScorerRegistry.register({ name: 'llm_judge', handler: (ctx, req) => llmJudge(req, ctx), description: 'LLM-as-judge: ask an LM to score the output against criteria', isAsync: true });
+ScorerRegistry.register({ name: 'exact_match', handler: (_ctx, req) => exactMatch(req), description: 'Exact string match', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'contains', handler: (_ctx, req) => contains(req), description: 'Substring containment check', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'json_valid', handler: (_ctx, req) => jsonValid(req), description: 'Valid JSON check', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'json_schema', handler: (_ctx, req) => jsonSchema(req), description: 'Validate against a JSON Schema', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'numeric_range', handler: (_ctx, req) => numericRange(req), description: 'Numeric output is in [min, max]', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'regex_match', handler: (_ctx, req) => regexMatch(req), description: 'Regex pattern match', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'levenshtein', handler: (_ctx, req) => levenshtein(req), description: 'Levenshtein edit distance', scope: 'item', isAsync: false });
+ScorerRegistry.register({ name: 'llm_judge', handler: (ctx, req) => llmJudge(req, ctx), description: 'LLM-as-judge: ask an LM to score the output against criteria', scope: 'item', isAsync: true });
+ScorerRegistry.register({ name: 'correctness', handler: (ctx, req) => correctness(req, ctx), description: 'Managed LLM judge preset for answer correctness', scope: 'item', isAsync: true });
+ScorerRegistry.register({ name: 'faithfulness', handler: (ctx, req) => faithfulness(req, ctx), description: 'Managed LLM judge preset for faithfulness to configured context', scope: 'item', isAsync: true });
 // ─── Runner ──────────────────────────────────────────────────────────
 /**
  * Run a scorer by name against a request.
@@ -540,9 +803,125 @@ export async function runScorer(scorerName, request, ctx) {
         attempt: 0,
         log: () => { },
     };
-    return config.handler(scorerCtx, request);
+    const bound = applyScorerFieldBindings(request);
+    if (bound.error) {
+        return new ScorerResult({
+            score: 0.0,
+            passed: false,
+            label: 'config_error',
+            explanation: `${scorerName} field binding error: ${bound.error}`,
+        });
+    }
+    const result = await config.handler(scorerCtx, bound.request);
+    return mergeResultMetadata(result, bound.metadata);
 }
 // ─── Helpers ─────────────────────────────────────────────────────────
+function applyScorerFieldBindings(request) {
+    const cfg = request.config ?? {};
+    const metadata = {};
+    try {
+        const output = bindRequestField(cfg, 'output', 'output_field', 'output_type', request.output, metadata);
+        const expected = request.expected !== undefined || hasFieldBinding(cfg, 'expected_field', 'expected_type')
+            ? bindRequestField(cfg, 'expected', 'expected_field', 'expected_type', request.expected, metadata)
+            : request.expected;
+        const input = request.input !== undefined || hasFieldBinding(cfg, 'input_field', 'input_type')
+            ? bindRequestField(cfg, 'input', 'input_field', 'input_type', request.input, metadata)
+            : request.input;
+        return {
+            request: { ...request, output, expected, input },
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        };
+    }
+    catch (e) {
+        return { error: e.message };
+    }
+}
+function hasFieldBinding(config, fieldKey, typeKey) {
+    return config[fieldKey] !== undefined || config[typeKey] !== undefined;
+}
+function bindRequestField(config, root, fieldKey, typeKey, value, metadata) {
+    let selected = value;
+    const selector = config[fieldKey];
+    if (typeof selector === 'string' && selector.trim()) {
+        selected = boundFieldValue(value, selector.trim(), root);
+        metadata[fieldKey] = selector.trim();
+    }
+    const expectedType = config[typeKey];
+    if (typeof expectedType === 'string' && expectedType.trim()) {
+        if (!valueTypeMatches(selected, expectedType.trim())) {
+            throw new Error(`${fieldKey} selected ${valueTypeName(selected)}; expected ${expectedType.trim()}`);
+        }
+        metadata[typeKey] = expectedType.trim();
+    }
+    return selected;
+}
+function boundFieldValue(value, selector, root) {
+    const prefix = `${root}.`;
+    const path = selector === root ? '' : selector.startsWith(prefix) ? selector.slice(prefix.length) : selector;
+    if (!path)
+        return value;
+    let current = value;
+    for (const part of path.split('.')) {
+        if (!part) {
+            throw new Error(`${root}_field ${JSON.stringify(selector)} contains an empty path segment`);
+        }
+        if (current && typeof current === 'object' && !Array.isArray(current) && part in current) {
+            current = current[part];
+            continue;
+        }
+        if (Array.isArray(current) && /^\d+$/.test(part)) {
+            const index = Number(part);
+            if (index < current.length) {
+                current = current[index];
+                continue;
+            }
+        }
+        throw new Error(`${root}_field ${JSON.stringify(selector)} was not found`);
+    }
+    return current;
+}
+function valueTypeMatches(value, expectedType) {
+    const normalized = expectedType.toLowerCase();
+    if (normalized === 'null')
+        return value === null || value === undefined;
+    if (normalized === 'bool' || normalized === 'boolean')
+        return typeof value === 'boolean';
+    if (normalized === 'number')
+        return typeof value === 'number';
+    if (normalized === 'string')
+        return typeof value === 'string';
+    if (normalized === 'array')
+        return Array.isArray(value);
+    if (normalized === 'object')
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    return false;
+}
+function valueTypeName(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (typeof value === 'number')
+        return 'number';
+    if (typeof value === 'string')
+        return 'string';
+    if (typeof value === 'object')
+        return 'object';
+    return typeof value;
+}
+function mergeResultMetadata(result, metadata) {
+    if (!metadata)
+        return result;
+    return new ScorerResult({
+        score: result.score,
+        passed: result.passed,
+        label: result.label,
+        explanation: result.explanation,
+        metadata: { ...(result.metadata ?? {}), ...metadata },
+    });
+}
 /** Helper methods for ScorerRequest */
 export function getRequestConfig(request, key, defaultValue) {
     return request.config?.[key] ?? defaultValue;
@@ -557,4 +936,220 @@ export function getTotalTokens(request) {
         .filter(e => e.eventType === 'lm.call.completed')
         .reduce((sum, e) => sum + (e.data.total_tokens || 0), 0);
 }
+/** Extract typed tool calls from ScorerRequest journal events */
+export function getToolCalls(request) {
+    return extractToolCallsFromEvents(request.trace || []);
+}
+/** Extract typed tool calls from journal events */
+export function extractToolCallsFromEvents(events = []) {
+    const calls = [];
+    const byKey = new Map();
+    const add = (call, fallbackKey) => {
+        if (!call?.name)
+            return;
+        const key = call.callId || call.spanId || fallbackKey;
+        const existingIndex = byKey.get(key);
+        if (existingIndex !== undefined) {
+            calls[existingIndex] = mergeToolCalls(calls[existingIndex], call);
+            return;
+        }
+        byKey.set(key, calls.length);
+        calls.push(call);
+    };
+    for (const event of events) {
+        const data = isRecord(event.data) ? event.data : {};
+        iterToolCallPayloads(data).forEach((payload, index) => {
+            add(toolCallFromMapping(payload, event, index), `${eventIdOf(event)}:payload:${index}`);
+        });
+        if (eventTypeOf(event).includes('tool')) {
+            add(toolCallFromMapping(data, event, 0), eventIdOf(event));
+        }
+    }
+    return calls;
+}
+/** Return tool names in observed call order */
+export function getToolCallNames(request) {
+    return toolCallNames(getToolCalls(request));
+}
+/** Return tool-call names from typed tool calls */
+export function toolCallNames(calls) {
+    return calls.map(call => call.name).filter(Boolean);
+}
+/** Return true when the observed trajectory exactly matches expected */
+export function toolTrajectoryExact(actual, expected) {
+    return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
+}
+/** Return true when expected appears as an ordered subsequence */
+export function toolTrajectoryInOrder(actual, expected) {
+    if (expected.length === 0)
+        return true;
+    let index = 0;
+    for (const name of actual) {
+        if (name === expected[index]) {
+            index += 1;
+            if (index === expected.length)
+                return true;
+        }
+    }
+    return false;
+}
+/** Return true when actual contains expected names with matching counts */
+export function toolTrajectoryAnyOrder(actual, expected) {
+    const remaining = new Map();
+    for (const name of actual)
+        remaining.set(name, (remaining.get(name) || 0) + 1);
+    for (const name of expected) {
+        const count = remaining.get(name) || 0;
+        if (count <= 0)
+            return false;
+        remaining.set(name, count - 1);
+    }
+    return true;
+}
+/** Compare a tool trajectory using exact, in_order, or any_order semantics */
+export function toolTrajectoryMatches(actual, expected, mode = 'exact') {
+    if (mode === 'exact')
+        return toolTrajectoryExact(actual, expected);
+    if (mode === 'in_order')
+        return toolTrajectoryInOrder(actual, expected);
+    return toolTrajectoryAnyOrder(actual, expected);
+}
+function iterToolCallPayloads(data) {
+    const payloads = [];
+    const extendFrom = (value) => {
+        if (Array.isArray(value)) {
+            payloads.push(...value.filter(isRecord));
+        }
+    };
+    extendFrom(data.tool_calls);
+    extendFrom(data.toolCalls);
+    for (const key of ['normalized_session', 'session', 'trace_session', 'journal_session']) {
+        if (isRecord(data[key])) {
+            extendFrom(data[key].tool_calls);
+            extendFrom(data[key].toolCalls);
+        }
+    }
+    for (const key of ['response', 'output', 'message']) {
+        if (isRecord(data[key])) {
+            extendFrom(data[key].tool_calls);
+            extendFrom(data[key].toolCalls);
+        }
+    }
+    if (Array.isArray(data.choices)) {
+        for (const choice of data.choices) {
+            if (isRecord(choice?.message)) {
+                extendFrom(choice.message.tool_calls);
+                extendFrom(choice.message.toolCalls);
+            }
+        }
+    }
+    return payloads;
+}
+function toolCallFromMapping(payload, event, index) {
+    const fnPayload = isRecord(payload.function) ? payload.function : {};
+    const eventType = eventTypeOf(event);
+    const name = stringOrUndefined(firstPresent(payload.name, payload.tool_name, fnPayload.name, eventType.includes('tool') ? event.name : undefined));
+    if (!name)
+        return undefined;
+    const callId = stringOrUndefined(firstPresent(payload.call_id, payload.tool_call_id, payload.id, eventType.includes('tool') ? event.correlationId : undefined));
+    const rawArgs = firstPresent(payload.arguments, payload.args, fnPayload.arguments);
+    return {
+        name,
+        arguments: decodeArguments(rawArgs),
+        callId,
+        spanId: stringOrUndefined(payload.span_id) || event.correlationId,
+        timestampNs: numberOrUndefined(payload.timestamp_ns) || event.timestampNs,
+        startedAt: numberOrUndefined(payload.started_at),
+        endedAt: numberOrUndefined(payload.ended_at),
+        status: stringOrUndefined(payload.status) || statusFromEventType(eventType),
+        metadata: toolCallMetadata(payload, event, index),
+    };
+}
+function toolCallMetadata(payload, event, index) {
+    const metadata = {
+        source_event_id: eventIdOf(event),
+        source_event_type: eventTypeOf(event),
+        source_index: index,
+    };
+    for (const key of [
+        'arguments_ref',
+        'args_ref',
+        'arguments_hash',
+        'args_hash',
+        'result_ref',
+        'result_hash',
+        'output_ref',
+        'output_hash',
+        'duration_ms',
+        'error_code',
+        'error_message_sanitized',
+    ]) {
+        if (payload[key] !== undefined && payload[key] !== null)
+            metadata[key] = payload[key];
+    }
+    if (isRecord(payload.attributes_safe))
+        metadata.attributes_safe = payload.attributes_safe;
+    return metadata;
+}
+function mergeToolCalls(existing, incoming) {
+    return {
+        name: incoming.name || existing.name,
+        arguments: incoming.arguments !== undefined ? incoming.arguments : existing.arguments,
+        callId: incoming.callId || existing.callId,
+        spanId: incoming.spanId || existing.spanId,
+        timestampNs: existing.timestampNs || incoming.timestampNs,
+        startedAt: existing.startedAt || incoming.startedAt,
+        endedAt: incoming.endedAt || existing.endedAt,
+        status: incoming.status || existing.status,
+        metadata: { ...existing.metadata, ...incoming.metadata },
+    };
+}
+function decodeArguments(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function firstPresent(...values) {
+    return values.find(value => value !== undefined && value !== null);
+}
+function stringOrUndefined(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    return text || undefined;
+}
+function numberOrUndefined(value) {
+    if (value === undefined || value === null || typeof value === 'boolean')
+        return undefined;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? Math.trunc(value) : undefined;
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? Math.trunc(parsed) : undefined;
+    }
+    return undefined;
+}
+function statusFromEventType(eventType) {
+    if (eventType.endsWith('.started'))
+        return 'started';
+    if (eventType.endsWith('.completed'))
+        return 'completed';
+    if (eventType.endsWith('.failed'))
+        return 'failed';
+    return undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function eventTypeOf(event) {
+    return event.eventType || event.event_type || '';
+}
+function eventIdOf(event) {
+    return event.eventId || event.event_id || '';
+}
 //# sourceMappingURL=scorer.js.map