@agen-ai/agent-protocol 0.1.0

package/dist/zod/events.js

@@ -0,0 +1,190 @@
+import { z } from "zod/v4";
+import { AgentArtifactDescriptorSchema } from "./artifacts.js";
+import {
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_EVENT_BYTES_LIMIT,
+  AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
+  AGENT_PROTOCOL_TEXT_MAX_LENGTH,
+  AGENT_PROTOCOL_VERSION,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/types.js";
+import { AgentRequestPortableSchema, AgentRequestSchema } from "./requests.js";
+import {
+  AgentContentStreamKindSchema,
+  AgentDiffSummarySchema,
+  AgentItemSnapshotSchema,
+  AgentPlanStepSchema,
+  AgentTurnCompletedPayloadPortableSchema,
+  AgentTurnCompletedPayloadSchema
+} from "./turns.js";
+import {
+  AgentArtifactIdSchema,
+  AgentCanonicalCodeSchema,
+  AgentCanonicalIdValueSchema,
+  AgentCanonicalNonBlankTextSchema,
+  AgentErrorContextSchema,
+  AgentErrorSchema,
+  AgentIsoDateTimeSchema,
+  AgentItemIdSchema,
+  AgentProviderRefsPortableSchema,
+  AgentProviderRefsSchema,
+  AgentRequestIdSchema,
+  AgentSessionIdSchema,
+  AgentTurnIdSchema
+} from "./foundation.js";
+const commonFields = {
+  protocolVersion: z.literal(AGENT_PROTOCOL_VERSION),
+  sessionId: AgentSessionIdSchema,
+  providerRefs: AgentProviderRefsPortableSchema.optional(),
+  occurredAt: AgentIsoDateTimeSchema
+};
+function turnEvent(type, payload) {
+  return z.object({
+    ...commonFields,
+    type: z.literal(type),
+    turnId: AgentTurnIdSchema,
+    payload
+  }).strict().readonly();
+}
+function optionallyTurnScopedEvent(type, payload) {
+  return z.object({
+    ...commonFields,
+    type: z.literal(type),
+    turnId: AgentTurnIdSchema.optional(),
+    payload
+  }).strict().readonly();
+}
+const TurnStateChangedPayloadSchema = z.object({
+  state: z.enum(["running", "waiting_for_request"]),
+  requestId: AgentRequestIdSchema.optional(),
+  message: z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH).optional()
+}).strict().readonly();
+const ProgressUpdatedPayloadSchema = z.object({
+  progressId: AgentCanonicalIdValueSchema,
+  kind: z.enum(["task", "hook", "tool", "unknown"]),
+  phase: z.enum(["started", "updated", "completed"]),
+  title: z.string().max(200).optional(),
+  message: z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH).optional(),
+  current: z.number().int().min(0).optional(),
+  total: z.number().int().min(0).optional()
+}).strict().readonly();
+const AgentEventPortableSchema = z.discriminatedUnion("type", [
+  turnEvent(
+    "turn.started",
+    z.object({ message: z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH).optional() }).strict().readonly()
+  ),
+  turnEvent("turn.state_changed", TurnStateChangedPayloadSchema),
+  turnEvent("turn.completed", AgentTurnCompletedPayloadPortableSchema),
+  turnEvent("item.started", AgentItemSnapshotSchema),
+  turnEvent("item.updated", AgentItemSnapshotSchema),
+  turnEvent("item.completed", AgentItemSnapshotSchema),
+  turnEvent(
+    "content.delta",
+    z.object({
+      itemId: AgentItemIdSchema,
+      streamKind: AgentContentStreamKindSchema,
+      delta: z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH)
+    }).strict().readonly()
+  ),
+  turnEvent(
+    "turn.plan.updated",
+    z.object({
+      explanation: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+      steps: z.array(AgentPlanStepSchema).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly()
+    }).strict().readonly()
+  ),
+  turnEvent(
+    "turn.plan.proposed",
+    z.object({
+      artifactId: AgentArtifactIdSchema,
+      requestId: AgentRequestIdSchema
+    }).strict().readonly()
+  ),
+  turnEvent("turn.diff.updated", AgentDiffSummarySchema),
+  turnEvent(
+    "request.opened",
+    z.object({ request: AgentRequestPortableSchema }).strict().readonly()
+  ),
+  turnEvent("progress.updated", ProgressUpdatedPayloadSchema),
+  optionallyTurnScopedEvent(
+    "artifact.referenced",
+    z.object({ artifact: AgentArtifactDescriptorSchema }).strict().readonly()
+  ),
+  optionallyTurnScopedEvent(
+    "runtime.warning",
+    z.object({
+      code: AgentCanonicalCodeSchema,
+      message: AgentCanonicalNonBlankTextSchema,
+      retryable: z.boolean().optional(),
+      context: AgentErrorContextSchema.optional()
+    }).strict().readonly()
+  ),
+  optionallyTurnScopedEvent(
+    "runtime.error",
+    z.object({ error: AgentErrorSchema }).strict().readonly()
+  ),
+  optionallyTurnScopedEvent(
+    "provider.diagnostic",
+    z.object({
+      code: AgentCanonicalCodeSchema,
+      message: AgentCanonicalNonBlankTextSchema,
+      context: AgentErrorContextSchema.optional()
+    }).strict().readonly()
+  )
+]);
+const AgentEventSchema = AgentEventPortableSchema.superRefine((event, context) => {
+  if (event.providerRefs !== void 0) {
+    const providerRefs = AgentProviderRefsSchema.safeParse(event.providerRefs);
+    if (!providerRefs.success) {
+      for (const issue of providerRefs.error.issues) {
+        context.addIssue({ ...issue, path: ["providerRefs", ...issue.path] });
+      }
+    }
+  }
+  if (event.type === "turn.state_changed") {
+    const waiting = event.payload.state === "waiting_for_request";
+    if (waiting !== (event.payload.requestId !== void 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["payload", "requestId"],
+        message: "Only waiting_for_request state requires a requestId."
+      });
+    }
+  }
+  if (event.type === "turn.completed") {
+    const completed = AgentTurnCompletedPayloadSchema.safeParse(event.payload);
+    if (!completed.success) {
+      for (const issue of completed.error.issues) {
+        context.addIssue({ ...issue, path: ["payload", ...issue.path] });
+      }
+    }
+  }
+  if (event.type === "request.opened") {
+    const request = AgentRequestSchema.safeParse(event.payload.request);
+    if (!request.success) {
+      for (const issue of request.error.issues) {
+        context.addIssue({
+          ...issue,
+          path: ["payload", "request", ...issue.path]
+        });
+      }
+    }
+  }
+  if (event.type === "progress.updated" && event.payload.current !== void 0 && event.payload.total !== void 0 && event.payload.current > event.payload.total) {
+    context.addIssue({
+      code: "custom",
+      path: ["payload", "current"],
+      message: "Progress current cannot exceed total."
+    });
+  }
+  if (agentProtocolSerializedJsonBytes(event) > AGENT_PROTOCOL_EVENT_BYTES_LIMIT) {
+    context.addIssue({
+      code: "custom",
+      message: `Agent events cannot exceed ${AGENT_PROTOCOL_EVENT_BYTES_LIMIT} serialized bytes.`
+    });
+  }
+});
+export {
+  AgentEventPortableSchema,
+  AgentEventSchema
+};

package/dist/zod/foundation.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod/v4';
+import { type AgentArtifactId, type AgentConfigurationRevisionId, type AgentError, type AgentInstanceId, type AgentIsoDateTime, type AgentItemId, type AgentJsonValue, type AgentProviderConversationId, type AgentProviderHistoryAnchor, type AgentProviderItemRef, type AgentProviderKey, type AgentProviderRefs, type AgentProviderRequestRef, type AgentProviderTurnRef, type AgentRequestFieldId, type AgentRequestId, type AgentSessionId, type AgentTurnId } from '../foundation/types.js';
+export declare const AgentCanonicalIdValueSchema: z.ZodString;
+export declare function createAgentCanonicalNonBlankStringSchema(maxLength: number): z.ZodString;
+export declare const AgentCanonicalNonBlankTextSchema: z.ZodString;
+export declare const AgentCanonicalCodeSchema: z.ZodString;
+export declare const AgentInstanceIdSchema: z.ZodType<AgentInstanceId, unknown, z.core.$ZodTypeInternals<AgentInstanceId, unknown>>;
+export declare const AgentSessionIdSchema: z.ZodType<AgentSessionId, unknown, z.core.$ZodTypeInternals<AgentSessionId, unknown>>;
+export declare const AgentTurnIdSchema: z.ZodType<AgentTurnId, unknown, z.core.$ZodTypeInternals<AgentTurnId, unknown>>;
+export declare const AgentItemIdSchema: z.ZodType<AgentItemId, unknown, z.core.$ZodTypeInternals<AgentItemId, unknown>>;
+export declare const AgentRequestIdSchema: z.ZodType<AgentRequestId, unknown, z.core.$ZodTypeInternals<AgentRequestId, unknown>>;
+export declare const AgentRequestFieldIdSchema: z.ZodType<AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<AgentRequestFieldId, unknown>>;
+export declare const AgentArtifactIdSchema: z.ZodType<AgentArtifactId, unknown, z.core.$ZodTypeInternals<AgentArtifactId, unknown>>;
+export declare const AgentConfigurationRevisionIdSchema: z.ZodType<AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<AgentConfigurationRevisionId, unknown>>;
+export declare const AgentProviderConversationIdSchema: z.ZodType<AgentProviderConversationId, unknown, z.core.$ZodTypeInternals<AgentProviderConversationId, unknown>>;
+export declare const AgentProviderHistoryAnchorSchema: z.ZodType<AgentProviderHistoryAnchor, unknown, z.core.$ZodTypeInternals<AgentProviderHistoryAnchor, unknown>>;
+export declare const AgentProviderTurnRefSchema: z.ZodType<AgentProviderTurnRef, unknown, z.core.$ZodTypeInternals<AgentProviderTurnRef, unknown>>;
+export declare const AgentProviderItemRefSchema: z.ZodType<AgentProviderItemRef, unknown, z.core.$ZodTypeInternals<AgentProviderItemRef, unknown>>;
+export declare const AgentProviderRequestRefSchema: z.ZodType<AgentProviderRequestRef, unknown, z.core.$ZodTypeInternals<AgentProviderRequestRef, unknown>>;
+export declare const AgentProviderKeySchema: z.ZodType<AgentProviderKey, unknown, z.core.$ZodTypeInternals<AgentProviderKey, unknown>>;
+export declare const AgentIsoDateTimeSchema: z.ZodType<AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<AgentIsoDateTime, unknown>>;
+export declare const AgentJsonObjectKeySchema: z.ZodString;
+interface ProtocolInputPreflightOptions {
+    readonly maxDepth?: number;
+    readonly maxCollectionLength?: number;
+}
+export declare function withAcyclicProtocolInput<Output>(schema: z.ZodType<Output>, options?: ProtocolInputPreflightOptions): z.ZodType<Output>;
+export declare const AgentJsonValuePortableSchema: z.ZodType<AgentJsonValue>;
+export declare const AgentJsonValueSchema: z.ZodType<AgentJsonValue>;
+export declare const AgentProviderRefsPortableSchema: z.ZodReadonly<z.ZodObject<{
+    conversationId: z.ZodOptional<z.ZodType<AgentProviderConversationId, unknown, z.core.$ZodTypeInternals<AgentProviderConversationId, unknown>>>;
+    historyAnchor: z.ZodOptional<z.ZodType<AgentProviderHistoryAnchor, unknown, z.core.$ZodTypeInternals<AgentProviderHistoryAnchor, unknown>>>;
+    turnId: z.ZodOptional<z.ZodType<AgentProviderTurnRef, unknown, z.core.$ZodTypeInternals<AgentProviderTurnRef, unknown>>>;
+    itemId: z.ZodOptional<z.ZodType<AgentProviderItemRef, unknown, z.core.$ZodTypeInternals<AgentProviderItemRef, unknown>>>;
+    requestId: z.ZodOptional<z.ZodType<AgentProviderRequestRef, unknown, z.core.$ZodTypeInternals<AgentProviderRequestRef, unknown>>>;
+}, z.core.$strict>>;
+export declare const AgentProviderRefsSchema: z.ZodType<AgentProviderRefs>;
+export declare const AgentErrorContextSchema: z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodOptional<z.ZodString>;
+    component: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare const AgentErrorSchema: z.ZodType<AgentError>;
+export {};
+//# sourceMappingURL=foundation.d.ts.map

package/dist/zod/foundation.js

@@ -0,0 +1,205 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_CODE_MAX_LENGTH,
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_ID_MAX_LENGTH,
+  AGENT_PROTOCOL_JSON_BYTES_LIMIT,
+  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  AGENT_PROTOCOL_JSON_KEY_MAX_LENGTH,
+  AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH,
+  AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH,
+  AGENT_PROTOCOL_TEXT_MAX_LENGTH,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/types.js";
+const CANONICAL_OPAQUE_STRING_PATTERN = /^(?![\s\S]*[\u0000-\u001F\u007F-\u009F])\S(?:[\s\S]*\S)?$/u;
+const CANONICAL_NON_BLANK_STRING_PATTERN = /^(?:\S|\S[\s\S]*\S)$/u;
+function canonicalOpaqueStringSchema(maxLength, message) {
+  return z.string().min(1).max(maxLength).regex(CANONICAL_OPAQUE_STRING_PATTERN, message);
+}
+const AgentCanonicalIdValueSchema = canonicalOpaqueStringSchema(
+  AGENT_PROTOCOL_ID_MAX_LENGTH,
+  "Opaque IDs must be canonical and contain no control or surrounding whitespace."
+);
+function createAgentCanonicalNonBlankStringSchema(maxLength) {
+  return z.string().min(1).max(maxLength).regex(
+    CANONICAL_NON_BLANK_STRING_PATTERN,
+    "Canonical text must contain non-whitespace content and no surrounding whitespace."
+  );
+}
+const AgentCanonicalNonBlankTextSchema = createAgentCanonicalNonBlankStringSchema(AGENT_PROTOCOL_TEXT_MAX_LENGTH);
+const AgentCanonicalCodeSchema = createAgentCanonicalNonBlankStringSchema(AGENT_PROTOCOL_CODE_MAX_LENGTH);
+const ProviderReferenceSchema = canonicalOpaqueStringSchema(
+  AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH,
+  "Provider references must be canonical and contain no control or surrounding whitespace."
+);
+function opaqueStringSchema(schema) {
+  return schema;
+}
+const AgentInstanceIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentSessionIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentTurnIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentItemIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentRequestIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentRequestFieldIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentArtifactIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentConfigurationRevisionIdSchema = opaqueStringSchema(AgentCanonicalIdValueSchema);
+const AgentProviderConversationIdSchema = opaqueStringSchema(ProviderReferenceSchema);
+const AgentProviderHistoryAnchorSchema = opaqueStringSchema(ProviderReferenceSchema);
+const AgentProviderTurnRefSchema = opaqueStringSchema(ProviderReferenceSchema);
+const AgentProviderItemRefSchema = opaqueStringSchema(ProviderReferenceSchema);
+const AgentProviderRequestRefSchema = opaqueStringSchema(ProviderReferenceSchema);
+const AgentProviderKeySchema = opaqueStringSchema(
+  z.string().min(1).max(AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH).regex(/^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/u)
+);
+const AgentIsoDateTimeSchema = opaqueStringSchema(
+  z.string().datetime({ offset: true })
+);
+const AGENT_JSON_OBJECT_KEY_PATTERN = /^(?!(?:__proto__|constructor|prototype)$)/u;
+const AgentJsonObjectKeySchema = z.string().min(1).max(AGENT_PROTOCOL_JSON_KEY_MAX_LENGTH).regex(
+  AGENT_JSON_OBJECT_KEY_PATTERN,
+  "JSON object keys must not use prototype-sensitive names."
+);
+function passesProtocolInputPreflight(input, options) {
+  const activeObjects = /* @__PURE__ */ new WeakSet();
+  const pending = [{ operation: "enter", value: input, depth: 0 }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current) break;
+    if (current.operation === "leave") {
+      activeObjects.delete(current.value);
+      continue;
+    }
+    if (options.maxDepth !== void 0 && current.depth > options.maxDepth) {
+      return false;
+    }
+    if (current.value === null || typeof current.value !== "object") continue;
+    if (activeObjects.has(current.value)) return false;
+    activeObjects.add(current.value);
+    pending.push({ operation: "leave", value: current.value });
+    if (Array.isArray(current.value) && options.maxCollectionLength !== void 0) {
+      let lengthDescriptor;
+      try {
+        lengthDescriptor = Object.getOwnPropertyDescriptor(current.value, "length");
+      } catch {
+        return false;
+      }
+      if (!lengthDescriptor || !("value" in lengthDescriptor) || typeof lengthDescriptor.value !== "number" || lengthDescriptor.value > options.maxCollectionLength) {
+        return false;
+      }
+    }
+    let propertyKeys;
+    try {
+      propertyKeys = Reflect.ownKeys(current.value);
+    } catch {
+      return false;
+    }
+    let collectionLength = 0;
+    for (const propertyKey of propertyKeys) {
+      if (typeof propertyKey === "string" && !AGENT_JSON_OBJECT_KEY_PATTERN.test(propertyKey)) {
+        return false;
+      }
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(current.value, propertyKey);
+      } catch {
+        return false;
+      }
+      if (!descriptor?.enumerable) continue;
+      if (!("value" in descriptor)) return false;
+      collectionLength += 1;
+      if (options.maxCollectionLength !== void 0 && collectionLength > options.maxCollectionLength) {
+        return false;
+      }
+      pending.push({
+        operation: "enter",
+        value: descriptor.value,
+        depth: current.depth + 1
+      });
+    }
+  }
+  return true;
+}
+function withAcyclicProtocolInput(schema, options = {}) {
+  return z.custom(
+    (input) => passesProtocolInputPreflight(input, options),
+    {
+      message: "Protocol inputs must be bounded, acyclic, and free of accessor-backed values."
+    }
+  ).pipe(schema);
+}
+const AgentJsonValuePortableSchema = z.lazy(
+  () => z.union([
+    z.string().max(AGENT_PROTOCOL_JSON_BYTES_LIMIT),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+    z.array(AgentJsonValuePortableSchema).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+    z.record(
+      AgentJsonObjectKeySchema,
+      AgentJsonValuePortableSchema
+    ).readonly()
+  ])
+);
+function addJsonByteBoundsIssue(value, context) {
+  if (agentProtocolSerializedJsonBytes(value) > AGENT_PROTOCOL_JSON_BYTES_LIMIT) {
+    context.addIssue({
+      code: "custom",
+      message: `JSON values cannot exceed ${AGENT_PROTOCOL_JSON_BYTES_LIMIT} serialized bytes.`
+    });
+  }
+}
+const AgentJsonValueSchema = withAcyclicProtocolInput(AgentJsonValuePortableSchema, {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+}).superRefine(addJsonByteBoundsIssue);
+const AgentProviderRefsPortableSchema = z.object({
+  conversationId: AgentProviderConversationIdSchema.optional(),
+  historyAnchor: AgentProviderHistoryAnchorSchema.optional(),
+  turnId: AgentProviderTurnRefSchema.optional(),
+  itemId: AgentProviderItemRefSchema.optional(),
+  requestId: AgentProviderRequestRefSchema.optional()
+}).strict().readonly();
+const AgentProviderRefsSchema = AgentProviderRefsPortableSchema.refine(
+  (value) => Object.values(value).some((item) => item !== void 0),
+  { message: "At least one provider reference is required." }
+);
+const AgentErrorContextSchema = z.object({
+  operation: createAgentCanonicalNonBlankStringSchema(160).optional(),
+  component: createAgentCanonicalNonBlankStringSchema(160).optional(),
+  status: createAgentCanonicalNonBlankStringSchema(160).optional()
+}).strict().readonly();
+const AgentErrorSchema = z.object({
+  code: AgentCanonicalCodeSchema,
+  message: AgentCanonicalNonBlankTextSchema,
+  retryable: z.boolean(),
+  context: AgentErrorContextSchema.optional()
+}).strict().readonly();
+export {
+  AgentArtifactIdSchema,
+  AgentCanonicalCodeSchema,
+  AgentCanonicalIdValueSchema,
+  AgentCanonicalNonBlankTextSchema,
+  AgentConfigurationRevisionIdSchema,
+  AgentErrorContextSchema,
+  AgentErrorSchema,
+  AgentInstanceIdSchema,
+  AgentIsoDateTimeSchema,
+  AgentItemIdSchema,
+  AgentJsonObjectKeySchema,
+  AgentJsonValuePortableSchema,
+  AgentJsonValueSchema,
+  AgentProviderConversationIdSchema,
+  AgentProviderHistoryAnchorSchema,
+  AgentProviderItemRefSchema,
+  AgentProviderKeySchema,
+  AgentProviderRefsPortableSchema,
+  AgentProviderRefsSchema,
+  AgentProviderRequestRefSchema,
+  AgentProviderTurnRefSchema,
+  AgentRequestFieldIdSchema,
+  AgentRequestIdSchema,
+  AgentSessionIdSchema,
+  AgentTurnIdSchema,
+  createAgentCanonicalNonBlankStringSchema,
+  withAcyclicProtocolInput
+};

package/dist/zod/index.d.ts

@@ -0,0 +1,9 @@
+export { AgentArtifactIdSchema, AgentConfigurationRevisionIdSchema, AgentErrorContextSchema, AgentErrorSchema, AgentInstanceIdSchema, AgentIsoDateTimeSchema, AgentItemIdSchema, AgentJsonValueSchema, AgentProviderConversationIdSchema, AgentProviderHistoryAnchorSchema, AgentProviderItemRefSchema, AgentProviderKeySchema, AgentProviderRefsSchema, AgentProviderRequestRefSchema, AgentProviderTurnRefSchema, AgentRequestFieldIdSchema, AgentRequestIdSchema, AgentSessionIdSchema, AgentTurnIdSchema, } from './foundation.js';
+export { AgentSessionBindingSchema, AgentSessionBranchSourceSchema, AgentSessionBranchInputSchema, AgentSessionConfigurationSchema, AgentSessionCreateInputSchema, AgentSessionOpenInputSchema, AgentSessionResumeInputSchema, } from './sessions.js';
+export { AgentBrowserActionDetailsSchema, AgentCollaborationToolCallDetailsSchema, AgentCommandExecutionDetailsSchema, AgentComputerActionDetailsSchema, AgentContentStreamKindSchema, AgentDiffSummarySchema, AgentDynamicToolCallDetailsSchema, AgentFileChangeDetailsSchema, AgentFileChangeSchema, AgentImageViewDetailsSchema, AgentItemSnapshotSchema, AgentMcpToolCallDetailsSchema, AgentPlanStepSchema, AgentReviewDetailsSchema, AgentTurnCompletedPayloadSchema, AgentTurnInputContentCompositionSchema, AgentTurnInputContentSchema, AgentTurnInteractionModeSchema, AgentTurnInputPartSchema, AgentTurnInterruptionInputSchema, AgentTurnRunInputSchema, AgentWebSearchDetailsSchema, } from './turns.js';
+export { AgentElicitationRequestSchema, AgentRequestResolutionSchema, AgentRequestSchema, } from './requests.js';
+export { AgentCapabilitiesSchema } from './capabilities.js';
+export { AgentArtifactDescriptorSchema } from './artifacts.js';
+export { AgentEventSchema } from './events.js';
+export type { AgentProtocolSchemaTypeAssertions } from './typeEquality.generated.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/zod/index.js

@@ -0,0 +1,118 @@
+import {
+  AgentArtifactIdSchema,
+  AgentConfigurationRevisionIdSchema,
+  AgentErrorContextSchema,
+  AgentErrorSchema,
+  AgentInstanceIdSchema,
+  AgentIsoDateTimeSchema,
+  AgentItemIdSchema,
+  AgentJsonValueSchema,
+  AgentProviderConversationIdSchema,
+  AgentProviderHistoryAnchorSchema,
+  AgentProviderItemRefSchema,
+  AgentProviderKeySchema,
+  AgentProviderRefsSchema,
+  AgentProviderRequestRefSchema,
+  AgentProviderTurnRefSchema,
+  AgentRequestFieldIdSchema,
+  AgentRequestIdSchema,
+  AgentSessionIdSchema,
+  AgentTurnIdSchema
+} from "./foundation.js";
+import {
+  AgentSessionBindingSchema,
+  AgentSessionBranchSourceSchema,
+  AgentSessionBranchInputSchema,
+  AgentSessionConfigurationSchema,
+  AgentSessionCreateInputSchema,
+  AgentSessionOpenInputSchema,
+  AgentSessionResumeInputSchema
+} from "./sessions.js";
+import {
+  AgentBrowserActionDetailsSchema,
+  AgentCollaborationToolCallDetailsSchema,
+  AgentCommandExecutionDetailsSchema,
+  AgentComputerActionDetailsSchema,
+  AgentContentStreamKindSchema,
+  AgentDiffSummarySchema,
+  AgentDynamicToolCallDetailsSchema,
+  AgentFileChangeDetailsSchema,
+  AgentFileChangeSchema,
+  AgentImageViewDetailsSchema,
+  AgentItemSnapshotSchema,
+  AgentMcpToolCallDetailsSchema,
+  AgentPlanStepSchema,
+  AgentReviewDetailsSchema,
+  AgentTurnCompletedPayloadSchema,
+  AgentTurnInputContentCompositionSchema,
+  AgentTurnInputContentSchema,
+  AgentTurnInteractionModeSchema,
+  AgentTurnInputPartSchema,
+  AgentTurnInterruptionInputSchema,
+  AgentTurnRunInputSchema,
+  AgentWebSearchDetailsSchema
+} from "./turns.js";
+import {
+  AgentElicitationRequestSchema,
+  AgentRequestResolutionSchema,
+  AgentRequestSchema
+} from "./requests.js";
+import { AgentCapabilitiesSchema } from "./capabilities.js";
+import { AgentArtifactDescriptorSchema } from "./artifacts.js";
+import { AgentEventSchema } from "./events.js";
+export {
+  AgentArtifactDescriptorSchema,
+  AgentArtifactIdSchema,
+  AgentBrowserActionDetailsSchema,
+  AgentCapabilitiesSchema,
+  AgentCollaborationToolCallDetailsSchema,
+  AgentCommandExecutionDetailsSchema,
+  AgentComputerActionDetailsSchema,
+  AgentConfigurationRevisionIdSchema,
+  AgentContentStreamKindSchema,
+  AgentDiffSummarySchema,
+  AgentDynamicToolCallDetailsSchema,
+  AgentElicitationRequestSchema,
+  AgentErrorContextSchema,
+  AgentErrorSchema,
+  AgentEventSchema,
+  AgentFileChangeDetailsSchema,
+  AgentFileChangeSchema,
+  AgentImageViewDetailsSchema,
+  AgentInstanceIdSchema,
+  AgentIsoDateTimeSchema,
+  AgentItemIdSchema,
+  AgentItemSnapshotSchema,
+  AgentJsonValueSchema,
+  AgentMcpToolCallDetailsSchema,
+  AgentPlanStepSchema,
+  AgentProviderConversationIdSchema,
+  AgentProviderHistoryAnchorSchema,
+  AgentProviderItemRefSchema,
+  AgentProviderKeySchema,
+  AgentProviderRefsSchema,
+  AgentProviderRequestRefSchema,
+  AgentProviderTurnRefSchema,
+  AgentRequestFieldIdSchema,
+  AgentRequestIdSchema,
+  AgentRequestResolutionSchema,
+  AgentRequestSchema,
+  AgentReviewDetailsSchema,
+  AgentSessionBindingSchema,
+  AgentSessionBranchInputSchema,
+  AgentSessionBranchSourceSchema,
+  AgentSessionConfigurationSchema,
+  AgentSessionCreateInputSchema,
+  AgentSessionIdSchema,
+  AgentSessionOpenInputSchema,
+  AgentSessionResumeInputSchema,
+  AgentTurnCompletedPayloadSchema,
+  AgentTurnIdSchema,
+  AgentTurnInputContentCompositionSchema,
+  AgentTurnInputContentSchema,
+  AgentTurnInputPartSchema,
+  AgentTurnInteractionModeSchema,
+  AgentTurnInterruptionInputSchema,
+  AgentTurnRunInputSchema,
+  AgentWebSearchDetailsSchema
+};