clementine-agent 1.18.199 → 1.18.201

package/dist/agent/run-agent.d.ts

@@ -73,6 +73,8 @@ export interface RunAgentOptions {
         tool: string;
         input: Record<string, unknown>;
     }) => void | Promise<void>;
+    /** Fires after the runId is generated, before SDK execution starts. */
+    onRunStart?: (runId: string) => void;
     /** Abort signal — when triggered, the SDK stream is cancelled. */
     abortSignal?: AbortSignal;
     /** Optional override of the AgentDefinition map. Mostly for tests. */

package/dist/agent/run-agent.js

@@ -97,6 +97,7 @@ export function invalidateMcpStatusEntry(name) {
 import { BASE_DIR, PKG_DIR, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, normalizeClaudeSdkOptionsForOneMillionContext, TOOL_OUTPUT_GUARD, } from '../config.js';
 import { buildGuardHooks } from './tool-output-guard.js';
 import { buildDedupHook } from './tool-call-dedup.js';
+import { buildSideEffectIdempotencyHook } from './side-effect-idempotency.js';
 import { buildChatStopHook } from './chat-stop-hook.js';
 import { buildAgentMap } from './agent-definitions.js';
 import { buildExecutionToolPolicy, } from './execution-policy.js';
@@ -351,6 +352,10 @@ export async function runAgent(prompt, opts) {
     // tool-output guard (1.18.169) can namespace its on-disk archive by
     // runId. EventLog writers below also reference this id.
     const runId = randomUUID();
+    try {
+        opts.onRunStart?.(runId);
+    }
+    catch { /* telemetry callback only */ }
     const eventLog = new EventLog();
     let eventSeq = 0;
     const writeEvent = (e) => {
@@ -445,6 +450,25 @@ export async function runAgent(prompt, opts) {
             });
         },
     });
+    // ── Side-effect idempotency hook (1.18.201) ────────────────────────
+    // Prevents exact duplicate high-confidence external mutations across
+    // context-overflow resumes/retries. This is intentionally narrow:
+    // confident email sends and CRM mutations only, keyed by stable identity
+    // fields. Unknown side effects remain event-log/audit data, not blocks.
+    const idempotency = buildSideEffectIdempotencyHook({
+        runId,
+        sessionKey: opts.sessionKey,
+        onDecision: (info) => {
+            if (info.decision !== 'block')
+                return;
+            writeEvent({
+                kind: 'error',
+                ts: new Date().toISOString(),
+                sessionId,
+                toolError: `_clementine_idempotency:block ${info.toolName} ${info.summary ?? ''}`.trim(),
+            });
+        },
+    });
     // ── Chat persistence Stop hook (1.18.184, source='chat' only) ─────
     // Keeps chat-initiated multi-step jobs running until they finish.
     // Inspects the model's last assistant message for continuation
@@ -476,6 +500,10 @@ export async function runAgent(prompt, opts) {
     // Merge hook maps from the modules. SDK accepts arrays of
     // HookCallbackMatcher per event; we concatenate.
     const mergedHooks = { ...guard.hooks };
+    for (const [evt, matchers] of Object.entries(idempotency.hooks)) {
+        const existing = mergedHooks[evt] ?? [];
+        mergedHooks[evt] = [...existing, ...matchers];
+    }
     for (const [evt, matchers] of Object.entries(dedup.hooks)) {
         const existing = mergedHooks[evt] ?? [];
         mergedHooks[evt] = [...existing, ...matchers];
@@ -827,6 +855,12 @@ export async function runAgent(prompt, opts) {
             warned: dedup.stats.warned,
             blocked: dedup.stats.blocked,
         } : undefined,
+        idempotency: idempotency.stats.guarded > 0 ? {
+            guarded: idempotency.stats.guarded,
+            blocked: idempotency.stats.blocked,
+            recorded: idempotency.stats.recorded,
+            failedNotRecorded: idempotency.stats.failedNotRecorded,
+        } : undefined,
     }, 'runAgent: query complete');
     // PRD §6 Phase 4e: subagent transcript backfill (Path C). The SDK persists
     // every subagent's full message stream to ~/.claude/projects/<encoded-cwd>/

package/dist/agent/run-summary.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Run summaries derived from the durable Clementine event log.
+ *
+ * The event log is the source of truth for "what actually fired" during an
+ * SDK run. This module turns raw tool_call/tool_result rows into a compact,
+ * provider-neutral summary that chat overflow recovery can show to the owner
+ * and feed back into a fresh continuation prompt.
+ */
+import { EventLog } from '../gateway/event-log.js';
+import { type SideEffectVerdict } from './side-effect-classifier.js';
+export interface SideEffectCall {
+    runId: string;
+    toolName: string;
+    toolUseId: string;
+    input: Record<string, unknown>;
+    timestamp: string;
+    verdict: SideEffectVerdict;
+    result?: {
+        successful: boolean;
+        raw: unknown;
+        reason: string;
+        statusCode?: number;
+        error?: string;
+    };
+}
+export interface RunSummary {
+    runIds: string[];
+    sessionIds: string[];
+    totalEvents: number;
+    successfulSideEffects: SideEffectCall[];
+    failedSideEffects: SideEffectCall[];
+    pendingSideEffects: SideEffectCall[];
+    unknownEffectCalls: SideEffectCall[];
+    readOnlyCount: number;
+    errors: Array<{
+        runId: string;
+        ts: string;
+        message: string;
+    }>;
+    lastAssistantText?: string;
+    ended: 'session_end' | 'error' | 'in_progress';
+}
+export declare function summarizeRunSideEffects(runIds: string | string[], eventLog?: EventLog): RunSummary;
+export declare function hasOperationalActivity(summary: RunSummary): boolean;
+export declare function extractRecipients(input: Record<string, unknown>): string[];
+export declare function formatOverflowRecoveryMessage(summary: RunSummary): string;
+export declare function buildContinuationPrompt(summary: RunSummary, originalRequest: string): string;
+//# sourceMappingURL=run-summary.d.ts.map

package/dist/agent/run-summary.js

@@ -0,0 +1,287 @@
+/**
+ * Run summaries derived from the durable Clementine event log.
+ *
+ * The event log is the source of truth for "what actually fired" during an
+ * SDK run. This module turns raw tool_call/tool_result rows into a compact,
+ * provider-neutral summary that chat overflow recovery can show to the owner
+ * and feed back into a fresh continuation prompt.
+ */
+import { EventLog } from '../gateway/event-log.js';
+import { classifyToolCall, isToolResultSuccessful, normalizedToolResultPayload, } from './side-effect-classifier.js';
+function uniqueRunIds(runIds) {
+    const raw = Array.isArray(runIds) ? runIds : [runIds];
+    const out = [];
+    for (const id of raw) {
+        if (!id || out.includes(id))
+            continue;
+        out.push(id);
+    }
+    return out;
+}
+function asInput(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function isToolCall(event) {
+    return event.kind === 'tool_call'
+        && typeof event.toolName === 'string'
+        && typeof event.toolUseId === 'string'
+        && !!event.toolName
+        && !!event.toolUseId;
+}
+function resultForToolUse(events, toolUseId) {
+    return events.find((event) => event.kind === 'tool_result' && event.toolUseId === toolUseId);
+}
+function summarizeResult(result) {
+    if (!result)
+        return undefined;
+    return isToolResultSuccessful(result.toolResult, !!result.toolError);
+}
+function makeCall(call, result, verdict) {
+    const success = summarizeResult(result);
+    return {
+        runId: call.runId,
+        toolName: call.toolName,
+        toolUseId: call.toolUseId,
+        input: asInput(call.toolInput),
+        timestamp: call.ts,
+        verdict,
+        ...(success ? {
+            result: {
+                successful: success.successful,
+                raw: normalizedToolResultPayload(result?.toolResult),
+                reason: success.reason,
+                ...(success.statusCode !== undefined ? { statusCode: success.statusCode } : {}),
+                ...(success.error ? { error: success.error } : {}),
+            },
+        } : {}),
+    };
+}
+export function summarizeRunSideEffects(runIds, eventLog = new EventLog()) {
+    const ids = uniqueRunIds(runIds);
+    const events = ids.flatMap((runId) => eventLog.readByRun(runId));
+    const sessionIds = Array.from(new Set(events.map((event) => event.sessionId).filter((id) => !!id)));
+    const successfulSideEffects = [];
+    const failedSideEffects = [];
+    const pendingSideEffects = [];
+    const unknownEffectCalls = [];
+    let readOnlyCount = 0;
+    for (const call of events.filter(isToolCall)) {
+        const verdict = classifyToolCall(call.toolName, asInput(call.toolInput));
+        const result = resultForToolUse(events, call.toolUseId);
+        const item = makeCall(call, result, verdict);
+        if (verdict.kind === 'read_only') {
+            readOnlyCount += 1;
+            continue;
+        }
+        if (verdict.kind === 'unknown') {
+            unknownEffectCalls.push(item);
+            continue;
+        }
+        if (!result) {
+            pendingSideEffects.push(item);
+            continue;
+        }
+        if (item.result?.successful)
+            successfulSideEffects.push(item);
+        else
+            failedSideEffects.push(item);
+    }
+    const errors = events
+        .filter((event) => event.kind === 'error' || event.toolError)
+        .map((event) => ({
+        runId: event.runId,
+        ts: event.ts,
+        message: String(event.toolError ?? event.text ?? 'error').slice(0, 500),
+    }));
+    const lastAssistantText = [...events]
+        .reverse()
+        .find((event) => event.kind === 'llm_text' && typeof event.text === 'string' && event.text.trim())
+        ?.text;
+    const ended = events.some((event) => event.kind === 'session_end')
+        ? 'session_end'
+        : errors.length > 0 ? 'error' : 'in_progress';
+    return {
+        runIds: ids,
+        sessionIds,
+        totalEvents: events.length,
+        successfulSideEffects,
+        failedSideEffects,
+        pendingSideEffects,
+        unknownEffectCalls,
+        readOnlyCount,
+        errors,
+        ...(lastAssistantText ? { lastAssistantText } : {}),
+        ended,
+    };
+}
+export function hasOperationalActivity(summary) {
+    return summary.successfulSideEffects.length > 0
+        || summary.failedSideEffects.length > 0
+        || summary.pendingSideEffects.length > 0
+        || summary.unknownEffectCalls.length > 0;
+}
+function toolKindLabel(toolName) {
+    const lower = toolName.toLowerCase();
+    if (lower.includes('email') || lower.includes('gmail') || lower.includes('outlook') || lower.includes('send_email')) {
+        return 'email sends';
+    }
+    if (lower.includes('salesforce') || lower.includes('__sf_') || lower.includes('sfdc')) {
+        return 'CRM mutations';
+    }
+    if (toolName === 'Bash')
+        return 'Bash commands';
+    return toolName;
+}
+function groupCounts(calls) {
+    const map = new Map();
+    for (const call of calls) {
+        const label = toolKindLabel(call.toolName);
+        map.set(label, [...(map.get(label) ?? []), call]);
+    }
+    return Array.from(map.entries()).map(([label, grouped]) => ({ label, count: grouped.length, calls: grouped }));
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function arrayStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .flatMap((item) => {
+        if (typeof item === 'string')
+            return [item];
+        if (item && typeof item === 'object') {
+            const obj = item;
+            return [firstString(obj.email, obj.address, obj.mail, obj.name)].filter((v) => !!v);
+        }
+        return [];
+    })
+        .filter(Boolean);
+}
+export function extractRecipients(input) {
+    const direct = [
+        ...arrayStrings(input.to),
+        ...arrayStrings(input.toRecipients),
+        ...arrayStrings(input.recipients),
+        ...arrayStrings(input.cc),
+        ...arrayStrings(input.bcc),
+    ];
+    const singles = [
+        firstString(input.to, input.recipient, input.email, input.to_email, input.toEmail),
+    ].filter((v) => !!v);
+    return Array.from(new Set([...direct, ...singles]));
+}
+function extractSubject(input) {
+    return firstString(input.subject, input.title);
+}
+function extractProviderLogId(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const obj = raw;
+    return firstString(obj.logId, obj.log_id, obj.id)
+        ?? (obj.data && typeof obj.data === 'object' ? extractProviderLogId(obj.data) : undefined);
+}
+function statusPhrase(call) {
+    const status = call.result?.statusCode;
+    if (status && toolKindLabel(call.toolName) === 'email sends')
+        return `accepted (${status})`;
+    if (status)
+        return `succeeded (${status})`;
+    return 'succeeded';
+}
+function recipientPreview(calls, max = 3) {
+    const recipients = calls.flatMap((call) => extractRecipients(call.input));
+    if (recipients.length === 0)
+        return '';
+    const shown = recipients.slice(0, max);
+    const rest = recipients.length - shown.length;
+    return ` (${shown.join(', ')}${rest > 0 ? `, +${rest} more` : ''})`;
+}
+function formatGroupedLines(prefix, calls) {
+    return groupCounts(calls).map((group) => `- ${group.count} ${group.label} ${prefix}${recipientPreview(group.calls)}`);
+}
+export function formatOverflowRecoveryMessage(summary) {
+    const lines = [
+        'That run hit the context limit after some work had already happened.',
+        '',
+    ];
+    if (summary.successfulSideEffects.length > 0) {
+        lines.push('Completed before overflow:');
+        lines.push(...formatGroupedLines('completed', summary.successfulSideEffects));
+        lines.push('');
+    }
+    if (summary.failedSideEffects.length > 0 || summary.pendingSideEffects.length > 0 || summary.unknownEffectCalls.length > 0) {
+        lines.push('Needs attention:');
+        if (summary.failedSideEffects.length > 0)
+            lines.push(...formatGroupedLines('failed', summary.failedSideEffects));
+        if (summary.pendingSideEffects.length > 0)
+            lines.push(...formatGroupedLines('started, no confirmation', summary.pendingSideEffects));
+        if (summary.unknownEffectCalls.length > 0)
+            lines.push(`- ${summary.unknownEffectCalls.length} tool call(s) had unknown external effect`);
+        lines.push('');
+    }
+    if (summary.readOnlyCount > 0) {
+        lines.push(`Read-only tool calls before overflow: ${summary.readOnlyCount}`);
+        lines.push('');
+    }
+    lines.push('Reply `continue` within 30 minutes to resume from this state, or `done` to stop here.');
+    return lines.join('\n').slice(0, 1900);
+}
+function formatDetailedCall(call) {
+    const recipients = extractRecipients(call.input);
+    const subject = extractSubject(call.input);
+    const logId = call.result ? extractProviderLogId(call.result.raw) : undefined;
+    const parts = [
+        toolKindLabel(call.toolName),
+        recipients.length ? `to ${recipients.join(', ')}` : undefined,
+        subject ? `subject "${subject}"` : undefined,
+        call.result ? statusPhrase(call) : 'started, no confirmation',
+        logId ? `logId ${logId}` : undefined,
+        `run ${call.runId}`,
+    ].filter(Boolean);
+    return `- ${parts.join(' · ')}`;
+}
+export function buildContinuationPrompt(summary, originalRequest) {
+    const lines = [];
+    lines.push('[Resume context — read this before taking any action]');
+    lines.push(`The previous SDK run(s) hit a context limit: ${summary.runIds.join(', ')}`);
+    lines.push('Some tool calls may already have changed external state. DO NOT re-run completed side effects.');
+    lines.push('');
+    if (summary.successfulSideEffects.length > 0) {
+        lines.push('Completed side effects:');
+        for (const call of summary.successfulSideEffects.slice(0, 80))
+            lines.push(formatDetailedCall(call));
+        if (summary.successfulSideEffects.length > 80)
+            lines.push(`- ...and ${summary.successfulSideEffects.length - 80} more completed side effects in the event log.`);
+        lines.push('');
+    }
+    if (summary.failedSideEffects.length > 0) {
+        lines.push('Failed side effects that may need retry or reconciliation:');
+        for (const call of summary.failedSideEffects.slice(0, 30))
+            lines.push(formatDetailedCall(call));
+        lines.push('');
+    }
+    if (summary.pendingSideEffects.length > 0) {
+        lines.push('Side-effect calls that started but had no confirmation. Check before retrying:');
+        for (const call of summary.pendingSideEffects.slice(0, 30))
+            lines.push(formatDetailedCall(call));
+        lines.push('');
+    }
+    if (summary.unknownEffectCalls.length > 0) {
+        lines.push(`Unknown-effect tool calls: ${summary.unknownEffectCalls.length}. Treat these cautiously and inspect if relevant.`);
+        lines.push('');
+    }
+    lines.push('Original owner request:');
+    lines.push(originalRequest);
+    lines.push('');
+    lines.push('Continue from where the previous run stopped. Focus on remaining follow-up, cleanup, reconciliation, or status reporting. DO NOT re-find inputs or re-execute completed sends/updates/deletes.');
+    lines.push('[/Resume context]');
+    return lines.join('\n');
+}
+//# sourceMappingURL=run-summary.js.map

package/dist/agent/side-effect-classifier.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Provider-neutral side-effect classification for SDK tool calls.
+ *
+ * This module answers two intentionally small questions:
+ * - Did this tool likely mutate external or durable state?
+ * - Did the matching tool_result represent a successful execution?
+ *
+ * Provider-specific details belong in extractors/summaries. The classifier
+ * keeps the global npm behavior conservative: confident read-only calls stay
+ * read-only, confident mutating calls are side effects, and unclear calls are
+ * surfaced as unknown rather than blocked or retried automatically.
+ */
+export type SideEffectVerdict = {
+    kind: 'side_effect';
+    reason: string;
+} | {
+    kind: 'read_only';
+    reason: string;
+} | {
+    kind: 'unknown';
+    reason: string;
+};
+export declare function classifyToolCall(toolName: string, input?: Record<string, unknown>): SideEffectVerdict;
+export interface ToolResultSuccess {
+    successful: boolean;
+    reason: string;
+    statusCode?: number;
+    error?: string;
+}
+export declare function isToolResultSuccessful(rawResult: unknown, sdkIsError?: boolean): ToolResultSuccess;
+export declare function normalizedToolResultPayload(value: unknown): unknown;
+//# sourceMappingURL=side-effect-classifier.d.ts.map

package/dist/agent/side-effect-classifier.js

@@ -0,0 +1,232 @@
+/**
+ * Provider-neutral side-effect classification for SDK tool calls.
+ *
+ * This module answers two intentionally small questions:
+ * - Did this tool likely mutate external or durable state?
+ * - Did the matching tool_result represent a successful execution?
+ *
+ * Provider-specific details belong in extractors/summaries. The classifier
+ * keeps the global npm behavior conservative: confident read-only calls stay
+ * read-only, confident mutating calls are side effects, and unclear calls are
+ * surfaced as unknown rather than blocked or retried automatically.
+ */
+const READ_ONLY_BUILTINS = new Set([
+    'Agent',
+    'Glob',
+    'Grep',
+    'LS',
+    'Read',
+    'Task',
+    'TodoRead',
+    'TodoWrite',
+    'WebFetch',
+    'WebSearch',
+]);
+const MUTATING_BUILTINS = new Set([
+    'Edit',
+    'MultiEdit',
+    'NotebookEdit',
+    'Write',
+]);
+const READ_ONLY_TOOL_VERBS = new Set([
+    'describe',
+    'fetch',
+    'find',
+    'get',
+    'inbox',
+    'list',
+    'lookup',
+    'query',
+    'read',
+    'retrieve',
+    'search',
+    'select',
+]);
+const SIDE_EFFECT_TOOL_VERBS = new Set([
+    'add',
+    'apply',
+    'approve',
+    'archive',
+    'assign',
+    'cancel',
+    'compose',
+    'create',
+    'delete',
+    'deploy',
+    'disable',
+    'enable',
+    'forward',
+    'insert',
+    'merge',
+    'move',
+    'post',
+    'publish',
+    'push',
+    'remove',
+    'rename',
+    'reply',
+    'send',
+    'set',
+    'subscribe',
+    'unsubscribe',
+    'update',
+    'upload',
+    'upsert',
+]);
+const READ_ONLY_MCP_PATTERNS = [
+    /^mcp__dataforseo__/i,
+    /^mcp__bright[_-]?data__/i,
+    /^mcp__.*__(?:get|list|search|find|fetch|read|query|describe|retrieve|lookup|inbox|select)(?:_|$)/i,
+    /^mcp__.*__(?:.*_)?(?:get|list|search|find|fetch|read|query|describe|retrieve|lookup|inbox|select)$/i,
+];
+const BASH_SIDE_EFFECT_PATTERNS = [
+    /\b(rm|mv|cp|mkdir|touch|chmod|chown)\b/i,
+    /(^|[^>])>{1,2}[^>]/,
+    /\btee\b/i,
+    /\bgit\s+(commit|push|merge|rebase|tag)\b/i,
+    /\bnpm\s+(install|publish|update)\b/i,
+    /\b(?:sf|sfdx)\s+data\s+(update|delete|create|upsert)\b/i,
+    /\b(?:sf|sfdx)\s+org\s+(create|delete)\b/i,
+    /\bcurl\b.*(?:-X|--request)\s*(POST|PUT|DELETE|PATCH)\b/i,
+    /\bpython3?\s+\S*(send|sender|publish|deploy|migrate|push|upload)/i,
+];
+const BASH_READ_ONLY_PATTERNS = [
+    /^\s*(?:pwd|ls|find|rg|grep|sed|awk|cat|head|tail|wc|jq|git\s+(?:status|diff|show|log|branch|rev-parse)|npm\s+(?:view|ls|outdated))\b/i,
+];
+function tokensForToolName(toolName) {
+    const withCamelBreaks = toolName.replace(/([a-z0-9])([A-Z])/g, '$1_$2');
+    return withCamelBreaks
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
+function extractBashCommand(input) {
+    return typeof input?.command === 'string' ? input.command : '';
+}
+export function classifyToolCall(toolName, input) {
+    if (!toolName)
+        return { kind: 'unknown', reason: 'missing-tool-name' };
+    if (READ_ONLY_BUILTINS.has(toolName)) {
+        return { kind: 'read_only', reason: 'known-readonly-builtin' };
+    }
+    if (MUTATING_BUILTINS.has(toolName)) {
+        return { kind: 'side_effect', reason: 'known-mutating-builtin' };
+    }
+    if (toolName === 'Bash') {
+        const command = extractBashCommand(input);
+        for (const re of BASH_SIDE_EFFECT_PATTERNS) {
+            if (re.test(command))
+                return { kind: 'side_effect', reason: 'bash-mutation-pattern' };
+        }
+        for (const re of BASH_READ_ONLY_PATTERNS) {
+            if (re.test(command))
+                return { kind: 'read_only', reason: 'bash-readonly-pattern' };
+        }
+        return { kind: 'unknown', reason: 'bash-uncategorized' };
+    }
+    for (const re of READ_ONLY_MCP_PATTERNS) {
+        if (re.test(toolName))
+            return { kind: 'read_only', reason: 'known-readonly-tool-pattern' };
+    }
+    const tokens = tokensForToolName(toolName);
+    if (tokens.some((token) => SIDE_EFFECT_TOOL_VERBS.has(token))) {
+        return { kind: 'side_effect', reason: 'side-effect-verb-match' };
+    }
+    if (tokens.some((token) => READ_ONLY_TOOL_VERBS.has(token))) {
+        return { kind: 'read_only', reason: 'read-only-verb-match' };
+    }
+    return { kind: 'unknown', reason: 'unclassified-tool-name' };
+}
+function parseMaybeJsonString(value) {
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed || !/^[\[{"]/.test(trimmed))
+        return value;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function normalizeResultPayload(value) {
+    const parsed = parseMaybeJsonString(value);
+    if (Array.isArray(parsed) && parsed.length === 1) {
+        const first = parsed[0];
+        if (first && typeof first === 'object') {
+            const obj = first;
+            if (typeof obj.text === 'string')
+                return normalizeResultPayload(obj.text);
+            if ('content' in obj)
+                return normalizeResultPayload(obj.content);
+        }
+    }
+    return parsed;
+}
+function findStatusCode(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const obj = value;
+    for (const key of ['status_code', 'statusCode', 'status', 'httpStatus', 'code']) {
+        const raw = obj[key];
+        const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : NaN;
+        if (Number.isFinite(n) && n >= 100 && n <= 599)
+            return n;
+    }
+    for (const key of ['data', 'response', 'result']) {
+        const nested = findStatusCode(obj[key]);
+        if (nested !== undefined)
+            return nested;
+    }
+    return undefined;
+}
+function findError(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const obj = value;
+    for (const key of ['error', 'errors', 'message']) {
+        const raw = obj[key];
+        if (raw == null || raw === false || raw === '')
+            continue;
+        if (typeof raw === 'string')
+            return raw;
+        try {
+            return JSON.stringify(raw).slice(0, 500);
+        }
+        catch {
+            return String(raw);
+        }
+    }
+    return undefined;
+}
+export function isToolResultSuccessful(rawResult, sdkIsError = false) {
+    if (sdkIsError)
+        return { successful: false, reason: 'sdk-is-error' };
+    const result = normalizeResultPayload(rawResult);
+    if (result && typeof result === 'object') {
+        const obj = result;
+        if (obj.is_error === true || obj.isError === true) {
+            return { successful: false, reason: 'tool-result-is-error' };
+        }
+        if (obj.successful === false || obj.success === false || obj.ok === false) {
+            return { successful: false, reason: 'tool-result-success-false', error: findError(obj) };
+        }
+        const error = findError(obj);
+        if (error)
+            return { successful: false, reason: 'tool-result-error-field', error };
+        const statusCode = findStatusCode(obj);
+        if (statusCode !== undefined) {
+            return {
+                successful: statusCode >= 200 && statusCode < 300,
+                reason: statusCode >= 200 && statusCode < 300 ? 'status-2xx' : 'status-non-2xx',
+                statusCode,
+            };
+        }
+    }
+    return { successful: true, reason: 'no-error-signal' };
+}
+export function normalizedToolResultPayload(value) {
+    return normalizeResultPayload(value);
+}
+//# sourceMappingURL=side-effect-classifier.js.map