@amplitude/wizard 1.0.0-beta.0

package/dist/src/lib/middleware/benchmarks/token-tracker.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Token tracking plugin for input/output tokens.
+ *
+ * Accumulates per-turn token usage (input_tokens + cache_read_input_tokens
+ * + cache_creation_input_tokens = total input; output_tokens = output).
+ * Respects the dedup flag from TurnCounterPlugin. Cache breakdown (r/5m/1h)
+ * is tracked by CacheTrackerPlugin for reporting and pricing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTrackerPlugin = void 0;
+class TokenTrackerPlugin {
+    name = 'tokens';
+    phaseInput = 0;
+    phaseOutput = 0;
+    totalInput = 0;
+    totalOutput = 0;
+    lastUsage = null;
+    phaseSnapshots = [];
+    currentPhase = 'setup';
+    phaseMessagesWithUsage = 0;
+    onMessage(message, ctx, store) {
+        if (message.type !== 'assistant')
+            return;
+        const turns = ctx.get('turns');
+        if (turns?.isDuplicate)
+            return;
+        const usage = message.message?.usage;
+        if (usage) {
+            const input = Number(usage.input_tokens ?? 0) +
+                Number(usage.cache_read_input_tokens ?? 0) +
+                Number(usage.cache_creation_input_tokens ?? 0);
+            const output = Number(usage.output_tokens ?? 0);
+            this.phaseInput += input;
+            this.phaseOutput += output;
+            this.totalInput += input;
+            this.totalOutput += output;
+            this.lastUsage = usage;
+            this.phaseMessagesWithUsage += 1;
+        }
+        store.set('tokens', this.getData());
+    }
+    onPhaseTransition(fromPhase, toPhase, _ctx, store) {
+        this.phaseSnapshots.push({
+            phase: fromPhase,
+            inputTokens: this.phaseInput,
+            outputTokens: this.phaseOutput,
+            messagesWithUsage: this.phaseMessagesWithUsage,
+        });
+        this.currentPhase = toPhase;
+        this.phaseInput = 0;
+        this.phaseOutput = 0;
+        this.phaseMessagesWithUsage = 0;
+        store.set('tokens', this.getData());
+    }
+    onFinalize(_resultMessage, _totalDurationMs, _ctx, store) {
+        this.phaseSnapshots.push({
+            phase: this.currentPhase,
+            inputTokens: this.phaseInput,
+            outputTokens: this.phaseOutput,
+            messagesWithUsage: this.phaseMessagesWithUsage,
+        });
+        store.set('tokens', this.getData());
+    }
+    getData() {
+        return {
+            phaseInput: this.phaseInput,
+            phaseOutput: this.phaseOutput,
+            totalInput: this.totalInput,
+            totalOutput: this.totalOutput,
+            lastUsage: this.lastUsage,
+            phaseSnapshots: [...this.phaseSnapshots],
+        };
+    }
+}
+exports.TokenTrackerPlugin = TokenTrackerPlugin;

package/dist/src/lib/middleware/benchmarks/turn-counter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Turn counting plugin with message deduplication.
+ *
+ * The SDK emits multiple assistant events per turn (one per content block)
+ * with the same message ID. This plugin deduplicates and publishes turn
+ * counts + a duplicate flag for downstream plugins.
+ */
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage } from '../types';
+export interface TurnData {
+    /** Whether the current message is a duplicate of the last processed turn */
+    isDuplicate: boolean;
+    /** Turns in the current phase */
+    phaseTurns: number;
+    /** Total turns across all phases */
+    totalTurns: number;
+    /** Per-phase turn snapshots: [{ phase, turns }] */
+    phaseSnapshots: Array<{
+        phase: string;
+        turns: number;
+    }>;
+}
+export declare class TurnCounterPlugin implements Middleware {
+    readonly name = "turns";
+    private lastMessageId;
+    private phaseTurns;
+    private totalTurns;
+    private isDuplicate;
+    private phaseSnapshots;
+    private currentPhase;
+    onMessage(message: SDKMessage, _ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onPhaseTransition(fromPhase: string, _toPhase: string, _ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onFinalize(_resultMessage: SDKMessage, _totalDurationMs: number, _ctx: MiddlewareContext, store: MiddlewareStore): void;
+    private getData;
+}

package/dist/src/lib/middleware/benchmarks/turn-counter.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Turn counting plugin with message deduplication.
+ *
+ * The SDK emits multiple assistant events per turn (one per content block)
+ * with the same message ID. This plugin deduplicates and publishes turn
+ * counts + a duplicate flag for downstream plugins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnCounterPlugin = void 0;
+class TurnCounterPlugin {
+    name = 'turns';
+    lastMessageId = null;
+    phaseTurns = 0;
+    totalTurns = 0;
+    isDuplicate = false;
+    phaseSnapshots = [];
+    currentPhase = 'setup';
+    onMessage(message, _ctx, store) {
+        if (message.type !== 'assistant') {
+            this.isDuplicate = false;
+            store.set('turns', this.getData());
+            return;
+        }
+        const msgId = message.message?.id;
+        this.isDuplicate = msgId != null && msgId === this.lastMessageId;
+        if (msgId)
+            this.lastMessageId = msgId;
+        if (!this.isDuplicate) {
+            this.phaseTurns++;
+            this.totalTurns++;
+        }
+        store.set('turns', this.getData());
+    }
+    onPhaseTransition(fromPhase, _toPhase, _ctx, store) {
+        this.phaseSnapshots.push({ phase: fromPhase, turns: this.phaseTurns });
+        this.currentPhase = _toPhase;
+        this.phaseTurns = 0;
+        this.lastMessageId = null;
+        store.set('turns', this.getData());
+    }
+    onFinalize(_resultMessage, _totalDurationMs, _ctx, store) {
+        this.phaseSnapshots.push({
+            phase: this.currentPhase,
+            turns: this.phaseTurns,
+        });
+        store.set('turns', this.getData());
+    }
+    getData() {
+        return {
+            isDuplicate: this.isDuplicate,
+            phaseTurns: this.phaseTurns,
+            totalTurns: this.totalTurns,
+            phaseSnapshots: [...this.phaseSnapshots],
+        };
+    }
+}
+exports.TurnCounterPlugin = TurnCounterPlugin;

package/dist/src/lib/middleware/config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Benchmark configuration loader.
+ *
+ * Loads .benchmark-config.json from the working directory with sensible defaults.
+ * All fields are optional — missing fields fall back to defaults.
+ */
+export interface BenchmarkConfig {
+    /** Enable/disable individual metric plugins */
+    plugins: Record<string, boolean>;
+    output: {
+        /** Path for the benchmark JSON output file */
+        benchmarkPath: string;
+        /** Whether to write the benchmark JSON file */
+        benchmarkEnabled: boolean;
+        /** Path for the main wizard debug log file */
+        logPath: string;
+        /** Whether to write the main wizard debug log */
+        logEnabled: boolean;
+        /** Suppress benchmark console output (disables the summary plugin) */
+        suppressWizardLogs: boolean;
+    };
+}
+export declare function loadBenchmarkConfig(installDir: string): BenchmarkConfig;
+export declare function getDefaultConfig(): BenchmarkConfig;

package/dist/src/lib/middleware/config.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Benchmark configuration loader.
+ *
+ * Loads .benchmark-config.json from the working directory with sensible defaults.
+ * All fields are optional — missing fields fall back to defaults.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBenchmarkConfig = loadBenchmarkConfig;
+exports.getDefaultConfig = getDefaultConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const debug_1 = require("../../utils/debug");
+const agent_interface_1 = require("../agent-interface");
+const DEFAULT_CONFIG = {
+    plugins: {
+        tokens: true,
+        cache: true,
+        turns: true,
+        compactions: true,
+        contextSize: true,
+        cost: true,
+        duration: true,
+        summary: true,
+        jsonWriter: true,
+    },
+    output: {
+        benchmarkPath: '/tmp/amplitude-wizard-benchmark.json',
+        benchmarkEnabled: true,
+        logPath: '/tmp/amplitude-wizard.log',
+        logEnabled: true,
+        suppressWizardLogs: false,
+    },
+};
+const BenchmarkConfigFileSchema = zod_1.z
+    .object({
+    plugins: zod_1.z.record(zod_1.z.string(), zod_1.z.boolean()).optional(),
+    output: zod_1.z
+        .object({
+        benchmarkPath: zod_1.z.string(),
+        benchmarkEnabled: zod_1.z.boolean(),
+        logPath: zod_1.z.string(),
+        logEnabled: zod_1.z.boolean(),
+        suppressWizardLogs: zod_1.z.boolean(),
+    })
+        .partial()
+        .optional(),
+})
+    .passthrough();
+function loadBenchmarkConfig(installDir) {
+    const configPath = process.env.AMPLITUDE_WIZARD_BENCHMARK_CONFIG ??
+        path_1.default.join(installDir, '.benchmark-config.json');
+    try {
+        const raw = fs_1.default.readFileSync(configPath, 'utf-8');
+        const result = BenchmarkConfigFileSchema.safeParse(JSON.parse(raw));
+        if (!result.success)
+            throw result.error;
+        const parsed = result.data;
+        const config = {
+            plugins: { ...DEFAULT_CONFIG.plugins, ...parsed.plugins },
+            output: { ...DEFAULT_CONFIG.output, ...parsed.output },
+        };
+        // Env var overrides for parallel runs
+        if (process.env.AMPLITUDE_WIZARD_BENCHMARK_FILE) {
+            config.output.benchmarkPath = process.env.AMPLITUDE_WIZARD_BENCHMARK_FILE;
+        }
+        if (process.env.AMPLITUDE_WIZARD_LOG_FILE) {
+            config.output.logPath = process.env.AMPLITUDE_WIZARD_LOG_FILE;
+        }
+        // If benchmark output is disabled, disable the jsonWriter plugin
+        if (!config.output.benchmarkEnabled) {
+            config.plugins.jsonWriter = false;
+        }
+        (0, debug_1.logToFile)(`${agent_interface_1.AgentSignals.BENCHMARK} Loaded config from ${configPath}`);
+        return config;
+    }
+    catch {
+        // No config file or invalid JSON — use defaults
+        const config = structuredClone(DEFAULT_CONFIG);
+        // Env var overrides
+        if (process.env.AMPLITUDE_WIZARD_BENCHMARK_FILE) {
+            config.output.benchmarkPath = process.env.AMPLITUDE_WIZARD_BENCHMARK_FILE;
+        }
+        if (process.env.AMPLITUDE_WIZARD_LOG_FILE) {
+            config.output.logPath = process.env.AMPLITUDE_WIZARD_LOG_FILE;
+        }
+        return config;
+    }
+}
+function getDefaultConfig() {
+    return structuredClone(DEFAULT_CONFIG);
+}

package/dist/src/lib/middleware/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Middleware system for wizard agent runs.
+ */
+export { MiddlewarePipeline } from './pipeline';
+export { PhaseDetector } from './phase-detector';
+export type { Middleware, MiddlewareContext, MiddlewareStore } from './types';
+export { loadBenchmarkConfig, getDefaultConfig } from './config';
+export type { BenchmarkConfig } from './config';
+export { createBenchmarkPipeline } from './benchmark';
+export type { BenchmarkData, StepUsage } from './benchmark';
+export { createPluginsFromConfig } from './benchmarks';

package/dist/src/lib/middleware/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Middleware system for wizard agent runs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginsFromConfig = exports.createBenchmarkPipeline = exports.getDefaultConfig = exports.loadBenchmarkConfig = exports.PhaseDetector = exports.MiddlewarePipeline = void 0;
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "MiddlewarePipeline", { enumerable: true, get: function () { return pipeline_1.MiddlewarePipeline; } });
+var phase_detector_1 = require("./phase-detector");
+Object.defineProperty(exports, "PhaseDetector", { enumerable: true, get: function () { return phase_detector_1.PhaseDetector; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadBenchmarkConfig", { enumerable: true, get: function () { return config_1.loadBenchmarkConfig; } });
+Object.defineProperty(exports, "getDefaultConfig", { enumerable: true, get: function () { return config_1.getDefaultConfig; } });
+var benchmark_1 = require("./benchmark");
+Object.defineProperty(exports, "createBenchmarkPipeline", { enumerable: true, get: function () { return benchmark_1.createBenchmarkPipeline; } });
+var benchmarks_1 = require("./benchmarks");
+Object.defineProperty(exports, "createPluginsFromConfig", { enumerable: true, get: function () { return benchmarks_1.createPluginsFromConfig; } });

package/dist/src/lib/middleware/phase-detector.d.ts

@@ -0,0 +1,8 @@
+/** Phase transitions from [STATUS] in assistant text. Keep in sync with workflow "Status to report" bullets. */
+import type { SDKMessage } from './types';
+export declare class PhaseDetector {
+    private currentPhase;
+    detect(message: SDKMessage): string | null;
+    private getNextPhase;
+    reset(): void;
+}

package/dist/src/lib/middleware/phase-detector.js

@@ -0,0 +1,63 @@
+"use strict";
+/** Phase transitions from [STATUS] in assistant text. Keep in sync with workflow "Status to report" bullets. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhaseDetector = void 0;
+const PHASES_ORDER = [
+    '1.0-begin',
+    '1.1-edit',
+    '1.2-revise',
+    '1.3-conclude',
+];
+const STATUS_PHRASES_BY_PHASE = {
+    '1.0-begin': [
+        'Checking project structure',
+        'Verifying Amplitude dependencies',
+        'Generating events based on project',
+    ],
+    '1.1-edit': ['Inserting Amplitude capture code'],
+    '1.2-revise': [
+        'Finding and correcting errors',
+        'Report details of any errors you fix',
+        'Linting, building and prettying',
+    ],
+    '1.3-conclude': ['Configured dashboard', 'Created setup report'],
+};
+class PhaseDetector {
+    currentPhase = 'setup';
+    detect(message) {
+        if (message.type !== 'assistant')
+            return null;
+        const nextPhase = this.getNextPhase();
+        if (nextPhase === null)
+            return null;
+        const content = message.message?.content;
+        if (!Array.isArray(content))
+            return null;
+        for (const block of content) {
+            if (block.type !== 'text' || typeof block.text !== 'string')
+                continue;
+            if (!block.text.includes('[STATUS]'))
+                continue;
+            const phrases = STATUS_PHRASES_BY_PHASE[nextPhase];
+            for (const phrase of phrases) {
+                if (block.text.includes(phrase)) {
+                    this.currentPhase = nextPhase;
+                    return nextPhase;
+                }
+            }
+        }
+        return null;
+    }
+    getNextPhase() {
+        if (this.currentPhase === 'setup')
+            return '1.0-begin';
+        const i = PHASES_ORDER.indexOf(this.currentPhase);
+        if (i < 0 || i >= PHASES_ORDER.length - 1)
+            return null;
+        return PHASES_ORDER[i + 1];
+    }
+    reset() {
+        this.currentPhase = 'setup';
+    }
+}
+exports.PhaseDetector = PhaseDetector;

package/dist/src/lib/middleware/pipeline.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Middleware pipeline orchestrator.
+ *
+ * Implements the same { onMessage, finalize } interface that runAgent() expects,
+ * while internally dispatching to an ordered list of middleware plugins.
+ */
+import { PhaseDetector } from './phase-detector';
+import type { Middleware, SDKMessage } from './types';
+export declare class MiddlewarePipeline {
+    private middlewares;
+    private store;
+    private phaseDetector;
+    private autoDetectPhases;
+    private _currentPhase;
+    private _currentPhaseFreshContext;
+    constructor(middlewares: Middleware[], opts?: {
+        phaseDetector?: PhaseDetector;
+        autoDetectPhases?: boolean;
+    });
+    /** Feed an SDK message through all middleware (satisfies tracker.onMessage) */
+    onMessage(message: SDKMessage): void;
+    /** Finalize the run (satisfies tracker.finalize) */
+    finalize(resultMessage: SDKMessage, totalDurationMs: number): unknown;
+    /** Explicit phase start (for phased runner support) */
+    startPhase(name: string, freshContext: boolean): void;
+    private transitionPhase;
+    private createContext;
+    private createStore;
+}

package/dist/src/lib/middleware/pipeline.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Middleware pipeline orchestrator.
+ *
+ * Implements the same { onMessage, finalize } interface that runAgent() expects,
+ * while internally dispatching to an ordered list of middleware plugins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewarePipeline = void 0;
+const phase_detector_1 = require("./phase-detector");
+class MiddlewarePipeline {
+    middlewares;
+    store = new Map();
+    phaseDetector;
+    autoDetectPhases;
+    _currentPhase = 'setup';
+    _currentPhaseFreshContext = true;
+    constructor(middlewares, opts) {
+        this.middlewares = middlewares;
+        this.phaseDetector = opts?.phaseDetector ?? new phase_detector_1.PhaseDetector();
+        this.autoDetectPhases = opts?.autoDetectPhases ?? true;
+        const ctx = this.createContext();
+        for (const mw of this.middlewares) {
+            mw.onInit?.(ctx);
+        }
+    }
+    /** Feed an SDK message through all middleware (satisfies tracker.onMessage) */
+    onMessage(message) {
+        // Phase detection first — updates context before middleware sees it
+        if (this.autoDetectPhases) {
+            const newPhase = this.phaseDetector.detect(message);
+            if (newPhase && newPhase !== this._currentPhase) {
+                this.transitionPhase(newPhase, false);
+            }
+        }
+        const ctx = this.createContext();
+        const storeHandle = this.createStore();
+        for (const mw of this.middlewares) {
+            mw.onMessage?.(message, ctx, storeHandle);
+        }
+    }
+    /** Finalize the run (satisfies tracker.finalize) */
+    finalize(resultMessage, totalDurationMs) {
+        const ctx = this.createContext();
+        const storeHandle = this.createStore();
+        let result;
+        for (const mw of this.middlewares) {
+            const r = mw.onFinalize?.(resultMessage, totalDurationMs, ctx, storeHandle);
+            if (r !== undefined)
+                result = r;
+        }
+        return result;
+    }
+    /** Explicit phase start (for phased runner support) */
+    startPhase(name, freshContext) {
+        this.transitionPhase(name, freshContext);
+    }
+    transitionPhase(newPhase, freshContext) {
+        const oldPhase = this._currentPhase;
+        this._currentPhase = newPhase;
+        this._currentPhaseFreshContext = freshContext;
+        const ctx = this.createContext();
+        const storeHandle = this.createStore();
+        for (const mw of this.middlewares) {
+            mw.onPhaseTransition?.(oldPhase, newPhase, ctx, storeHandle);
+        }
+    }
+    createContext() {
+        return {
+            currentPhase: this._currentPhase,
+            currentPhaseFreshContext: this._currentPhaseFreshContext,
+            get: (key) => this.store.get(key),
+        };
+    }
+    createStore() {
+        return {
+            set: (key, value) => this.store.set(key, value),
+        };
+    }
+}
+exports.MiddlewarePipeline = MiddlewarePipeline;

package/dist/src/lib/middleware/schemas.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Zod schemas for SDK message validation.
+ *
+ * These schemas enforce the structural types defined in types.ts at runtime.
+ * Use `safeParseSDKMessage` at ingestion boundaries (the for-await loop in
+ * agent-interface.ts and the middleware pipeline) so malformed messages are
+ * logged and skipped rather than causing uncaught property-access errors.
+ */
+import { z } from 'zod';
+import type { SDKMessage, SDKUsage, SDKContentBlock, SDKCompactMetadata, SDKModelUsageEntry } from './types';
+export declare const sdkUsageSchema: z.ZodType<SDKUsage>;
+export declare const sdkContentBlockSchema: z.ZodType<SDKContentBlock>;
+export declare const sdkCompactMetadataSchema: z.ZodType<SDKCompactMetadata>;
+export declare const sdkModelUsageEntrySchema: z.ZodType<SDKModelUsageEntry>;
+export declare const sdkMessageSchema: z.ZodType<SDKMessage>;
+export type SDKMessageParseResult = {
+    ok: true;
+    message: SDKMessage;
+} | {
+    ok: false;
+    error: z.ZodError;
+};
+/**
+ * Validate an unknown value as an SDKMessage.
+ * Returns a discriminated result so callers can log and skip bad messages.
+ */
+export declare function safeParseSDKMessage(value: unknown): SDKMessageParseResult;

package/dist/src/lib/middleware/schemas.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Zod schemas for SDK message validation.
+ *
+ * These schemas enforce the structural types defined in types.ts at runtime.
+ * Use `safeParseSDKMessage` at ingestion boundaries (the for-await loop in
+ * agent-interface.ts and the middleware pipeline) so malformed messages are
+ * logged and skipped rather than causing uncaught property-access errors.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkMessageSchema = exports.sdkModelUsageEntrySchema = exports.sdkCompactMetadataSchema = exports.sdkContentBlockSchema = exports.sdkUsageSchema = void 0;
+exports.safeParseSDKMessage = safeParseSDKMessage;
+const zod_1 = require("zod");
+// ── Leaf schemas ────────────────────────────────────────────────────────────
+exports.sdkUsageSchema = zod_1.z.object({
+    input_tokens: zod_1.z.number().optional(),
+    output_tokens: zod_1.z.number().optional(),
+    cache_read_input_tokens: zod_1.z.number().optional(),
+    cache_creation_input_tokens: zod_1.z.number().optional(),
+    cache_creation: zod_1.z
+        .object({
+        ephemeral_5m_input_tokens: zod_1.z.number().optional(),
+        ephemeral_1h_input_tokens: zod_1.z.number().optional(),
+    })
+        .optional(),
+    total_cost_usd: zod_1.z.number().optional(),
+});
+exports.sdkContentBlockSchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+    text: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+    input: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+})
+    .passthrough();
+exports.sdkCompactMetadataSchema = zod_1.z.object({
+    pre_tokens: zod_1.z.number().optional(),
+    trigger: zod_1.z.string().optional(),
+});
+exports.sdkModelUsageEntrySchema = zod_1.z.object({
+    inputTokens: zod_1.z.number().optional(),
+    outputTokens: zod_1.z.number().optional(),
+    cacheCreationInputTokens: zod_1.z.number().optional(),
+    cacheReadInputTokens: zod_1.z.number().optional(),
+});
+// ── SDKMessage ──────────────────────────────────────────────────────────────
+exports.sdkMessageSchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+    subtype: zod_1.z.string().optional(),
+    message: zod_1.z
+        .object({
+        id: zod_1.z.string().optional(),
+        usage: exports.sdkUsageSchema.optional(),
+        content: zod_1.z.array(exports.sdkContentBlockSchema).optional(),
+    })
+        .passthrough()
+        .optional(),
+    compact_metadata: exports.sdkCompactMetadataSchema.optional(),
+    is_error: zod_1.z.boolean().optional(),
+    result: zod_1.z.string().optional(),
+    errors: zod_1.z.array(zod_1.z.string()).optional(),
+    model: zod_1.z.string().optional(),
+    tools: zod_1.z.array(zod_1.z.unknown()).optional(),
+    mcp_servers: zod_1.z
+        .array(zod_1.z.object({ name: zod_1.z.string(), status: zod_1.z.string() }))
+        .optional(),
+    usage: exports.sdkUsageSchema.optional(),
+    total_cost_usd: zod_1.z.number().optional(),
+    num_turns: zod_1.z.number().optional(),
+    modelUsage: zod_1.z.record(zod_1.z.string(), exports.sdkModelUsageEntrySchema).optional(),
+})
+    .passthrough();
+/**
+ * Validate an unknown value as an SDKMessage.
+ * Returns a discriminated result so callers can log and skip bad messages.
+ */
+function safeParseSDKMessage(value) {
+    const result = exports.sdkMessageSchema.safeParse(value);
+    if (result.success) {
+        return { ok: true, message: result.data };
+    }
+    return { ok: false, error: result.error };
+}