@rkat/sdk 0.5.2 → 0.6.1

package/dist/events.js

@@ -3,8 +3,10 @@
  *
  * Events form a discriminated union on the `type` field (snake_case to match
  * the wire protocol).  All other fields use idiomatic camelCase.
- * Missing fields are defaulted during parsing so partial streaming payloads
- * can still be represented as typed events.
+ * Missing semantic fields remain absent during parsing so partial streaming
+ * payloads do not become authoritative SDK state.
+ * Malformed known event payloads are preserved as `malformed_event` frames
+ * instead of being coerced into typed semantic events with fabricated defaults.
  *
  * @example
  * ```ts
@@ -41,26 +43,377 @@ export function isToolCallRequested(event) {
 export function isRunCompleted(event) {
     return event.type === "run_completed";
 }
+export function isExtractionSucceeded(event) {
+    return event.type === "extraction_succeeded";
+}
+export function isExtractionFailed(event) {
+    return event.type === "extraction_failed";
+}
 export function isRunFailed(event) {
     return event.type === "run_failed";
 }
 // ---------------------------------------------------------------------------
 // Wire → typed parser
 // ---------------------------------------------------------------------------
+function isPlainRecord(raw) {
+    return typeof raw === "object" && raw !== null && !Array.isArray(raw);
+}
+function malformedEvent(raw, rawType, error) {
+    return { type: "malformed_event", rawType, raw, error };
+}
+function requireStringField(raw, field) {
+    const value = raw[field];
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be string`);
+    }
+    return value;
+}
+function requireNumberField(raw, field) {
+    const value = raw[field];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${field} must be number`);
+    }
+    return value;
+}
+function requireBooleanField(raw, field) {
+    const value = raw[field];
+    if (typeof value !== "boolean") {
+        throw new Error(`${field} must be boolean`);
+    }
+    return value;
+}
+function requireRecordField(raw, field) {
+    const value = raw[field];
+    if (!isPlainRecord(value)) {
+        throw new Error(`${field} must be object`);
+    }
+    return value;
+}
+function requireOneOf(value, field, allowed) {
+    if (!allowed.includes(value)) {
+        throw new Error(`${field} must be one of ${allowed.join(", ")}`);
+    }
+    return value;
+}
 function parseUsage(raw) {
-    if (!raw)
-        return { inputTokens: 0, outputTokens: 0 };
+    if (!isPlainRecord(raw)) {
+        throw new Error("missing usage");
+    }
     return {
-        inputTokens: Number(raw.input_tokens ?? 0),
-        outputTokens: Number(raw.output_tokens ?? 0),
+        inputTokens: requireNumberField(raw, "input_tokens"),
+        outputTokens: requireNumberField(raw, "output_tokens"),
         cacheCreationTokens: raw.cache_creation_tokens != null
-            ? Number(raw.cache_creation_tokens)
+            ? requireNumberField(raw, "cache_creation_tokens")
             : undefined,
         cacheReadTokens: raw.cache_read_tokens != null
-            ? Number(raw.cache_read_tokens)
+            ? requireNumberField(raw, "cache_read_tokens")
             : undefined,
     };
 }
+function hasOwn(raw, field) {
+    return Object.prototype.hasOwnProperty.call(raw, field);
+}
+function parseTerminalCauseKind(raw) {
+    const causeKind = parseWireString(raw.terminal_cause_kind ?? raw.terminalCauseKind);
+    if (causeKind !== undefined &&
+        TURN_TERMINAL_CAUSE_KINDS.has(causeKind)) {
+        return causeKind;
+    }
+    return undefined;
+}
+function terminalCauseKindField(raw) {
+    const terminalCauseKind = parseTerminalCauseKind(raw);
+    return terminalCauseKind === undefined ? {} : { terminalCauseKind };
+}
+function parseAgentErrorReason(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (raw === null) {
+        return null;
+    }
+    if (!isPlainRecord(raw)) {
+        throw new Error("error_report.reason must be object");
+    }
+    const reasonType = parseWireString(raw.reason_type ?? raw.reasonType);
+    if (reasonType === undefined) {
+        throw new Error("error_report.reason.reason_type must be string");
+    }
+    if (reasonType === "turn_terminal_cause") {
+        const outcome = parseWireString(raw.outcome);
+        const causeKind = parseWireString(raw.cause_kind ?? raw.causeKind);
+        if (outcome !== undefined &&
+            causeKind !== undefined &&
+            TURN_TERMINAL_OUTCOMES.has(outcome) &&
+            TURN_TERMINAL_CAUSE_KINDS.has(causeKind)) {
+            return {
+                reasonType,
+                outcome: outcome,
+                causeKind: causeKind,
+            };
+        }
+        return undefined;
+    }
+    if (!["hook_denied", "hook_timeout", "hook_execution_failed"].includes(reasonType)) {
+        return { reasonType: "unknown", rawReasonType: reasonType, raw };
+    }
+    const reason = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (key !== "hook_id" && key !== "hook_id_string") {
+            reason[key] = value;
+        }
+    }
+    reason.reason_type = reasonType;
+    if (reasonType === "hook_denied") {
+        reason.point = requireStringField(raw, "point");
+        reason.reason_code = requireStringField(raw, "reason_code");
+    }
+    else {
+        reason.hook_id = requireStringField(raw, "hook_id");
+    }
+    if (reasonType === "hook_timeout") {
+        reason.timeout_ms = requireNumberField(raw, "timeout_ms");
+    }
+    if (reasonType === "hook_execution_failed") {
+        reason.reason = requireStringField(raw, "reason");
+    }
+    if (reasonType === "hook_denied" && hasOwn(raw, "hook_id")) {
+        const hookId = raw.hook_id;
+        if (hookId !== null && typeof hookId !== "string") {
+            throw new Error("error_report.reason.hook_id must be string or null");
+        }
+        reason.hook_id = hookId;
+    }
+    return reason;
+}
+function parseAgentErrorReport(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (raw === null) {
+        return null;
+    }
+    if (!isPlainRecord(raw)) {
+        throw new Error("error_report must be object");
+    }
+    const reason = hasOwn(raw, "reason")
+        ? parseAgentErrorReason(raw.reason)
+        : undefined;
+    return {
+        class: requireStringField(raw, "class"),
+        message: requireStringField(raw, "message"),
+        ...(reason !== undefined ? { reason } : {}),
+    };
+}
+function parseContentInput(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    return String(raw ?? "");
+}
+function parseContentBlocks(raw, legacyText) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw != null)
+        throw new Error("content must be a content block array");
+    if (typeof legacyText === "string" && legacyText.length > 0) {
+        return [{ type: "text", text: legacyText }];
+    }
+    return [];
+}
+function parseToolConfigChangeStatus(raw) {
+    if (raw == null || typeof raw !== "object") {
+        return undefined;
+    }
+    const value = raw;
+    const kind = String(value.kind ?? "");
+    switch (kind) {
+        case "boundary_applied":
+            return {
+                kind,
+                base_changed: typeof value.base_changed === "boolean" ? value.base_changed : false,
+                visible_changed: typeof value.visible_changed === "boolean" ? value.visible_changed : false,
+                revision: Number(value.revision ?? 0),
+            };
+        case "deferred_catalog_delta":
+            return {
+                kind,
+                added_hidden_count: Number(value.added_hidden_count ?? 0),
+                removed_hidden_count: Number(value.removed_hidden_count ?? 0),
+                pending_source_count: Number(value.pending_source_count ?? 0),
+            };
+        case "warning_failed_closed":
+            return {
+                kind,
+                error: String(value.error ?? ""),
+            };
+        case "external_tool_delta":
+            return {
+                kind,
+                phase: String(value.phase ?? "pending"),
+                ...(value.detail != null ? { detail: String(value.detail) } : {}),
+            };
+        default:
+            return undefined;
+    }
+}
+function parseSkillKey(raw) {
+    if (!isPlainRecord(raw)) {
+        return undefined;
+    }
+    const value = raw;
+    const sourceUuid = value.source_uuid ?? value.sourceUuid;
+    const skillName = value.skill_name ?? value.skillName;
+    if (typeof sourceUuid !== "string" || sourceUuid.length === 0) {
+        return undefined;
+    }
+    if (typeof skillName !== "string" || skillName.length === 0) {
+        return undefined;
+    }
+    return {
+        sourceUuid,
+        skillName,
+    };
+}
+function requireSkillKey(raw, field) {
+    const skillKey = parseSkillKey(raw);
+    if (!skillKey) {
+        throw new Error(`${field} must be SkillKey`);
+    }
+    return skillKey;
+}
+function requireSkillKeyArray(raw) {
+    if (!Array.isArray(raw)) {
+        throw new Error("skills must be SkillKey array");
+    }
+    return raw.map((skill, index) => requireSkillKey(skill, `skills[${index}]`));
+}
+const STOP_REASONS = new Set([
+    "end_turn",
+    "tool_use",
+    "max_tokens",
+    "stop_sequence",
+    "content_filter",
+    "cancelled",
+]);
+function parseStopReason(raw) {
+    return typeof raw === "string" && STOP_REASONS.has(raw)
+        ? raw
+        : undefined;
+}
+const TOOL_CONFIG_CHANGE_OPERATIONS = new Set([
+    "add",
+    "remove",
+    "reload",
+]);
+function parseToolConfigChangeOperation(raw) {
+    return typeof raw === "string" && TOOL_CONFIG_CHANGE_OPERATIONS.has(raw)
+        ? raw
+        : undefined;
+}
+function parseWireString(raw) {
+    return typeof raw === "string" ? raw : undefined;
+}
+function parseWireBoolean(raw) {
+    return typeof raw === "boolean" ? raw : undefined;
+}
+const TURN_TERMINAL_OUTCOMES = new Set([
+    "none",
+    "completed",
+    "failed",
+    "cancelled",
+    "budget_exhausted",
+    "time_budget_exceeded",
+    "structured_output_validation_failed",
+]);
+const TURN_TERMINAL_CAUSE_KINDS = new Set([
+    "unknown",
+    "hook_denied",
+    "hook_failure",
+    "llm_failure",
+    "tool_failure",
+    "structured_output_validation_failed",
+    "budget_exhausted",
+    "time_budget_exceeded",
+    "retry_exhausted",
+    "turn_limit_reached",
+    "runtime_apply_failure",
+    "fatal_failure",
+]);
+function parseSkillResolutionFailureReason(raw, fallbackMessage) {
+    if (raw == null || typeof raw !== "object") {
+        return undefined;
+    }
+    const value = raw;
+    const reasonTypeRaw = value.reason_type ?? value.reasonType;
+    if (typeof reasonTypeRaw !== "string") {
+        return undefined;
+    }
+    const reasonType = reasonTypeRaw;
+    switch (reasonType) {
+        case "not_found": {
+            const key = parseSkillKey(value.key);
+            return key ? { reasonType, key } : undefined;
+        }
+        case "capability_unavailable": {
+            const key = parseSkillKey(value.key);
+            if (!key || typeof value.capability !== "string" || value.capability.length === 0) {
+                return undefined;
+            }
+            return {
+                reasonType,
+                key,
+                capability: value.capability,
+            };
+        }
+        case "load":
+        case "parse":
+            return { reasonType, message: String(value.message ?? "") };
+        case "source_uuid_collision":
+            return {
+                reasonType,
+                sourceUuid: String(value.source_uuid ?? value.sourceUuid ?? ""),
+                existingFingerprint: String(value.existing_fingerprint ?? value.existingFingerprint ?? ""),
+                newFingerprint: String(value.new_fingerprint ?? value.newFingerprint ?? ""),
+            };
+        case "source_uuid_mutation_without_lineage":
+            return {
+                reasonType,
+                fingerprint: String(value.fingerprint ?? ""),
+                existingSourceUuid: String(value.existing_source_uuid ?? value.existingSourceUuid ?? ""),
+                mutatedSourceUuid: String(value.mutated_source_uuid ?? value.mutatedSourceUuid ?? ""),
+            };
+        case "missing_skill_remaps":
+            return {
+                reasonType,
+                eventId: String(value.event_id ?? value.eventId ?? ""),
+                eventKind: String(value.event_kind ?? value.eventKind ?? ""),
+            };
+        case "remap_without_lineage":
+            return {
+                reasonType,
+                fromSourceUuid: String(value.from_source_uuid ?? value.fromSourceUuid ?? ""),
+                fromSkillName: String(value.from_skill_name ?? value.fromSkillName ?? ""),
+                toSourceUuid: String(value.to_source_uuid ?? value.toSourceUuid ?? ""),
+                toSkillName: String(value.to_skill_name ?? value.toSkillName ?? ""),
+            };
+        case "unknown_skill_alias":
+            return { reasonType, alias: String(value.alias ?? "") };
+        case "remap_cycle":
+            return {
+                reasonType,
+                sourceUuid: String(value.source_uuid ?? value.sourceUuid ?? ""),
+                skillName: String(value.skill_name ?? value.skillName ?? ""),
+            };
+        case "unknown":
+            return { reasonType, message: String(value.message ?? fallbackMessage) };
+        default:
+            return {
+                reasonType: "unknown",
+                message: String(value.message ?? fallbackMessage),
+                rawReasonType: reasonType,
+            };
+    }
+}
 /**
  * Parse a raw wire event dict into a typed {@link StreamEvent}.
  *
@@ -68,6 +421,28 @@ function parseUsage(raw) {
  * forward-compatibility.
  */
 export function parseEvent(raw) {
+    const normalizeScopePath = (value) => {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value.map((entry) => {
+            if (!entry || typeof entry !== "object") {
+                return { scope: "primary", session_id: "" };
+            }
+            const frame = entry;
+            if (frame.scope === "mob_member") {
+                return {
+                    scope: "mob_member",
+                    flow_run_id: String(frame.flow_run_id ?? ""),
+                    agent_identity: String(frame.agent_identity ?? ""),
+                };
+            }
+            return {
+                scope: "primary",
+                session_id: String(frame.session_id ?? ""),
+            };
+        });
+    };
     if (raw.event &&
         (typeof raw.scope_id === "string" || Array.isArray(raw.scope_path))) {
         const innerRaw = typeof raw.event === "object" && raw.event !== null
@@ -76,7 +451,7 @@ export function parseEvent(raw) {
         return {
             type: "scoped_agent_event",
             scopeId: String(raw.scope_id ?? ""),
-            scopePath: (raw.scope_path ?? []),
+            scopePath: normalizeScopePath(raw.scope_path),
             event: parseCoreEvent(innerRaw),
         };
     }
@@ -85,95 +460,194 @@ export function parseEvent(raw) {
 /** Parse a raw wire event as a core (non-wrapper) agent event. */
 export function parseCoreEvent(raw) {
     const type = String(raw.type ?? "");
-    switch (type) {
-        // Session lifecycle
-        case "run_started":
-            return { type, sessionId: String(raw.session_id ?? ""), prompt: String(raw.prompt ?? "") };
-        case "run_completed":
-            return { type, sessionId: String(raw.session_id ?? ""), result: String(raw.result ?? ""), usage: parseUsage(raw.usage) };
-        case "run_failed":
-            return { type, sessionId: String(raw.session_id ?? ""), error: String(raw.error ?? "") };
-        // Turn / LLM
-        case "turn_started":
-            return { type, turnNumber: Number(raw.turn_number ?? 0) };
-        case "text_delta":
-            return { type, delta: String(raw.delta ?? "") };
-        case "text_complete":
-            return { type, content: String(raw.content ?? "") };
-        case "tool_call_requested":
-            return { type, id: String(raw.id ?? ""), name: String(raw.name ?? ""), args: raw.args };
-        case "tool_result_received":
-            return { type, id: String(raw.id ?? ""), name: String(raw.name ?? ""), isError: Boolean(raw.is_error) };
-        case "turn_completed":
-            return { type, stopReason: String(raw.stop_reason ?? "end_turn"), usage: parseUsage(raw.usage) };
-        // Tool execution
-        case "tool_execution_started":
-            return { type, id: String(raw.id ?? ""), name: String(raw.name ?? "") };
-        case "tool_execution_completed":
-            return { type, id: String(raw.id ?? ""), name: String(raw.name ?? ""), result: String(raw.result ?? ""), isError: Boolean(raw.is_error), durationMs: Number(raw.duration_ms ?? 0) };
-        case "tool_execution_timed_out":
-            return { type, id: String(raw.id ?? ""), name: String(raw.name ?? ""), timeoutMs: Number(raw.timeout_ms ?? 0) };
-        // Compaction
-        case "compaction_started":
-            return { type, inputTokens: Number(raw.input_tokens ?? 0), estimatedHistoryTokens: Number(raw.estimated_history_tokens ?? 0), messageCount: Number(raw.message_count ?? 0) };
-        case "compaction_completed":
-            return { type, summaryTokens: Number(raw.summary_tokens ?? 0), messagesBefore: Number(raw.messages_before ?? 0), messagesAfter: Number(raw.messages_after ?? 0) };
-        case "compaction_failed":
-            return { type, error: String(raw.error ?? "") };
-        // Budget
-        case "budget_warning":
-            return { type, budgetType: String(raw.budget_type ?? ""), used: Number(raw.used ?? 0), limit: Number(raw.limit ?? 0), percent: Number(raw.percent ?? 0) };
-        // Retry
-        case "retrying":
-            return { type, attempt: Number(raw.attempt ?? 0), maxAttempts: Number(raw.max_attempts ?? 0), error: String(raw.error ?? ""), delayMs: Number(raw.delay_ms ?? 0) };
-        // Hooks
-        case "hook_started":
-            return { type, hookId: String(raw.hook_id ?? ""), point: String(raw.point ?? "") };
-        case "hook_completed":
-            return { type, hookId: String(raw.hook_id ?? ""), point: String(raw.point ?? ""), durationMs: Number(raw.duration_ms ?? 0) };
-        case "hook_failed":
-            return { type, hookId: String(raw.hook_id ?? ""), point: String(raw.point ?? ""), error: String(raw.error ?? "") };
-        case "hook_denied":
-            return { type, hookId: String(raw.hook_id ?? ""), point: String(raw.point ?? ""), reasonCode: String(raw.reason_code ?? ""), message: String(raw.message ?? ""), ...(raw.payload != null ? { payload: raw.payload } : {}) };
-        case "hook_rewrite_applied":
-            return { type, hookId: String(raw.hook_id ?? ""), point: String(raw.point ?? ""), patch: (raw.patch ?? {}) };
-        case "hook_patch_published":
-            return { type, hookId: String(raw.hook_id ?? ""), point: String(raw.point ?? ""), envelope: (raw.envelope ?? {}) };
-        // Skills
-        case "skills_resolved":
-            return { type, skills: (raw.skills ?? []), injectionBytes: Number(raw.injection_bytes ?? 0) };
-        case "skill_resolution_failed":
-            return { type, reference: String(raw.reference ?? ""), error: String(raw.error ?? "") };
-        // Interaction (comms)
-        case "interaction_complete":
-            return { type, interactionId: String(raw.interaction_id ?? ""), result: String(raw.result ?? "") };
-        case "interaction_failed":
-            return { type, interactionId: String(raw.interaction_id ?? ""), error: String(raw.error ?? "") };
-        // Stream management
-        case "stream_truncated":
-            return { type, reason: String(raw.reason ?? "") };
-        case "tool_config_changed": {
-            const payloadRaw = typeof raw.payload === "object" && raw.payload !== null
-                ? raw.payload
-                : {};
-            const appliedAtTurnRaw = payloadRaw.applied_at_turn;
-            const appliedAtTurn = typeof appliedAtTurnRaw === "number" && Number.isFinite(appliedAtTurnRaw)
-                ? appliedAtTurnRaw
-                : undefined;
-            return {
-                type,
-                payload: {
-                    operation: String(payloadRaw.operation ?? "reload"),
-                    target: String(payloadRaw.target ?? ""),
-                    status: String(payloadRaw.status ?? ""),
-                    persisted: typeof payloadRaw.persisted === "boolean" ? payloadRaw.persisted : false,
-                    ...(appliedAtTurn != null ? { applied_at_turn: appliedAtTurn } : {}),
-                },
-            };
+    try {
+        switch (type) {
+            // Session lifecycle
+            case "run_started":
+                return { type, sessionId: requireStringField(raw, "session_id"), prompt: parseContentInput(raw.prompt) };
+            case "run_completed":
+                return {
+                    type,
+                    sessionId: requireStringField(raw, "session_id"),
+                    result: requireStringField(raw, "result"),
+                    ...(raw.structured_output !== undefined ? { structuredOutput: raw.structured_output } : {}),
+                    ...(raw.extraction_required !== undefined ? { extractionRequired: Boolean(raw.extraction_required) } : {}),
+                    usage: parseUsage(raw.usage),
+                    ...terminalCauseKindField(raw),
+                };
+            case "extraction_succeeded": {
+                const rawWarnings = Array.isArray(raw.schema_warnings) ? raw.schema_warnings : undefined;
+                const schemaWarnings = rawWarnings?.map((warning) => {
+                    const record = isPlainRecord(warning) ? warning : {};
+                    return {
+                        provider: String(record.provider ?? ""),
+                        path: String(record.path ?? ""),
+                        message: String(record.message ?? ""),
+                    };
+                });
+                return {
+                    type,
+                    sessionId: requireStringField(raw, "session_id"),
+                    structuredOutput: raw.structured_output,
+                    ...(schemaWarnings ? { schemaWarnings } : {}),
+                };
+            }
+            case "extraction_failed":
+                return {
+                    type,
+                    sessionId: requireStringField(raw, "session_id"),
+                    lastOutput: requireStringField(raw, "last_output"),
+                    attempts: requireNumberField(raw, "attempts"),
+                    reason: requireStringField(raw, "reason"),
+                };
+            case "run_failed":
+                return {
+                    type,
+                    sessionId: requireStringField(raw, "session_id"),
+                    errorClass: requireStringField(raw, "error_class"),
+                    error: requireStringField(raw, "error"),
+                    ...terminalCauseKindField(raw),
+                    ...(hasOwn(raw, "error_report") ? { errorReport: parseAgentErrorReport(raw.error_report) ?? null } : {}),
+                };
+            // Turn / LLM
+            case "turn_started":
+                return { type, turnNumber: requireNumberField(raw, "turn_number") };
+            case "text_delta":
+                return { type, delta: requireStringField(raw, "delta") };
+            case "text_complete":
+                return { type, content: requireStringField(raw, "content") };
+            case "tool_call_requested":
+                return {
+                    type,
+                    id: requireStringField(raw, "id"),
+                    name: requireStringField(raw, "name"),
+                    args: requireRecordField(raw, "args"),
+                };
+            case "tool_result_received":
+                return {
+                    type,
+                    id: requireStringField(raw, "id"),
+                    name: requireStringField(raw, "name"),
+                    content: parseContentBlocks(raw.content),
+                    isError: requireBooleanField(raw, "is_error"),
+                };
+            case "turn_completed":
+                return {
+                    type,
+                    stopReason: requireOneOf(requireStringField(raw, "stop_reason"), "stop_reason", ["end_turn", "tool_use", "max_tokens", "stop_sequence", "content_filter", "cancelled"]),
+                    usage: parseUsage(raw.usage),
+                };
+            // Tool execution
+            case "tool_execution_started":
+                return { type, id: requireStringField(raw, "id"), name: requireStringField(raw, "name") };
+            case "tool_execution_completed":
+                return {
+                    type,
+                    id: requireStringField(raw, "id"),
+                    name: requireStringField(raw, "name"),
+                    result: requireStringField(raw, "result"),
+                    content: parseContentBlocks(raw.content, raw.result),
+                    ...(parseWireBoolean(raw.is_error) != null ? { isError: parseWireBoolean(raw.is_error) } : {}),
+                    ...(typeof raw.duration_ms === "number" && Number.isFinite(raw.duration_ms)
+                        ? { durationMs: raw.duration_ms }
+                        : {}),
+                };
+            case "tool_execution_timed_out":
+                return { type, id: requireStringField(raw, "id"), name: requireStringField(raw, "name"), timeoutMs: requireNumberField(raw, "timeout_ms") };
+            // Compaction
+            case "compaction_started":
+                return { type, inputTokens: requireNumberField(raw, "input_tokens"), estimatedHistoryTokens: requireNumberField(raw, "estimated_history_tokens"), messageCount: requireNumberField(raw, "message_count") };
+            case "compaction_completed":
+                return { type, summaryTokens: requireNumberField(raw, "summary_tokens"), messagesBefore: requireNumberField(raw, "messages_before"), messagesAfter: requireNumberField(raw, "messages_after") };
+            case "compaction_failed":
+                return { type, error: requireStringField(raw, "error") };
+            // Budget
+            case "budget_warning":
+                return { type, budgetType: requireOneOf(requireStringField(raw, "budget_type"), "budget_type", ["tokens", "time", "tool_calls"]), used: requireNumberField(raw, "used"), limit: requireNumberField(raw, "limit"), percent: requireNumberField(raw, "percent") };
+            // Retry
+            case "retrying":
+                return { type, attempt: requireNumberField(raw, "attempt"), maxAttempts: requireNumberField(raw, "max_attempts"), error: requireStringField(raw, "error"), delayMs: requireNumberField(raw, "delay_ms") };
+            // Hooks
+            case "hook_started":
+                return { type, hookId: requireStringField(raw, "hook_id"), point: requireStringField(raw, "point") };
+            case "hook_completed":
+                return { type, hookId: requireStringField(raw, "hook_id"), point: requireStringField(raw, "point"), durationMs: requireNumberField(raw, "duration_ms") };
+            case "hook_failed":
+                return { type, hookId: requireStringField(raw, "hook_id"), point: requireStringField(raw, "point"), error: requireStringField(raw, "error") };
+            case "hook_denied":
+                return { type, hookId: requireStringField(raw, "hook_id"), point: requireStringField(raw, "point"), reasonCode: requireStringField(raw, "reason_code"), message: requireStringField(raw, "message"), ...(raw.payload != null ? { payload: raw.payload } : {}) };
+            // Skills
+            case "skills_resolved":
+                return {
+                    type,
+                    skills: requireSkillKeyArray(raw.skills),
+                    injectionBytes: requireNumberField(raw, "injection_bytes"),
+                };
+            case "skill_resolution_failed": {
+                const reference = requireStringField(raw, "reference");
+                const error = requireStringField(raw, "error");
+                const skillKey = parseSkillKey(raw.skill_key);
+                const reason = parseSkillResolutionFailureReason(raw.reason, error);
+                return {
+                    type,
+                    ...(skillKey ? { skillKey } : {}),
+                    ...(reason ? { reason } : {}),
+                    reference,
+                    error,
+                };
+            }
+            // Interaction (comms)
+            case "interaction_complete":
+                return {
+                    type,
+                    interactionId: requireStringField(raw, "interaction_id"),
+                    result: requireStringField(raw, "result"),
+                    ...(raw.structured_output !== undefined ? { structuredOutput: raw.structured_output } : {}),
+                };
+            case "interaction_failed":
+                return { type, interactionId: requireStringField(raw, "interaction_id"), error: requireStringField(raw, "error") };
+            // Stream management
+            case "stream_truncated":
+                return { type, reason: requireStringField(raw, "reason") };
+            case "tool_config_changed": {
+                if (!isPlainRecord(raw.payload))
+                    throw new Error("payload must be object");
+                const payloadRaw = raw.payload;
+                const appliedAtTurnRaw = payloadRaw.applied_at_turn;
+                const appliedAtTurn = typeof appliedAtTurnRaw === "number" && Number.isFinite(appliedAtTurnRaw)
+                    ? appliedAtTurnRaw
+                    : undefined;
+                const statusInfo = parseToolConfigChangeStatus(payloadRaw?.status_info);
+                return {
+                    type,
+                    payload: {
+                        ...(statusInfo != null ? { status_info: statusInfo } : {}),
+                        operation: requireOneOf(requireStringField(payloadRaw, "operation"), "operation", ["add", "remove", "reload"]),
+                        target: requireStringField(payloadRaw, "target"),
+                        status: requireStringField(payloadRaw, "status"),
+                        persisted: requireBooleanField(payloadRaw, "persisted"),
+                        ...(appliedAtTurn != null ? { applied_at_turn: appliedAtTurn } : {}),
+                    },
+                };
+            }
+            case "background_job_completed": {
+                const legacyStatus = typeof raw.status === "string" ? raw.status : undefined;
+                return {
+                    type,
+                    jobId: requireStringField(raw, "job_id"),
+                    displayName: requireStringField(raw, "display_name"),
+                    ...(legacyStatus != null ? { legacyStatus } : {}),
+                    terminalStatus: requireOneOf(requireStringField(raw, "terminal_status"), "terminal_status", ["completed", "failed", "aborted", "cancelled", "retired", "terminated"]),
+                    detail: requireStringField(raw, "detail"),
+                };
+            }
+            // Unknown — forward-compat
+            default:
+                return { type, ...raw };
         }
-        // Unknown — forward-compat
-        default:
-            return { type, ...raw };
+    }
+    catch (error) {
+        return malformedEvent(raw, type, error instanceof Error ? error.message : String(error));
     }
 }
 //# sourceMappingURL=events.js.map