@agen-ai/agent-protocol 0.1.0

package/dist/zod/turns.d.ts

@@ -0,0 +1,219 @@
+import { z } from 'zod/v4';
+import { type AgentBrowserActionDetails, type AgentCollaborationToolCallDetails, type AgentCommandExecutionDetails, type AgentComputerActionDetails, type AgentDiffSummary, type AgentDynamicToolCallDetails, type AgentFileChange, type AgentFileChangeDetails, type AgentImageViewDetails, type AgentItemSnapshot, type AgentMcpToolCallDetails, type AgentPlanStep, type AgentReviewDetails, type AgentTurnCompletedPayload, type AgentTurnInputContent, type AgentTurnInterruptionInput, type AgentTurnRunInput, type AgentWebSearchDetails } from '../turns/types.js';
+export declare const AGENT_PROTOCOL_INLINE_IMAGE_BASE64_MAX_LENGTH = 500000;
+export declare const AgentImageInputSourceSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    mediaType: z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+        "image/webp": "image/webp";
+    }>;
+    byteSize: z.ZodNumber;
+    widthPixels: z.ZodNumber;
+    heightPixels: z.ZodNumber;
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    data: z.ZodBase64;
+    mediaType: z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+        "image/webp": "image/webp";
+    }>;
+    byteSize: z.ZodNumber;
+    widthPixels: z.ZodNumber;
+    heightPixels: z.ZodNumber;
+    type: z.ZodLiteral<"base64">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    mediaType: z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+        "image/webp": "image/webp";
+    }>;
+    byteSize: z.ZodNumber;
+    widthPixels: z.ZodNumber;
+    heightPixels: z.ZodNumber;
+    type: z.ZodLiteral<"local_file">;
+    path: z.ZodString;
+    sha256: z.ZodString;
+}, z.core.$strict>>], "type">;
+export declare const AgentTurnInputPartSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    source: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        mediaType: z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+            "image/webp": "image/webp";
+        }>;
+        byteSize: z.ZodNumber;
+        widthPixels: z.ZodNumber;
+        heightPixels: z.ZodNumber;
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        data: z.ZodBase64;
+        mediaType: z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+            "image/webp": "image/webp";
+        }>;
+        byteSize: z.ZodNumber;
+        widthPixels: z.ZodNumber;
+        heightPixels: z.ZodNumber;
+        type: z.ZodLiteral<"base64">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        mediaType: z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+            "image/webp": "image/webp";
+        }>;
+        byteSize: z.ZodNumber;
+        widthPixels: z.ZodNumber;
+        heightPixels: z.ZodNumber;
+        type: z.ZodLiteral<"local_file">;
+        path: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>], "type">;
+}, z.core.$strict>>], "type">;
+export declare const AgentTurnInteractionModeSchema: z.ZodEnum<{
+    default: "default";
+    plan: "plan";
+}>;
+/**
+ * Explicit Zod composition surface for private protocols that must add
+ * transport-owned fields while retaining the canonical input refinements.
+ */
+export declare const AgentTurnInputContentCompositionSchema: z.ZodObject<{
+    parts: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            mediaType: z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>;
+            byteSize: z.ZodNumber;
+            widthPixels: z.ZodNumber;
+            heightPixels: z.ZodNumber;
+            type: z.ZodLiteral<"url">;
+            url: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            data: z.ZodBase64;
+            mediaType: z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>;
+            byteSize: z.ZodNumber;
+            widthPixels: z.ZodNumber;
+            heightPixels: z.ZodNumber;
+            type: z.ZodLiteral<"base64">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            mediaType: z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>;
+            byteSize: z.ZodNumber;
+            widthPixels: z.ZodNumber;
+            heightPixels: z.ZodNumber;
+            type: z.ZodLiteral<"local_file">;
+            path: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>>], "type">;
+    }, z.core.$strict>>], "type">>>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const AgentTurnInputContentSchema: z.ZodType<AgentTurnInputContent>;
+export declare const AgentTurnRunInputPortableSchema: z.ZodReadonly<z.ZodObject<{
+    deadlineAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+    parts: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            mediaType: z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>;
+            byteSize: z.ZodNumber;
+            widthPixels: z.ZodNumber;
+            heightPixels: z.ZodNumber;
+            type: z.ZodLiteral<"url">;
+            url: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            data: z.ZodBase64;
+            mediaType: z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>;
+            byteSize: z.ZodNumber;
+            widthPixels: z.ZodNumber;
+            heightPixels: z.ZodNumber;
+            type: z.ZodLiteral<"base64">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            mediaType: z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>;
+            byteSize: z.ZodNumber;
+            widthPixels: z.ZodNumber;
+            heightPixels: z.ZodNumber;
+            type: z.ZodLiteral<"local_file">;
+            path: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>>], "type">;
+    }, z.core.$strict>>], "type">>>;
+    summary: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodType<import("../index.js").AgentTurnId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentTurnId, unknown>>;
+    interactionMode: z.ZodEnum<{
+        default: "default";
+        plan: "plan";
+    }>;
+}, z.core.$strict>>;
+export declare const AgentTurnRunInputSchema: z.ZodType<AgentTurnRunInput>;
+export declare const AgentTurnInterruptionInputSchema: z.ZodType<AgentTurnInterruptionInput>;
+export declare const AgentCommandExecutionDetailsSchema: z.ZodType<AgentCommandExecutionDetails>;
+export declare const AgentFileChangeSchema: z.ZodType<AgentFileChange>;
+export declare const AgentFileChangeDetailsSchema: z.ZodType<AgentFileChangeDetails>;
+export declare const AgentMcpToolCallDetailsSchema: z.ZodType<AgentMcpToolCallDetails>;
+export declare const AgentDynamicToolCallDetailsSchema: z.ZodType<AgentDynamicToolCallDetails>;
+export declare const AgentCollaborationToolCallDetailsSchema: z.ZodType<AgentCollaborationToolCallDetails>;
+export declare const AgentWebSearchDetailsSchema: z.ZodType<AgentWebSearchDetails>;
+export declare const AgentBrowserActionDetailsSchema: z.ZodType<AgentBrowserActionDetails>;
+export declare const AgentComputerActionDetailsSchema: z.ZodType<AgentComputerActionDetails>;
+export declare const AgentImageViewDetailsSchema: z.ZodType<AgentImageViewDetails>;
+export declare const AgentReviewDetailsSchema: z.ZodType<AgentReviewDetails>;
+export declare const AgentItemSnapshotSchema: z.ZodType<AgentItemSnapshot>;
+export declare const AgentContentStreamKindSchema: z.ZodEnum<{
+    unknown: "unknown";
+    assistant_text: "assistant_text";
+    reasoning_text: "reasoning_text";
+    reasoning_summary: "reasoning_summary";
+    plan_text: "plan_text";
+    command_output: "command_output";
+    file_change_output: "file_change_output";
+}>;
+export declare const AgentPlanStepSchema: z.ZodType<AgentPlanStep>;
+export declare const AgentDiffSummarySchema: z.ZodType<AgentDiffSummary>;
+export declare const AgentTurnCompletedPayloadPortableSchema: z.ZodReadonly<z.ZodObject<{
+    outcome: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        canceled: "canceled";
+        expired: "expired";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodType<import("../index.js").AgentError, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentError, unknown>>>;
+}, z.core.$strict>>;
+export declare const AgentTurnCompletedPayloadSchema: z.ZodType<AgentTurnCompletedPayload>;
+//# sourceMappingURL=turns.d.ts.map

package/dist/zod/turns.js

@@ -0,0 +1,400 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
+  AGENT_PROTOCOL_TEXT_MAX_LENGTH,
+  AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/types.js";
+import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
+import {
+  AGENT_CONTENT_STREAM_KINDS,
+  AGENT_FILE_CHANGE_KINDS,
+  AGENT_IMAGE_INPUT_MEDIA_TYPES,
+  AGENT_ITEM_STATUSES,
+  AGENT_TURN_INTERACTION_MODES
+} from "../turns/types.js";
+import {
+  AgentCanonicalIdValueSchema,
+  AgentErrorSchema,
+  AgentIsoDateTimeSchema,
+  AgentItemIdSchema,
+  AgentTurnIdSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const AGENT_PROTOCOL_INLINE_IMAGE_BASE64_MAX_LENGTH = 5e5;
+const AGENT_PROTOCOL_IMAGE_BYTE_SIZE_MAX = 100 * 1024 * 1024;
+const AGENT_PROTOCOL_IMAGE_DIMENSION_MAX = 1e5;
+const AgentImageMediaTypeSchema = z.enum(AGENT_IMAGE_INPUT_MEDIA_TYPES);
+const AgentImageByteSizeSchema = z.number().int().positive().max(AGENT_PROTOCOL_IMAGE_BYTE_SIZE_MAX);
+const AgentImageDimensionSchema = z.number().int().positive().max(AGENT_PROTOCOL_IMAGE_DIMENSION_MAX);
+const AgentImageSourceMetadataShape = {
+  mediaType: AgentImageMediaTypeSchema,
+  byteSize: AgentImageByteSizeSchema,
+  widthPixels: AgentImageDimensionSchema,
+  heightPixels: AgentImageDimensionSchema
+};
+const AgentTextInputPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string().min(1).max(AGENT_PROTOCOL_TEXT_MAX_LENGTH * 16)
+}).strict().readonly();
+const AgentImageInputSourceSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("url"),
+    url: z.string().url().max(2048),
+    ...AgentImageSourceMetadataShape
+  }).strict().readonly(),
+  z.object({
+    type: z.literal("base64"),
+    ...AgentImageSourceMetadataShape,
+    data: z.base64().min(1).max(AGENT_PROTOCOL_INLINE_IMAGE_BASE64_MAX_LENGTH)
+  }).strict().superRefine((source, context) => {
+    const padding = source.data.endsWith("==") ? 2 : source.data.endsWith("=") ? 1 : 0;
+    const decodedByteSize = source.data.length / 4 * 3 - padding;
+    if (decodedByteSize !== source.byteSize) {
+      context.addIssue({
+        code: "custom",
+        path: ["byteSize"],
+        message: "Inline image byteSize must match the decoded base64 data."
+      });
+    }
+  }).readonly(),
+  z.object({
+    type: z.literal("local_file"),
+    path: z.string().min(2).max(4096).regex(
+      /^(?!.*\/\.\.(?:\/|$))\/(?![\s\S]*[\u0000-\u001F\u007F-\u009F])\S(?:[\s\S]*\S)?$/u,
+      "Local image paths must be absolute, traversal-free POSIX paths without control characters."
+    ),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    ...AgentImageSourceMetadataShape
+  }).strict().readonly()
+]);
+const AgentImageInputPartSchema = z.object({
+  type: z.literal("image"),
+  source: AgentImageInputSourceSchema
+}).strict().readonly();
+const AgentTurnInputPartSchema = z.discriminatedUnion("type", [
+  AgentTextInputPartSchema,
+  AgentImageInputPartSchema
+]);
+const AgentTurnInteractionModeSchema = z.enum(
+  AGENT_TURN_INTERACTION_MODES
+);
+const AgentTurnInputContentShape = {
+  parts: z.array(AgentTurnInputPartSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+  summary: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional()
+};
+const AgentTurnInputContentObjectSchema = z.object(AgentTurnInputContentShape).strict();
+const AgentTurnInputContentRefinedSchema = AgentTurnInputContentObjectSchema.superRefine((input, context) => {
+  const content = {
+    parts: input.parts,
+    ...input.summary === void 0 ? {} : { summary: input.summary }
+  };
+  if (agentProtocolSerializedJsonBytes(content) <= AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT) {
+    return;
+  }
+  context.addIssue({
+    code: "custom",
+    message: `Turn input content cannot exceed ${AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT} serialized bytes.`
+  });
+});
+const AgentTurnInputContentCompositionSchema = AgentTurnInputContentRefinedSchema;
+const AgentTurnInputContentSchema = AgentTurnInputContentRefinedSchema;
+const AgentTurnRunInputPortableSchema = z.object({
+  turnId: AgentTurnIdSchema,
+  interactionMode: AgentTurnInteractionModeSchema,
+  ...AgentTurnInputContentShape,
+  deadlineAt: AgentIsoDateTimeSchema.optional()
+}).strict().readonly();
+const AgentTurnRunInputSchema = AgentTurnInputContentRefinedSchema.safeExtend({
+  turnId: AgentTurnIdSchema,
+  interactionMode: AgentTurnInteractionModeSchema,
+  deadlineAt: AgentIsoDateTimeSchema.optional()
+}).strict().readonly();
+const AgentTurnInterruptionInputSchema = z.object({
+  turnId: AgentTurnIdSchema,
+  reason: z.enum([
+    "user_requested",
+    "timeout",
+    "shutdown",
+    "superseded",
+    "other"
+  ]),
+  requestedAt: AgentIsoDateTimeSchema.optional()
+}).strict().readonly();
+const DisplayPathSchema = z.string().min(1).max(500).regex(
+  /^(?![\\/]|[A-Za-z]:[\\/])(?!.*(?:^|[\\/])\.\.(?:[\\/]|$))(?![\s\S]*[\u0000-\u001F\u007F-\u009F])\S(?:[\s\S]*\S)?$/u,
+  "Display paths must be canonical, relative, traversal-free, and contain no control characters."
+);
+const SafeIntegerSchema = z.number().int().min(Number.MIN_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER);
+const NonNegativeSafeIntegerSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const DetailSummarySchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_PROTOCOL_SUMMARY_MAX_LENGTH
+);
+const DetailNameSchema = createAgentCanonicalNonBlankStringSchema(160);
+const ReviewTextSchema = createAgentCanonicalNonBlankStringSchema(
+  AGENT_PROTOCOL_TEXT_MAX_LENGTH
+);
+const TruncatedShape = { truncated: z.literal(true).optional() };
+const AgentCommandExecutionDetailsSchema = z.object({
+  commandSummary: DetailSummarySchema.optional(),
+  workingPath: DisplayPathSchema.optional(),
+  exitCode: SafeIntegerSchema.optional(),
+  durationMs: NonNegativeSafeIntegerSchema.optional(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  if (details.commandSummary === void 0 && details.workingPath === void 0 && details.exitCode === void 0 && details.durationMs === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Command details require a command summary, working path, exit code, or duration."
+    });
+  }
+}).readonly();
+const AgentFileChangeSchema = z.object({
+  path: DisplayPathSchema,
+  changeKind: z.enum(AGENT_FILE_CHANGE_KINDS)
+}).strict().readonly();
+const AgentFileChangeDetailsSchema = z.object({
+  changes: z.array(AgentFileChangeSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const [index, change] of details.changes.entries()) {
+    if (seenPaths.has(change.path)) {
+      context.addIssue({
+        code: "custom",
+        path: ["changes", index, "path"],
+        message: "File change paths must be unique."
+      });
+    }
+    seenPaths.add(change.path);
+    const previous = details.changes[index - 1];
+    if (previous && compareStringsByUnicodeCodePoint(previous.path, change.path) >= 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["changes", index, "path"],
+        message: "File changes must be sorted in ascending code-point order by path."
+      });
+    }
+  }
+}).readonly();
+const AgentMcpToolCallDetailsSchema = z.object({
+  serverName: DetailNameSchema.optional(),
+  toolName: DetailNameSchema.optional(),
+  actionSummary: DetailSummarySchema.optional(),
+  durationMs: NonNegativeSafeIntegerSchema.optional(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  if (details.serverName === void 0 && details.toolName === void 0 && details.actionSummary === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "MCP tool details require a server name, tool name, or action summary."
+    });
+  }
+}).readonly();
+const AgentDynamicToolCallDetailsSchema = z.object({
+  toolName: DetailNameSchema.optional(),
+  actionSummary: DetailSummarySchema.optional(),
+  durationMs: NonNegativeSafeIntegerSchema.optional(),
+  success: z.boolean().optional(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  if (details.toolName === void 0 && details.actionSummary === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Dynamic tool details require a tool name or action summary."
+    });
+  }
+}).readonly();
+const AgentCollaborationToolCallDetailsSchema = z.object({
+  toolName: DetailNameSchema.optional(),
+  actionSummary: DetailSummarySchema.optional(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  if (details.toolName === void 0 && details.actionSummary === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Collaboration tool details require a tool name or action summary."
+    });
+  }
+}).readonly();
+const AgentWebSearchDetailsSchema = z.object({
+  querySummary: DetailSummarySchema.optional(),
+  actionSummary: DetailSummarySchema.optional(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  if (details.querySummary === void 0 && details.actionSummary === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Web search details require a query or action summary."
+    });
+  }
+}).readonly();
+const AgentBrowserActionDetailsSchema = z.object({
+  actionSummary: DetailSummarySchema,
+  ...TruncatedShape
+}).strict().readonly();
+const AgentComputerActionDetailsSchema = z.object({
+  actionSummary: DetailSummarySchema,
+  ...TruncatedShape
+}).strict().readonly();
+const AgentImageViewDetailsSchema = z.object({
+  filePath: DisplayPathSchema.optional(),
+  actionSummary: DetailSummarySchema.optional(),
+  ...TruncatedShape
+}).strict().superRefine((details, context) => {
+  if (details.filePath === void 0 && details.actionSummary === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Image view details require a file path or action summary."
+    });
+  }
+}).readonly();
+const AgentReviewDetailsSchema = z.discriminatedUnion("phase", [
+  z.object({
+    phase: z.literal("entered"),
+    target: ReviewTextSchema,
+    ...TruncatedShape
+  }).strict().readonly(),
+  z.object({
+    phase: z.literal("exited"),
+    report: ReviewTextSchema,
+    ...TruncatedShape
+  }).strict().readonly()
+]);
+const AgentItemSnapshotCommonShape = {
+  itemId: AgentItemIdSchema,
+  status: z.enum(AGENT_ITEM_STATUSES),
+  title: z.string().max(200).optional(),
+  summary: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional()
+};
+function itemWithoutDetails(itemKind) {
+  return z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal(itemKind)
+  }).strict().readonly();
+}
+const AgentItemSnapshotSchema = z.discriminatedUnion("itemKind", [
+  itemWithoutDetails("user_message"),
+  itemWithoutDetails("assistant_message"),
+  itemWithoutDetails("reasoning"),
+  itemWithoutDetails("plan"),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("command_execution"),
+    details: AgentCommandExecutionDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("file_change"),
+    details: AgentFileChangeDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("mcp_tool_call"),
+    details: AgentMcpToolCallDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("dynamic_tool_call"),
+    details: AgentDynamicToolCallDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("collaboration_tool_call"),
+    details: AgentCollaborationToolCallDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("web_search"),
+    details: AgentWebSearchDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("browser_action"),
+    details: AgentBrowserActionDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("computer_action"),
+    details: AgentComputerActionDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("image_view"),
+    details: AgentImageViewDetailsSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    ...AgentItemSnapshotCommonShape,
+    itemKind: z.literal("review"),
+    details: AgentReviewDetailsSchema
+  }).strict().readonly(),
+  itemWithoutDetails("context_compaction"),
+  itemWithoutDetails("unknown")
+]);
+const AgentContentStreamKindSchema = z.enum(AGENT_CONTENT_STREAM_KINDS);
+const AgentPlanStepSchema = z.object({
+  stepId: AgentCanonicalIdValueSchema,
+  text: z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH),
+  status: z.enum(["pending", "in_progress", "completed", "canceled"]),
+  priority: z.enum(["low", "medium", "high"]).optional()
+}).strict().readonly();
+const AgentDiffSummarySchema = z.object({
+  summary: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH),
+  fileCount: z.number().int().min(0),
+  byteSize: z.number().int().min(0),
+  additions: z.number().int().min(0).optional(),
+  deletions: z.number().int().min(0).optional(),
+  binary: z.boolean().optional(),
+  malformed: z.boolean().optional(),
+  truncated: z.boolean().optional()
+}).strict().readonly();
+const AgentTurnCompletedPayloadPortableSchema = z.object({
+  outcome: z.enum(["completed", "failed", "canceled", "expired"]),
+  reason: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+  error: AgentErrorSchema.optional()
+}).strict().readonly();
+const AgentTurnCompletedPayloadSchema = AgentTurnCompletedPayloadPortableSchema.superRefine((payload, context) => {
+  if (payload.outcome === "failed" && payload.error === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["error"],
+      message: "Failed turns require an error."
+    });
+  }
+  if (payload.outcome !== "failed" && payload.error !== void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["error"],
+      message: "Only failed turns may contain an error."
+    });
+  }
+});
+export {
+  AGENT_PROTOCOL_INLINE_IMAGE_BASE64_MAX_LENGTH,
+  AgentBrowserActionDetailsSchema,
+  AgentCollaborationToolCallDetailsSchema,
+  AgentCommandExecutionDetailsSchema,
+  AgentComputerActionDetailsSchema,
+  AgentContentStreamKindSchema,
+  AgentDiffSummarySchema,
+  AgentDynamicToolCallDetailsSchema,
+  AgentFileChangeDetailsSchema,
+  AgentFileChangeSchema,
+  AgentImageInputSourceSchema,
+  AgentImageViewDetailsSchema,
+  AgentItemSnapshotSchema,
+  AgentMcpToolCallDetailsSchema,
+  AgentPlanStepSchema,
+  AgentReviewDetailsSchema,
+  AgentTurnCompletedPayloadPortableSchema,
+  AgentTurnCompletedPayloadSchema,
+  AgentTurnInputContentCompositionSchema,
+  AgentTurnInputContentSchema,
+  AgentTurnInputPartSchema,
+  AgentTurnInteractionModeSchema,
+  AgentTurnInterruptionInputSchema,
+  AgentTurnRunInputPortableSchema,
+  AgentTurnRunInputSchema,
+  AgentWebSearchDetailsSchema
+};

package/dist/zod/typeEquality.generated.d.ts

@@ -0,0 +1,51 @@
+import type { z } from 'zod/v4';
+import type { AgentArtifactDescriptor } from '../artifacts/types.js';
+import type { AgentCapabilities } from '../capabilities/types.js';
+import type { AgentEvent } from '../events/types.js';
+import type { AgentError, AgentJsonValue, AgentProviderRefs } from '../foundation/types.js';
+import type { AgentRequest, AgentRequestResolution } from '../requests/types.js';
+import type { AgentSessionBinding, AgentSessionConfiguration, AgentSessionOpenInput } from '../sessions/types.js';
+import type { AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from '../turns/types.js';
+import { AgentArtifactDescriptorSchema } from './artifacts.js';
+import { AgentCapabilitiesSchema } from './capabilities.js';
+import { AgentEventSchema } from './events.js';
+import { AgentErrorSchema, AgentJsonValueSchema, AgentProviderRefsSchema } from './foundation.js';
+import { AgentRequestResolutionSchema, AgentRequestSchema } from './requests.js';
+import { AgentSessionBindingSchema, AgentSessionConfigurationSchema, AgentSessionOpenInputSchema } from './sessions.js';
+import { AgentItemSnapshotSchema, AgentTurnInputContentSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema } from './turns.js';
+type Extends<Left, Right> = [Left] extends [Right] ? true : false;
+type Assert<Value extends true> = Value;
+export type AgentProtocolSchemaTypeAssertions = readonly [
+    Assert<Extends<z.output<typeof AgentJsonValueSchema>, AgentJsonValue>>,
+    Assert<Extends<AgentJsonValue, z.output<typeof AgentJsonValueSchema>>>,
+    Assert<Extends<z.output<typeof AgentProviderRefsSchema>, AgentProviderRefs>>,
+    Assert<Extends<AgentProviderRefs, z.output<typeof AgentProviderRefsSchema>>>,
+    Assert<Extends<z.output<typeof AgentErrorSchema>, AgentError>>,
+    Assert<Extends<AgentError, z.output<typeof AgentErrorSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionBindingSchema>, AgentSessionBinding>>,
+    Assert<Extends<AgentSessionBinding, z.output<typeof AgentSessionBindingSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionConfigurationSchema>, AgentSessionConfiguration>>,
+    Assert<Extends<AgentSessionConfiguration, z.output<typeof AgentSessionConfigurationSchema>>>,
+    Assert<Extends<z.output<typeof AgentSessionOpenInputSchema>, AgentSessionOpenInput>>,
+    Assert<Extends<AgentSessionOpenInput, z.output<typeof AgentSessionOpenInputSchema>>>,
+    Assert<Extends<z.output<typeof AgentTurnInputContentSchema>, AgentTurnInputContent>>,
+    Assert<Extends<AgentTurnInputContent, z.output<typeof AgentTurnInputContentSchema>>>,
+    Assert<Extends<z.output<typeof AgentTurnRunInputSchema>, AgentTurnRunInput>>,
+    Assert<Extends<AgentTurnRunInput, z.output<typeof AgentTurnRunInputSchema>>>,
+    Assert<Extends<z.output<typeof AgentTurnInterruptionInputSchema>, AgentTurnInterruptionInput>>,
+    Assert<Extends<AgentTurnInterruptionInput, z.output<typeof AgentTurnInterruptionInputSchema>>>,
+    Assert<Extends<z.output<typeof AgentItemSnapshotSchema>, AgentItemSnapshot>>,
+    Assert<Extends<AgentItemSnapshot, z.output<typeof AgentItemSnapshotSchema>>>,
+    Assert<Extends<z.output<typeof AgentRequestSchema>, AgentRequest>>,
+    Assert<Extends<AgentRequest, z.output<typeof AgentRequestSchema>>>,
+    Assert<Extends<z.output<typeof AgentRequestResolutionSchema>, AgentRequestResolution>>,
+    Assert<Extends<AgentRequestResolution, z.output<typeof AgentRequestResolutionSchema>>>,
+    Assert<Extends<z.output<typeof AgentCapabilitiesSchema>, AgentCapabilities>>,
+    Assert<Extends<AgentCapabilities, z.output<typeof AgentCapabilitiesSchema>>>,
+    Assert<Extends<z.output<typeof AgentArtifactDescriptorSchema>, AgentArtifactDescriptor>>,
+    Assert<Extends<AgentArtifactDescriptor, z.output<typeof AgentArtifactDescriptorSchema>>>,
+    Assert<Extends<z.output<typeof AgentEventSchema>, AgentEvent>>,
+    Assert<Extends<AgentEvent, z.output<typeof AgentEventSchema>>>
+];
+export {};
+//# sourceMappingURL=typeEquality.generated.d.ts.map