@machinemetrics/agent-event-protocol 0.1.0 → 0.2.0

package/dist/core.d.cts

@@ -1,119 +1,395 @@
-export { h as AbortedEvent, a as ActionResult, i as AgentEvent, b as AgentRequest, A as AssistantContentBlock, C as ContinuationEvent, D as DoneEvent, c as ErrorCode, g as ErrorEvent, E as EventStage, F as FinishReason, I as InputMessage, M as MetadataEvent, T as TextEvent, d as ThinkingEvent, e as ToolCallEvent, f as ToolResultEvent, U as UserContentBlock } from './types-CttB5bnC.cjs';
+export { h as AbortedEvent, a as ActionResult, i as AgentEvent, b as AgentRequest, A as AssistantContentBlock, C as ContinuationEvent, D as DoneEvent, c as ErrorCode, g as ErrorEvent, E as EventStage, F as FinishReason, I as InputMessage, M as MetadataEvent, T as TextEvent, d as ThinkingEvent, e as ToolCallEvent, f as ToolResultEvent, U as UserContentBlock } from './types-HORFdRxd.cjs';
 import { z } from 'zod';
 
 /**
- * Zod schema for validating user content blocks.
- * Currently only supports text; extensible for multimodal.
+ * Zod schema for a user text block.
  */
-declare const UserContentBlockSchema: z.ZodObject<{
+declare const UserTextBlockSchema: z.ZodObject<{
     type: z.ZodLiteral<"text">;
     text: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    type: "text";
+}, {
+    text: string;
+    type: "text";
+}>;
+declare const MediaTypeSchema: z.ZodString;
+/**
+ * Zod schema for a user attachment block: a file the user uploaded ahead of
+ * the message and now refers to by id. How the file reaches the model (an
+ * image, a document, extracted text, a tool) is the server's decision.
+ */
+declare const UserAttachmentBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attachment">;
+    attachmentId: z.ZodString;
+    mimeType: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "attachment";
+    attachmentId: string;
+    mimeType: string;
+    name?: string | undefined;
+}, {
+    type: "attachment";
+    attachmentId: string;
+    mimeType: string;
+    name?: string | undefined;
+}>;
+/**
+ * Zod schema for validating user content blocks: text or an attachment.
+ */
+declare const UserContentBlockSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    type: "text";
+}, {
+    text: string;
+    type: "text";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"attachment">;
+    attachmentId: z.ZodString;
+    mimeType: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "attachment";
+    attachmentId: string;
+    mimeType: string;
+    name?: string | undefined;
+}, {
+    type: "attachment";
+    attachmentId: string;
+    mimeType: string;
+    name?: string | undefined;
+}>]>;
 /**
  * Zod schema for validating assistant content blocks.
  * Discriminated union supporting text, thinking, tool_use, and tool_result.
  */
-declare const AssistantContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+declare const AssistantContentBlockSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"text">;
     text: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    type: "text";
+}, {
+    text: string;
+    type: "text";
+}>, z.ZodObject<{
     type: z.ZodLiteral<"thinking">;
     text: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    type: "thinking";
+}, {
+    text: string;
+    type: "thinking";
+}>, z.ZodObject<{
     type: z.ZodLiteral<"tool_use">;
     toolCallId: z.ZodString;
     tool: z.ZodString;
     args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    type: "tool_use";
+    toolCallId: string;
+    tool: string;
+    args: Record<string, unknown>;
+}, {
+    type: "tool_use";
+    toolCallId: string;
+    tool: string;
+    args: Record<string, unknown>;
+}>, z.ZodObject<{
     type: z.ZodLiteral<"tool_result">;
     toolCallId: z.ZodString;
     tool: z.ZodString;
-    status: z.ZodEnum<{
-        success: "success";
-        error: "error";
-    }>;
+    status: z.ZodEnum<["success", "error"]>;
     summary: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "type">;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_result";
+    status: "success" | "error";
+    toolCallId: string;
+    tool: string;
+    summary?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+}, {
+    type: "tool_result";
+    status: "success" | "error";
+    toolCallId: string;
+    tool: string;
+    summary?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+}>]>;
 /**
  * Zod schema for validating input messages.
  */
 declare const InputMessageSchema: z.ZodObject<{
-    content: z.ZodArray<z.ZodObject<{
+    content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"attachment">;
+        attachmentId: z.ZodString;
+        mimeType: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "attachment";
+        attachmentId: string;
+        mimeType: string;
+        name?: string | undefined;
+    }, {
+        type: "attachment";
+        attachmentId: string;
+        mimeType: string;
+        name?: string | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: ({
+        text: string;
+        type: "text";
+    } | {
+        type: "attachment";
+        attachmentId: string;
+        mimeType: string;
+        name?: string | undefined;
+    })[];
+}, {
+    content: ({
+        text: string;
+        type: "text";
+    } | {
+        type: "attachment";
+        attachmentId: string;
+        mimeType: string;
+        name?: string | undefined;
+    })[];
+}>;
 /**
  * Zod schema for validating action results from continuation events.
  */
 declare const ActionResultSchema: z.ZodObject<{
     actionId: z.ZodString;
     kind: z.ZodString;
-    status: z.ZodEnum<{
-        success: "success";
-        error: "error";
-    }>;
+    status: z.ZodEnum<["success", "error"]>;
     data: z.ZodOptional<z.ZodUnknown>;
     error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    status: "success" | "error";
+    actionId: string;
+    kind: string;
+    error?: string | undefined;
+    data?: unknown;
+}, {
+    status: "success" | "error";
+    actionId: string;
+    kind: string;
+    error?: string | undefined;
+    data?: unknown;
+}>;
 /**
  * Zod schema for validating agent request payloads.
  * Context object uses passthrough() to allow additional fields.
  */
 declare const AgentRequestSchema: z.ZodObject<{
     messages: z.ZodArray<z.ZodObject<{
-        content: z.ZodArray<z.ZodObject<{
+        content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
             type: z.ZodLiteral<"text">;
             text: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"attachment">;
+            attachmentId: z.ZodString;
+            mimeType: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "attachment";
+            attachmentId: string;
+            mimeType: string;
+            name?: string | undefined;
+        }, {
+            type: "attachment";
+            attachmentId: string;
+            mimeType: string;
+            name?: string | undefined;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "attachment";
+            attachmentId: string;
+            mimeType: string;
+            name?: string | undefined;
+        })[];
+    }, {
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "attachment";
+            attachmentId: string;
+            mimeType: string;
+            name?: string | undefined;
+        })[];
+    }>, "many">;
     threadId: z.ZodOptional<z.ZodString>;
     context: z.ZodOptional<z.ZodObject<{
         actionResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
             actionId: z.ZodString;
             kind: z.ZodString;
-            status: z.ZodEnum<{
-                success: "success";
-                error: "error";
-            }>;
+            status: z.ZodEnum<["success", "error"]>;
+            data: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }>, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        actionResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            actionId: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<["success", "error"]>;
+            data: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        actionResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            actionId: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<["success", "error"]>;
+            data: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "attachment";
+            attachmentId: string;
+            mimeType: string;
+            name?: string | undefined;
+        })[];
+    }[];
+    threadId?: string | undefined;
+    context?: z.objectOutputType<{
+        actionResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            actionId: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<["success", "error"]>;
             data: z.ZodOptional<z.ZodUnknown>;
             error: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$loose>>;
-}, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    messages: {
+        content: ({
+            text: string;
+            type: "text";
+        } | {
+            type: "attachment";
+            attachmentId: string;
+            mimeType: string;
+            name?: string | undefined;
+        })[];
+    }[];
+    threadId?: string | undefined;
+    context?: z.objectInputType<{
+        actionResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            actionId: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<["success", "error"]>;
+            data: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }, {
+            status: "success" | "error";
+            actionId: string;
+            kind: string;
+            error?: string | undefined;
+            data?: unknown;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
 /**
  * Zod schema for event lifecycle stages.
  */
-declare const EventStageSchema: z.ZodEnum<{
-    start: "start";
-    delta: "delta";
-    stop: "stop";
-}>;
+declare const EventStageSchema: z.ZodEnum<["start", "delta", "stop"]>;
 /**
  * Zod schema for protocol error codes.
  */
-declare const ErrorCodeSchema: z.ZodEnum<{
-    auth_failed: "auth_failed";
-    thread_not_found: "thread_not_found";
-    thread_access_denied: "thread_access_denied";
-    invalid_message_format: "invalid_message_format";
-    message_too_large: "message_too_large";
-    rate_limit_exceeded: "rate_limit_exceeded";
-    stream_timeout: "stream_timeout";
-    agent_error: "agent_error";
-    tool_error: "tool_error";
-    internal_error: "internal_error";
-    invalid_action_id: "invalid_action_id";
-}>;
+declare const ErrorCodeSchema: z.ZodEnum<["auth_failed", "thread_not_found", "thread_access_denied", "invalid_message_format", "message_too_large", "rate_limit_exceeded", "stream_timeout", "stream_stalled", "agent_error", "tool_error", "internal_error", "invalid_action_id"]>;
 /**
  * Zod schema for stream finish reasons.
  */
-declare const FinishReasonSchema: z.ZodEnum<{
-    error: "error";
-    stop: "stop";
-    length: "length";
-    action_required: "action_required";
-}>;
+declare const FinishReasonSchema: z.ZodEnum<["stop", "length", "error", "action_required"]>;
 /**
  * Zod schema for metadata events.
  * First event in every stream, provides identifiers.
@@ -124,7 +400,19 @@ declare const MetadataEventSchema: z.ZodObject<{
     threadId: z.ZodString;
     agentId: z.ZodString;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    threadId: string;
+    event: "metadata";
+    requestId: string;
+    agentId: string;
+    timestamp: string;
+}, {
+    threadId: string;
+    event: "metadata";
+    requestId: string;
+    agentId: string;
+    timestamp: string;
+}>;
 /**
  * Zod schema for text streaming events.
  * Validates the stage lifecycle with appropriate optional fields per stage.
@@ -135,15 +423,31 @@ declare const TextEventSchema: z.ZodObject<{
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     delta: z.ZodOptional<z.ZodString>;
     deltaIndex: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    event: "text";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}, {
+    event: "text";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}>;
 /**
  * Zod schema for thinking/reasoning events.
  * Structure mirrors TextEventSchema.
@@ -154,15 +458,31 @@ declare const ThinkingEventSchema: z.ZodObject<{
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     delta: z.ZodOptional<z.ZodString>;
     deltaIndex: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    event: "thinking";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}, {
+    event: "thinking";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}>;
 /**
  * Zod schema for tool call events.
  * Args are optional (only present on stop stage).
@@ -173,18 +493,40 @@ declare const ToolCallEventSchema: z.ZodObject<{
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     toolCallId: z.ZodOptional<z.ZodString>;
     tool: z.ZodOptional<z.ZodString>;
     delta: z.ZodOptional<z.ZodString>;
     deltaIndex: z.ZodOptional<z.ZodNumber>;
     args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    event: "tool_call";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    args?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}, {
+    event: "tool_call";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    args?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}>;
 /**
  * Zod schema for tool result events.
  * Status and summary only present on stop stage.
@@ -195,20 +537,40 @@ declare const ToolResultEventSchema: z.ZodObject<{
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     toolCallId: z.ZodOptional<z.ZodString>;
     tool: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        error: "error";
-    }>>;
+    status: z.ZodOptional<z.ZodEnum<["success", "error"]>>;
     summary: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    event: "tool_result";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    status?: "success" | "error" | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    summary?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+}, {
+    event: "tool_result";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    status?: "success" | "error" | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    summary?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+}>;
 /**
  * Zod schema for done events.
  * Terminal event with complete content array.
@@ -218,40 +580,137 @@ declare const DoneEventSchema: z.ZodObject<{
     requestId: z.ZodString;
     messageId: z.ZodString;
     threadId: z.ZodString;
-    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"thinking">;
         text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        type: "thinking";
+    }, {
+        text: string;
+        type: "thinking";
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"tool_use">;
         toolCallId: z.ZodString;
         tool: z.ZodString;
         args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    }, {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"tool_result">;
         toolCallId: z.ZodString;
         tool: z.ZodString;
-        status: z.ZodEnum<{
-            success: "success";
-            error: "error";
-        }>;
+        status: z.ZodEnum<["success", "error"]>;
         summary: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "type">>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    }, {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    }>]>, "many">;
     usage: z.ZodOptional<z.ZodObject<{
         promptTokens: z.ZodNumber;
         completionTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-    finishReason: z.ZodEnum<{
-        error: "error";
-        stop: "stop";
-        length: "length";
-        action_required: "action_required";
-    }>;
+    }, "strip", z.ZodTypeAny, {
+        promptTokens: number;
+        completionTokens: number;
+    }, {
+        promptTokens: number;
+        completionTokens: number;
+    }>>;
+    finishReason: z.ZodEnum<["stop", "length", "error", "action_required"]>;
     traceId: z.ZodOptional<z.ZodString>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    content: ({
+        text: string;
+        type: "text";
+    } | {
+        text: string;
+        type: "thinking";
+    } | {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    })[];
+    threadId: string;
+    event: "done";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    finishReason: "error" | "stop" | "length" | "action_required";
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    } | undefined;
+    traceId?: string | undefined;
+}, {
+    content: ({
+        text: string;
+        type: "text";
+    } | {
+        text: string;
+        type: "thinking";
+    } | {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    })[];
+    threadId: string;
+    event: "done";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    finishReason: "error" | "stop" | "length" | "action_required";
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    } | undefined;
+    traceId?: string | undefined;
+}>;
 /**
  * Zod schema for error events.
  * Terminal event with error details and retry guidance.
@@ -260,22 +719,24 @@ declare const ErrorEventSchema: z.ZodObject<{
     event: z.ZodLiteral<"error">;
     requestId: z.ZodString;
     message: z.ZodString;
-    code: z.ZodOptional<z.ZodEnum<{
-        auth_failed: "auth_failed";
-        thread_not_found: "thread_not_found";
-        thread_access_denied: "thread_access_denied";
-        invalid_message_format: "invalid_message_format";
-        message_too_large: "message_too_large";
-        rate_limit_exceeded: "rate_limit_exceeded";
-        stream_timeout: "stream_timeout";
-        agent_error: "agent_error";
-        tool_error: "tool_error";
-        internal_error: "internal_error";
-        invalid_action_id: "invalid_action_id";
-    }>>;
+    code: z.ZodOptional<z.ZodEnum<["auth_failed", "thread_not_found", "thread_access_denied", "invalid_message_format", "message_too_large", "rate_limit_exceeded", "stream_timeout", "stream_stalled", "agent_error", "tool_error", "internal_error", "invalid_action_id"]>>;
     retryable: z.ZodOptional<z.ZodBoolean>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    event: "error";
+    requestId: string;
+    timestamp: string;
+    code?: "auth_failed" | "thread_not_found" | "thread_access_denied" | "invalid_message_format" | "message_too_large" | "rate_limit_exceeded" | "stream_timeout" | "stream_stalled" | "agent_error" | "tool_error" | "internal_error" | "invalid_action_id" | undefined;
+    retryable?: boolean | undefined;
+}, {
+    message: string;
+    event: "error";
+    requestId: string;
+    timestamp: string;
+    code?: "auth_failed" | "thread_not_found" | "thread_access_denied" | "invalid_message_format" | "message_too_large" | "rate_limit_exceeded" | "stream_timeout" | "stream_stalled" | "agent_error" | "tool_error" | "internal_error" | "invalid_action_id" | undefined;
+    retryable?: boolean | undefined;
+}>;
 /**
  * Zod schema for aborted events.
  * Terminal event acknowledging client cancellation.
@@ -285,7 +746,17 @@ declare const AbortedEventSchema: z.ZodObject<{
     requestId: z.ZodString;
     messageId: z.ZodOptional<z.ZodString>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    event: "aborted";
+    requestId: string;
+    timestamp: string;
+    messageId?: string | undefined;
+}, {
+    event: "aborted";
+    requestId: string;
+    timestamp: string;
+    messageId?: string | undefined;
+}>;
 /**
  * Zod schema for continuation events.
  * Signals client action required before stream can continue.
@@ -297,151 +768,374 @@ declare const ContinuationEventSchema: z.ZodObject<{
     kind: z.ZodString;
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     timestamp: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    actionId: string;
+    kind: string;
+    event: "continuation";
+    requestId: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}, {
+    actionId: string;
+    kind: string;
+    event: "continuation";
+    requestId: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}>;
 /**
  * Zod schema for all protocol events.
  * Discriminated union on the `event` field for efficient parsing.
  */
-declare const AgentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+declare const AgentEventSchema: z.ZodDiscriminatedUnion<"event", [z.ZodObject<{
     event: z.ZodLiteral<"metadata">;
     requestId: z.ZodString;
     threadId: z.ZodString;
     agentId: z.ZodString;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    threadId: string;
+    event: "metadata";
+    requestId: string;
+    agentId: string;
+    timestamp: string;
+}, {
+    threadId: string;
+    event: "metadata";
+    requestId: string;
+    agentId: string;
+    timestamp: string;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"text">;
     requestId: z.ZodString;
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     delta: z.ZodOptional<z.ZodString>;
     deltaIndex: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    event: "text";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}, {
+    event: "text";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"thinking">;
     requestId: z.ZodString;
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     delta: z.ZodOptional<z.ZodString>;
     deltaIndex: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    event: "thinking";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}, {
+    event: "thinking";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"tool_call">;
     requestId: z.ZodString;
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     toolCallId: z.ZodOptional<z.ZodString>;
     tool: z.ZodOptional<z.ZodString>;
     delta: z.ZodOptional<z.ZodString>;
     deltaIndex: z.ZodOptional<z.ZodNumber>;
     args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    event: "tool_call";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    args?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}, {
+    event: "tool_call";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    delta?: string | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    args?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+    deltaIndex?: number | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"tool_result">;
     requestId: z.ZodString;
     messageId: z.ZodString;
     blockId: z.ZodString;
     blockIndex: z.ZodOptional<z.ZodNumber>;
-    stage: z.ZodEnum<{
-        start: "start";
-        delta: "delta";
-        stop: "stop";
-    }>;
+    stage: z.ZodEnum<["start", "delta", "stop"]>;
     toolCallId: z.ZodOptional<z.ZodString>;
     tool: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodEnum<{
-        success: "success";
-        error: "error";
-    }>>;
+    status: z.ZodOptional<z.ZodEnum<["success", "error"]>>;
     summary: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    event: "tool_result";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    status?: "success" | "error" | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    summary?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+}, {
+    event: "tool_result";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    blockId: string;
+    stage: "start" | "delta" | "stop";
+    status?: "success" | "error" | undefined;
+    toolCallId?: string | undefined;
+    tool?: string | undefined;
+    summary?: string | undefined;
+    output?: Record<string, unknown> | undefined;
+    blockIndex?: number | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"done">;
     requestId: z.ZodString;
     messageId: z.ZodString;
     threadId: z.ZodString;
-    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"thinking">;
         text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        type: "thinking";
+    }, {
+        text: string;
+        type: "thinking";
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"tool_use">;
         toolCallId: z.ZodString;
         tool: z.ZodString;
         args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    }, {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"tool_result">;
         toolCallId: z.ZodString;
         tool: z.ZodString;
-        status: z.ZodEnum<{
-            success: "success";
-            error: "error";
-        }>;
+        status: z.ZodEnum<["success", "error"]>;
         summary: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "type">>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    }, {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    }>]>, "many">;
     usage: z.ZodOptional<z.ZodObject<{
         promptTokens: z.ZodNumber;
         completionTokens: z.ZodNumber;
-    }, z.core.$strip>>;
-    finishReason: z.ZodEnum<{
-        error: "error";
-        stop: "stop";
-        length: "length";
-        action_required: "action_required";
-    }>;
+    }, "strip", z.ZodTypeAny, {
+        promptTokens: number;
+        completionTokens: number;
+    }, {
+        promptTokens: number;
+        completionTokens: number;
+    }>>;
+    finishReason: z.ZodEnum<["stop", "length", "error", "action_required"]>;
     traceId: z.ZodOptional<z.ZodString>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    content: ({
+        text: string;
+        type: "text";
+    } | {
+        text: string;
+        type: "thinking";
+    } | {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    })[];
+    threadId: string;
+    event: "done";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    finishReason: "error" | "stop" | "length" | "action_required";
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    } | undefined;
+    traceId?: string | undefined;
+}, {
+    content: ({
+        text: string;
+        type: "text";
+    } | {
+        text: string;
+        type: "thinking";
+    } | {
+        type: "tool_use";
+        toolCallId: string;
+        tool: string;
+        args: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        status: "success" | "error";
+        toolCallId: string;
+        tool: string;
+        summary?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+    })[];
+    threadId: string;
+    event: "done";
+    requestId: string;
+    timestamp: string;
+    messageId: string;
+    finishReason: "error" | "stop" | "length" | "action_required";
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    } | undefined;
+    traceId?: string | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"error">;
     requestId: z.ZodString;
     message: z.ZodString;
-    code: z.ZodOptional<z.ZodEnum<{
-        auth_failed: "auth_failed";
-        thread_not_found: "thread_not_found";
-        thread_access_denied: "thread_access_denied";
-        invalid_message_format: "invalid_message_format";
-        message_too_large: "message_too_large";
-        rate_limit_exceeded: "rate_limit_exceeded";
-        stream_timeout: "stream_timeout";
-        agent_error: "agent_error";
-        tool_error: "tool_error";
-        internal_error: "internal_error";
-        invalid_action_id: "invalid_action_id";
-    }>>;
+    code: z.ZodOptional<z.ZodEnum<["auth_failed", "thread_not_found", "thread_access_denied", "invalid_message_format", "message_too_large", "rate_limit_exceeded", "stream_timeout", "stream_stalled", "agent_error", "tool_error", "internal_error", "invalid_action_id"]>>;
     retryable: z.ZodOptional<z.ZodBoolean>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    event: "error";
+    requestId: string;
+    timestamp: string;
+    code?: "auth_failed" | "thread_not_found" | "thread_access_denied" | "invalid_message_format" | "message_too_large" | "rate_limit_exceeded" | "stream_timeout" | "stream_stalled" | "agent_error" | "tool_error" | "internal_error" | "invalid_action_id" | undefined;
+    retryable?: boolean | undefined;
+}, {
+    message: string;
+    event: "error";
+    requestId: string;
+    timestamp: string;
+    code?: "auth_failed" | "thread_not_found" | "thread_access_denied" | "invalid_message_format" | "message_too_large" | "rate_limit_exceeded" | "stream_timeout" | "stream_stalled" | "agent_error" | "tool_error" | "internal_error" | "invalid_action_id" | undefined;
+    retryable?: boolean | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"aborted">;
     requestId: z.ZodString;
     messageId: z.ZodOptional<z.ZodString>;
     timestamp: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    event: "aborted";
+    requestId: string;
+    timestamp: string;
+    messageId?: string | undefined;
+}, {
+    event: "aborted";
+    requestId: string;
+    timestamp: string;
+    messageId?: string | undefined;
+}>, z.ZodObject<{
     event: z.ZodLiteral<"continuation">;
     requestId: z.ZodString;
     actionId: z.ZodString;
     kind: z.ZodString;
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     timestamp: z.ZodString;
-}, z.core.$strip>], "event">;
+}, "strip", z.ZodTypeAny, {
+    actionId: string;
+    kind: string;
+    event: "continuation";
+    requestId: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}, {
+    actionId: string;
+    kind: string;
+    event: "continuation";
+    requestId: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}>]>;
 
 /**
  * Current protocol version.
@@ -460,4 +1154,4 @@ declare const EVENT_TYPES: readonly ["metadata", "text", "thinking", "tool_call"
  */
 type EventType = (typeof EVENT_TYPES)[number];
 
-export { AbortedEventSchema, ActionResultSchema, AgentEventSchema, AgentRequestSchema, AssistantContentBlockSchema, ContinuationEventSchema, DoneEventSchema, EVENT_TYPES, ErrorCodeSchema, ErrorEventSchema, EventStageSchema, type EventType, FinishReasonSchema, InputMessageSchema, MetadataEventSchema, PROTOCOL_VERSION, TextEventSchema, ThinkingEventSchema, ToolCallEventSchema, ToolResultEventSchema, UserContentBlockSchema };
+export { AbortedEventSchema, ActionResultSchema, AgentEventSchema, AgentRequestSchema, AssistantContentBlockSchema, ContinuationEventSchema, DoneEventSchema, EVENT_TYPES, ErrorCodeSchema, ErrorEventSchema, EventStageSchema, type EventType, FinishReasonSchema, InputMessageSchema, MediaTypeSchema, MetadataEventSchema, PROTOCOL_VERSION, TextEventSchema, ThinkingEventSchema, ToolCallEventSchema, ToolResultEventSchema, UserAttachmentBlockSchema, UserContentBlockSchema, UserTextBlockSchema };