@agen-ai/agent-protocol 0.1.0

package/dist/zod/requests.d.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod/v4';
+import type { AgentElicitationRequest, AgentRequest, AgentRequestResolution } from '../requests/types.js';
+export declare const AgentElicitationRequestPortableSchema: z.ZodReadonly<z.ZodObject<{
+    requestKind: z.ZodLiteral<"elicitation">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    prompt: z.ZodString;
+    fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"text">;
+        multiline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"choice">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            value: z.ZodIntersection<z.ZodString, z.ZodString>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        multiple: z.ZodBoolean;
+        allowOther: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"boolean">;
+    }, z.core.$strict>>], "kind">>>;
+    expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+}, z.core.$strict>>;
+export declare const AgentElicitationRequestSchema: z.ZodType<AgentElicitationRequest>;
+export declare const AgentRequestPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    requestKind: z.ZodLiteral<"approval">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    prompt: z.ZodString;
+    subject: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"plan">;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        artifactId: z.ZodType<import("../index.js").AgentArtifactId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentArtifactId, unknown>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodEnum<{
+            other: "other";
+            file_change: "file_change";
+            command: "command";
+            tool: "tool";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>], "kind">;
+    expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    requestKind: z.ZodLiteral<"elicitation">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    prompt: z.ZodString;
+    fields: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"text">;
+        multiline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"choice">;
+        options: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            value: z.ZodIntersection<z.ZodString, z.ZodString>;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        multiple: z.ZodBoolean;
+        allowOther: z.ZodBoolean;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"boolean">;
+    }, z.core.$strict>>], "kind">>>;
+    expiresAt: z.ZodOptional<z.ZodType<import("../index.js").AgentIsoDateTime, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentIsoDateTime, unknown>>>;
+}, z.core.$strict>>], "requestKind">;
+export declare const AgentRequestSchema: z.ZodType<AgentRequest>;
+export declare const AgentRequestResolutionPortableSchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+    requestKind: z.ZodLiteral<"approval">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    decision: z.ZodEnum<{
+        canceled: "canceled";
+        approved: "approved";
+        denied: "denied";
+    }>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    requestKind: z.ZodLiteral<"elicitation">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    disposition: z.ZodLiteral<"answered">;
+    answers: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        kind: z.ZodLiteral<"text">;
+        value: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        kind: z.ZodLiteral<"choice">;
+        values: z.ZodReadonly<z.ZodArray<z.ZodIntersection<z.ZodString, z.ZodString>>>;
+        other: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        fieldId: z.ZodType<import("../index.js").AgentRequestFieldId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestFieldId, unknown>>;
+        kind: z.ZodLiteral<"boolean">;
+        value: z.ZodBoolean;
+    }, z.core.$strict>>], "kind">>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    requestKind: z.ZodLiteral<"elicitation">;
+    requestId: z.ZodType<import("../index.js").AgentRequestId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentRequestId, unknown>>;
+    disposition: z.ZodLiteral<"canceled">;
+}, z.core.$strict>>]>;
+export declare const AgentRequestResolutionSchema: z.ZodType<AgentRequestResolution>;
+//# sourceMappingURL=requests.d.ts.map

package/dist/zod/requests.js

@@ -0,0 +1,174 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
+  AGENT_PROTOCOL_TEXT_MAX_LENGTH
+} from "../foundation/types.js";
+import {
+  AgentArtifactIdSchema,
+  AgentCanonicalIdValueSchema,
+  AgentIsoDateTimeSchema,
+  AgentRequestFieldIdSchema,
+  AgentRequestIdSchema
+} from "./foundation.js";
+const AgentApprovalRequestSchema = z.object({
+  requestKind: z.literal("approval"),
+  requestId: AgentRequestIdSchema,
+  prompt: z.string().min(1).max(AGENT_PROTOCOL_TEXT_MAX_LENGTH),
+  subject: z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("plan"),
+      title: z.string().min(1).max(200),
+      description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+      artifactId: AgentArtifactIdSchema
+    }).strict().readonly(),
+    z.object({
+      kind: z.enum(["command", "file_change", "tool", "other"]),
+      title: z.string().min(1).max(200),
+      description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional()
+    }).strict().readonly()
+  ]),
+  expiresAt: AgentIsoDateTimeSchema.optional()
+}).strict().readonly();
+const AgentRequestChoiceValueSchema = AgentCanonicalIdValueSchema.and(
+  z.string().max(160)
+);
+const AgentRequestChoiceSchema = z.object({
+  value: AgentRequestChoiceValueSchema,
+  label: z.string().min(1).max(200),
+  description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional()
+}).strict().readonly();
+const AgentElicitationFieldSchema = z.discriminatedUnion("kind", [
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    label: z.string().min(1).max(200),
+    description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+    required: z.boolean(),
+    kind: z.literal("text"),
+    multiline: z.boolean().optional()
+  }).strict().readonly(),
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    label: z.string().min(1).max(200),
+    description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+    required: z.boolean(),
+    kind: z.literal("choice"),
+    options: z.array(AgentRequestChoiceSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+    multiple: z.boolean(),
+    allowOther: z.boolean()
+  }).strict().readonly(),
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    label: z.string().min(1).max(200),
+    description: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional(),
+    required: z.boolean(),
+    kind: z.literal("boolean")
+  }).strict().readonly()
+]);
+const AgentElicitationRequestPortableSchema = z.object({
+  requestKind: z.literal("elicitation"),
+  requestId: AgentRequestIdSchema,
+  prompt: z.string().min(1).max(AGENT_PROTOCOL_TEXT_MAX_LENGTH),
+  fields: z.array(AgentElicitationFieldSchema).min(1).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+  expiresAt: AgentIsoDateTimeSchema.optional()
+}).strict().readonly();
+const AgentElicitationRequestSchema = AgentElicitationRequestPortableSchema.superRefine((request, context) => {
+  const fieldIds = /* @__PURE__ */ new Set();
+  request.fields.forEach((field, fieldIndex) => {
+    if (fieldIds.has(field.fieldId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["fields", fieldIndex, "fieldId"],
+        message: "Request field IDs must be unique."
+      });
+    }
+    fieldIds.add(field.fieldId);
+    if (field.kind !== "choice") return;
+    const optionValues = /* @__PURE__ */ new Set();
+    field.options.forEach((option, optionIndex) => {
+      if (optionValues.has(option.value)) {
+        context.addIssue({
+          code: "custom",
+          path: ["fields", fieldIndex, "options", optionIndex, "value"],
+          message: "Choice option values must be unique within a field."
+        });
+      }
+      optionValues.add(option.value);
+    });
+  });
+});
+const AgentRequestPortableSchema = z.discriminatedUnion("requestKind", [
+  AgentApprovalRequestSchema,
+  AgentElicitationRequestPortableSchema
+]);
+const AgentRequestSchema = AgentRequestPortableSchema.superRefine((request, context) => {
+  if (request.requestKind !== "elicitation") return;
+  const parsed = AgentElicitationRequestSchema.safeParse(request);
+  if (parsed.success) return;
+  for (const issue of parsed.error.issues) {
+    context.addIssue({
+      code: "custom",
+      path: issue.path,
+      message: issue.message
+    });
+  }
+});
+const AgentElicitationFreeformAnswerSchema = z.string().max(AGENT_PROTOCOL_TEXT_MAX_LENGTH).regex(/\S/u, "Free-form answers must contain non-whitespace content.");
+const AgentElicitationAnswerSchema = z.discriminatedUnion("kind", [
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    kind: z.literal("text"),
+    value: AgentElicitationFreeformAnswerSchema
+  }).strict().readonly(),
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    kind: z.literal("choice"),
+    values: z.array(AgentRequestChoiceValueSchema).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly(),
+    other: AgentElicitationFreeformAnswerSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    fieldId: AgentRequestFieldIdSchema,
+    kind: z.literal("boolean"),
+    value: z.boolean()
+  }).strict().readonly()
+]);
+const AgentRequestResolutionPortableSchema = z.union([
+  z.object({
+    requestKind: z.literal("approval"),
+    requestId: AgentRequestIdSchema,
+    decision: z.enum(["approved", "denied", "canceled"])
+  }).strict().readonly(),
+  z.object({
+    requestKind: z.literal("elicitation"),
+    requestId: AgentRequestIdSchema,
+    disposition: z.literal("answered"),
+    answers: z.array(AgentElicitationAnswerSchema).max(AGENT_PROTOCOL_COLLECTION_MAX_LENGTH).readonly()
+  }).strict().readonly(),
+  z.object({
+    requestKind: z.literal("elicitation"),
+    requestId: AgentRequestIdSchema,
+    disposition: z.literal("canceled")
+  }).strict().readonly()
+]);
+const AgentRequestResolutionSchema = AgentRequestResolutionPortableSchema.superRefine((resolution, context) => {
+  if (resolution.requestKind !== "elicitation" || resolution.disposition !== "answered") {
+    return;
+  }
+  resolution.answers.forEach((answer, answerIndex) => {
+    if (answer.kind === "choice" && new Set(answer.values).size !== answer.values.length) {
+      context.addIssue({
+        code: "custom",
+        path: ["answers", answerIndex, "values"],
+        message: "Choice answers cannot select the same option more than once."
+      });
+    }
+  });
+});
+export {
+  AgentElicitationRequestPortableSchema,
+  AgentElicitationRequestSchema,
+  AgentRequestPortableSchema,
+  AgentRequestResolutionPortableSchema,
+  AgentRequestResolutionSchema,
+  AgentRequestSchema
+};

package/dist/zod/sessions.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod/v4';
+import type { AgentSessionBinding, AgentSessionBranchSource, AgentSessionBranchInput, AgentSessionConfiguration, AgentSessionCreateInput, AgentSessionOpenInput, AgentSessionResumeInput } from '../sessions/types.js';
+export declare const AgentSessionBindingSchema: z.ZodType<AgentSessionBinding>;
+export declare const AgentSessionConfigurationPortableSchema: z.ZodReadonly<z.ZodObject<{
+    revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+    values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+}, z.core.$strict>>;
+export declare const AgentSessionConfigurationSchema: z.ZodType<AgentSessionConfiguration>;
+export declare const AgentSessionCreateInputPortableSchema: z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodLiteral<"create">;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    configuration: z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const AgentSessionResumeInputPortableSchema: z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodLiteral<"resume">;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    binding: z.ZodType<AgentSessionBinding, unknown, z.core.$ZodTypeInternals<AgentSessionBinding, unknown>>;
+    configuration: z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const AgentSessionBranchSourceSchema: z.ZodType<AgentSessionBranchSource>;
+export declare const AgentSessionBranchInputPortableSchema: z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodLiteral<"branch">;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    source: z.ZodType<AgentSessionBranchSource, unknown, z.core.$ZodTypeInternals<AgentSessionBranchSource, unknown>>;
+    configuration: z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+declare const AgentSessionOpenInputPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodLiteral<"create">;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    configuration: z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodLiteral<"resume">;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    binding: z.ZodType<AgentSessionBinding, unknown, z.core.$ZodTypeInternals<AgentSessionBinding, unknown>>;
+    configuration: z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    operation: z.ZodLiteral<"branch">;
+    sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
+    source: z.ZodType<AgentSessionBranchSource, unknown, z.core.$ZodTypeInternals<AgentSessionBranchSource, unknown>>;
+    configuration: z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodType<import("../index.js").AgentConfigurationRevisionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentConfigurationRevisionId, unknown>>;
+        values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").AgentJsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentJsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>], "operation">;
+export declare const AgentSessionCreateInputSchema: z.ZodType<AgentSessionCreateInput>;
+export declare const AgentSessionResumeInputSchema: z.ZodType<AgentSessionResumeInput>;
+export declare const AgentSessionBranchInputSchema: z.ZodType<AgentSessionBranchInput>;
+export declare const AgentSessionOpenInputSchema: z.ZodType<AgentSessionOpenInput>;
+export { AgentSessionOpenInputPortableSchema };
+//# sourceMappingURL=sessions.d.ts.map

package/dist/zod/sessions.js

@@ -0,0 +1,124 @@
+import { z } from "zod/v4";
+import {
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_JSON_BYTES_LIMIT,
+  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  agentProtocolSerializedJsonBytes
+} from "../foundation/types.js";
+import {
+  AgentConfigurationRevisionIdSchema,
+  AgentJsonObjectKeySchema,
+  AgentJsonValuePortableSchema,
+  AgentProviderConversationIdSchema,
+  AgentProviderHistoryAnchorSchema,
+  AgentSessionIdSchema,
+  AgentTurnIdSchema,
+  withAcyclicProtocolInput
+} from "./foundation.js";
+const SESSION_CONFIGURATION_JSON_DEPTH_OFFSET = 2;
+const SESSION_OPEN_JSON_DEPTH_OFFSET = 3;
+const AgentSessionBindingSchema = z.object({
+  conversationId: AgentProviderConversationIdSchema,
+  historyAnchor: AgentProviderHistoryAnchorSchema.optional()
+}).strict().readonly();
+const AgentSessionConfigurationPortableSchema = z.object({
+  revision: AgentConfigurationRevisionIdSchema,
+  values: z.record(
+    AgentJsonObjectKeySchema,
+    AgentJsonValuePortableSchema
+  ).readonly()
+}).strict().readonly();
+const AgentSessionConfigurationSchema = withAcyclicProtocolInput(AgentSessionConfigurationPortableSchema, {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_CONFIGURATION_JSON_DEPTH_OFFSET,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+}).superRefine((configuration, context) => {
+  if (Object.keys(configuration.values).length > AGENT_PROTOCOL_COLLECTION_MAX_LENGTH) {
+    context.addIssue({
+      code: "custom",
+      path: ["values"],
+      message: `Session configuration cannot exceed ${AGENT_PROTOCOL_COLLECTION_MAX_LENGTH} entries.`
+    });
+  }
+  if (agentProtocolSerializedJsonBytes(configuration.values) > AGENT_PROTOCOL_JSON_BYTES_LIMIT) {
+    context.addIssue({
+      code: "custom",
+      path: ["values"],
+      message: `Session configuration cannot exceed ${AGENT_PROTOCOL_JSON_BYTES_LIMIT} serialized bytes.`
+    });
+  }
+});
+const AgentSessionCreateInputPortableSchema = z.object({
+  operation: z.literal("create"),
+  sessionId: AgentSessionIdSchema,
+  configuration: AgentSessionConfigurationPortableSchema
+}).strict().readonly();
+const AgentSessionResumeInputPortableSchema = z.object({
+  operation: z.literal("resume"),
+  sessionId: AgentSessionIdSchema,
+  binding: AgentSessionBindingSchema,
+  configuration: AgentSessionConfigurationPortableSchema
+}).strict().readonly();
+const AgentSessionBranchSourceSchema = z.object({
+  sessionId: AgentSessionIdSchema,
+  binding: AgentSessionBindingSchema,
+  throughTurn: z.object({
+    turnId: AgentTurnIdSchema,
+    historyAnchor: AgentProviderHistoryAnchorSchema
+  }).strict().readonly()
+}).strict().readonly();
+const AgentSessionBranchInputPortableSchema = z.object({
+  operation: z.literal("branch"),
+  sessionId: AgentSessionIdSchema,
+  source: AgentSessionBranchSourceSchema,
+  configuration: AgentSessionConfigurationPortableSchema
+}).strict().readonly();
+const AgentSessionOpenInputPortableSchema = z.discriminatedUnion("operation", [
+  AgentSessionCreateInputPortableSchema,
+  AgentSessionResumeInputPortableSchema,
+  AgentSessionBranchInputPortableSchema
+]);
+function validateSessionOpenInput(input, context) {
+  const parsed = AgentSessionConfigurationSchema.safeParse(input.configuration);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      context.addIssue({ ...issue, path: ["configuration", ...issue.path] });
+    }
+  }
+  if (input.operation === "branch" && input.sessionId === input.source.sessionId) {
+    context.addIssue({
+      code: "custom",
+      path: ["sessionId"],
+      message: "Branch target sessionId must differ from its source sessionId."
+    });
+  }
+}
+const AgentSessionCreateInputSchema = withAcyclicProtocolInput(AgentSessionCreateInputPortableSchema, {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+}).superRefine(validateSessionOpenInput);
+const AgentSessionResumeInputSchema = withAcyclicProtocolInput(AgentSessionResumeInputPortableSchema, {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+}).superRefine(validateSessionOpenInput);
+const AgentSessionBranchInputSchema = withAcyclicProtocolInput(AgentSessionBranchInputPortableSchema, {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+}).superRefine(validateSessionOpenInput);
+const AgentSessionOpenInputSchema = withAcyclicProtocolInput(AgentSessionOpenInputPortableSchema, {
+  maxDepth: AGENT_PROTOCOL_JSON_DEPTH_LIMIT + SESSION_OPEN_JSON_DEPTH_OFFSET,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+}).superRefine(validateSessionOpenInput);
+export {
+  AgentSessionBindingSchema,
+  AgentSessionBranchInputPortableSchema,
+  AgentSessionBranchInputSchema,
+  AgentSessionBranchSourceSchema,
+  AgentSessionConfigurationPortableSchema,
+  AgentSessionConfigurationSchema,
+  AgentSessionCreateInputPortableSchema,
+  AgentSessionCreateInputSchema,
+  AgentSessionOpenInputPortableSchema,
+  AgentSessionOpenInputSchema,
+  AgentSessionResumeInputPortableSchema,
+  AgentSessionResumeInputSchema
+};