@agen-ai/agent-protocol 0.4.2 → 0.4.4

package/dist/zod/outputSchema.js

@@ -0,0 +1,177 @@
+import * as core from "zod/v4/core";
+import { AgentProtocolValidationError } from "../foundation/types.js";
+import { isOutputPropertyName, serializedStringBytes } from "../structuredOutput/boundedJson.js";
+import {
+  AGENT_OUTPUT_SCHEMA_BYTES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT,
+  AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_NODES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT
+} from "../structuredOutput/constants.js";
+import { StructuredOutputIssues } from "../structuredOutput/issues.js";
+const sourceChecksLimit = 256;
+function unsupported(message, path) {
+  const issues = new StructuredOutputIssues();
+  issues.add("unsupported_output_schema", message, path);
+  throw new AgentProtocolValidationError(issues.issues);
+}
+function finiteNumber(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return unsupported("Output schema bounds must be finite numbers.", path);
+  }
+  return value;
+}
+function emitNumber(schema, entries, path) {
+  let integer = false;
+  let minimum;
+  let maximum;
+  function numberFormat(format) {
+    if (format !== "safeint") unsupported("Only the safe-integer Zod numeric format is supported.", path);
+    integer = true;
+    minimum = Math.max(minimum ?? Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+    maximum = Math.min(maximum ?? Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+  }
+  if (schema._zod.def.coerce) unsupported("Zod coercion is unsupported; supply a value-preserving neutral output definition.", path);
+  if (schema instanceof core.$ZodNumberFormat) {
+    if (schema._zod.def.when !== void 0) unsupported("Conditional numeric checks cannot be represented by the portable output schema.", path);
+    numberFormat(schema._zod.def.format);
+  }
+  for (const check of entries) {
+    if (check._zod.def.when !== void 0) unsupported("Conditional numeric checks cannot be represented by the portable output schema.", path);
+    if (check instanceof core.$ZodCheckGreaterThan && check._zod.def.inclusive === true) {
+      minimum = Math.max(minimum ?? -Infinity, finiteNumber(check._zod.def.value, path));
+    } else if (check instanceof core.$ZodCheckLessThan && check._zod.def.inclusive === true) {
+      maximum = Math.min(maximum ?? Infinity, finiteNumber(check._zod.def.value, path));
+    } else if (check instanceof core.$ZodCheckNumberFormat) numberFormat(check._zod.def.format);
+    else unsupported("Only inclusive numeric bounds and safe-integer checks are supported.", path);
+  }
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) {
+    unsupported("Output schema numeric bounds are contradictory.", path);
+  }
+  return {
+    type: integer ? "integer" : "number",
+    ...minimum === void 0 ? {} : { minimum },
+    ...maximum === void 0 ? {} : { maximum }
+  };
+}
+function emitZodOutputSchema(root) {
+  const active = /* @__PURE__ */ new Set();
+  let nodes = 0;
+  let checks = 0;
+  let stringBytes = 0;
+  function chargeNode(depth, path) {
+    nodes += 1;
+    if (nodes > AGENT_OUTPUT_SCHEMA_NODES_LIMIT) unsupported("Expanded output schema exceeds the schema node limit.", path);
+    if (depth > AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT) unsupported("Output schema exceeds the schema depth limit.", path);
+  }
+  function chargeString(value, path) {
+    if (value.length > AGENT_OUTPUT_SCHEMA_BYTES_LIMIT) unsupported("Output schema exceeds the serialized UTF-8 byte limit.", path);
+    stringBytes += serializedStringBytes(value, AGENT_OUTPUT_SCHEMA_BYTES_LIMIT - stringBytes);
+    if (stringBytes > AGENT_OUTPUT_SCHEMA_BYTES_LIMIT) unsupported("Output schema exceeds the serialized UTF-8 byte limit.", path);
+  }
+  function emitEnum(schema, path) {
+    const values = [];
+    function append(value) {
+      if (values.length === AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT) unsupported("Output enum exceeds the entry limit.", path);
+      if (typeof value !== "string") unsupported("Only string enum and string literal values are supported.", path);
+      chargeString(value, path);
+      values.push(value);
+    }
+    if (schema instanceof core.$ZodEnum) {
+      const entries = schema._zod.def.entries;
+      for (const key in entries) {
+        if (!Object.hasOwn(entries, key)) continue;
+        const descriptor = Object.getOwnPropertyDescriptor(entries, key);
+        if (!descriptor || !("value" in descriptor)) unsupported("Zod enum values must be data properties.", path);
+        append(descriptor.value);
+      }
+    } else {
+      const entries = schema._zod.def.values;
+      if (entries.length > AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT) unsupported("Output enum exceeds the entry limit.", path);
+      for (const entry of entries) append(entry);
+    }
+    const [first, ...rest] = values;
+    if (first === void 0) unsupported("Output string enums must contain at least one value.", path);
+    return { type: "string", enum: [first, ...rest] };
+  }
+  function visit(schema, depth, path) {
+    chargeNode(depth, path);
+    if (!(schema instanceof core.$ZodType)) unsupported("Output schema children must be Zod core schemas.", path);
+    if (active.has(schema)) unsupported("Recursive Zod schemas are unsupported.", path);
+    active.add(schema);
+    try {
+      const entries = schema._zod.def.checks ?? [];
+      checks += entries.length;
+      if (checks > sourceChecksLimit) unsupported("Expanded output schema exceeds the source check limit.", path);
+      for (const entry of entries) {
+        if (!(entry instanceof core.$ZodCheck)) unsupported("Unrecognized Zod checks are unsupported.", path);
+      }
+      if (schema instanceof core.$ZodString) {
+        if (schema._zod.def.coerce) unsupported("Zod coercion is unsupported; supply a value-preserving neutral output definition.", path);
+        if (schema instanceof core.$ZodStringFormat) unsupported("Zod string formats are unsupported by the portable output schema.", path);
+        if (entries.some((check) => check instanceof core.$ZodCheckMinLength || check instanceof core.$ZodCheckMaxLength || check instanceof core.$ZodCheckLengthEquals)) {
+          unsupported("Zod string lengths count UTF-16 units. Use createAgentOutputDefinition with JSON Schema minLength/maxLength for code-point bounds, or an explicit local validation-only decoder.", path);
+        }
+        if (entries.length > 0) unsupported("Zod string checks, refinements and overwrites are unsupported.", path);
+        return { type: "string" };
+      }
+      if (schema instanceof core.$ZodNumber) return emitNumber(schema, entries, path);
+      if (schema instanceof core.$ZodBoolean) {
+        if (schema._zod.def.coerce) unsupported("Zod coercion is unsupported; supply a value-preserving neutral output definition.", path);
+        if (entries.length > 0) unsupported("Zod boolean checks are unsupported.", path);
+        return { type: "boolean" };
+      }
+      if (schema instanceof core.$ZodNull) {
+        if (entries.length > 0) unsupported("Zod null checks are unsupported.", path);
+        return { type: "null" };
+      }
+      if (schema instanceof core.$ZodEnum || schema instanceof core.$ZodLiteral) {
+        if (entries.length > 0) unsupported("Zod enum and literal checks are unsupported.", path);
+        return emitEnum(schema, path);
+      }
+      if (schema instanceof core.$ZodArray) {
+        if (entries.length > 0) {
+          unsupported("Zod array checks have opaque conditions. Use createAgentOutputDefinition with JSON Schema minItems/maxItems, or an explicit local validation-only decoder.", path);
+        }
+        return { type: "array", items: visit(schema._zod.def.element, depth + 1, [...path, "items"]) };
+      }
+      if (schema instanceof core.$ZodNullable) {
+        if (entries.length > 0) unsupported("Zod nullable checks are unsupported.", path);
+        const inner = visit(schema._zod.def.innerType, depth + 1, [...path, "anyOf", 0]);
+        if ("anyOf" in inner || inner.type === "null") unsupported("Nullable output requires one non-null, non-nullable inner schema.", path);
+        chargeNode(depth + 1, [...path, "anyOf", 1]);
+        return { anyOf: [inner, { type: "null" }] };
+      }
+      if (schema instanceof core.$ZodObject) {
+        if (entries.length > 0) unsupported("Zod object checks and refinements are unsupported.", path);
+        if (!(schema._zod.def.catchall instanceof core.$ZodNever)) unsupported("Output objects must be strict. Use z.strictObject or .strict().", path);
+        const shape = schema._zod.def.shape;
+        const properties = {};
+        const required = [];
+        for (const key in shape) {
+          if (!Object.hasOwn(shape, key)) continue;
+          const childPath = [...path, "properties", key];
+          if (required.length === AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT) unsupported("Output object exceeds the property limit.", path);
+          if (!isOutputPropertyName(key)) unsupported("Output object property names must be bounded, nonempty and safe.", path);
+          chargeString(key, childPath);
+          const descriptor = Object.getOwnPropertyDescriptor(shape, key);
+          if (!descriptor || !("value" in descriptor)) unsupported("Resolved Zod object shapes must contain data properties.", childPath);
+          const child = descriptor.value;
+          if (!(child instanceof core.$ZodType)) unsupported("Output schema children must be Zod core schemas.", childPath);
+          properties[key] = visit(child, depth + 1, childPath);
+          required.push(key);
+        }
+        return { type: "object", properties, required, additionalProperties: false };
+      }
+      return unsupported("This Zod schema type is unsupported. Use a finite strict output object without optional fields, wrappers, transforms or lazy schemas.", path);
+    } finally {
+      active.delete(schema);
+    }
+  }
+  const result = visit(root, 1, []);
+  if (!("type" in result) || result.type !== "object") unsupported("Output schema root must be a strict Zod object.", []);
+  return result;
+}
+export {
+  emitZodOutputSchema
+};

package/dist/zod/sessions.d.ts

@@ -29,6 +29,13 @@ export declare const AgentSessionConfigurationPortableSchema: z.ZodDiscriminated
 export declare const AgentSessionConfigurationSchema: z.ZodType<AgentSessionConfiguration>;
 export declare const AgentSessionCreateInputPortableSchema: z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"create">;
+    output: z.ZodOptional<z.ZodType<Readonly<{
+        kind: "json_schema";
+        schema: import("../index.js").AgentOutputSchema;
+    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+        kind: "json_schema";
+        schema: import("../index.js").AgentOutputSchema;
+    }>, unknown>>>;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
     configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"managed">;
@@ -119,6 +126,13 @@ export declare const AgentSessionBranchInputPortableSchema: z.ZodReadonly<z.ZodO
 }, z.core.$strict>>;
 declare const AgentSessionOpenInputPortableSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     operation: z.ZodLiteral<"create">;
+    output: z.ZodOptional<z.ZodType<Readonly<{
+        kind: "json_schema";
+        schema: import("../index.js").AgentOutputSchema;
+    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+        kind: "json_schema";
+        schema: import("../index.js").AgentOutputSchema;
+    }>, unknown>>>;
     sessionId: z.ZodType<import("../index.js").AgentSessionId, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentSessionId, unknown>>;
     configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         kind: z.ZodLiteral<"managed">;

package/dist/zod/sessions.js

@@ -1,6 +1,11 @@
 import { z } from "zod/v4";
+import {
+  AgentStructuredOutputRequestPortableSchema,
+  AgentStructuredOutputRequestSchema
+} from "./structuredOutput.js";
 import { compareStringsByUnicodeCodePoint } from "../foundation/ordering.js";
 import {
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
   AGENT_PROTOCOL_JSON_BYTES_LIMIT,
   agentProtocolSerializedJsonBytes
 } from "../foundation/types.js";
@@ -11,7 +16,8 @@ import {
   AgentProviderConversationIdSchema,
   AgentProviderHistoryAnchorSchema,
   AgentSessionIdSchema,
-  AgentTurnIdSchema
+  AgentTurnIdSchema,
+  withAcyclicProtocolInput
 } from "./foundation.js";
 import { AgentConfigurationValueSchema } from "./configuration.js";
 const PositiveSafeIntegerSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
@@ -73,6 +79,7 @@ const AgentSessionConfigurationSchema = AgentSessionConfigurationPortableSchema.
 });
 const AgentSessionCreateInputPortableSchema = z.object({
   operation: z.literal("create"),
+  output: AgentStructuredOutputRequestPortableSchema.optional(),
   sessionId: AgentSessionIdSchema,
   configuration: AgentSessionConfigurationPortableSchema
 }).strict().readonly();
@@ -116,10 +123,26 @@ function validateSessionOpenInput(input, context) {
     });
   }
 }
-const AgentSessionCreateInputSchema = AgentSessionCreateInputPortableSchema.superRefine(validateSessionOpenInput);
+const AgentSessionCreateInputFullSchema = AgentSessionCreateInputPortableSchema.unwrap().extend({ output: AgentStructuredOutputRequestSchema.optional() }).readonly();
+const sessionOpenPreflight = {
+  maxDepth: 64,
+  maxNodes: AGENT_PROTOCOL_JSON_BYTES_LIMIT * 2,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+};
+const AgentSessionCreateInputSchema = withAcyclicProtocolInput(
+  AgentSessionCreateInputFullSchema.superRefine(validateSessionOpenInput),
+  sessionOpenPreflight
+);
 const AgentSessionResumeInputSchema = AgentSessionResumeInputPortableSchema.superRefine(validateSessionOpenInput);
 const AgentSessionBranchInputSchema = AgentSessionBranchInputPortableSchema.superRefine(validateSessionOpenInput);
-const AgentSessionOpenInputSchema = AgentSessionOpenInputPortableSchema.superRefine(validateSessionOpenInput);
+const AgentSessionOpenInputSchema = withAcyclicProtocolInput(
+  z.discriminatedUnion("operation", [
+    AgentSessionCreateInputFullSchema,
+    AgentSessionResumeInputPortableSchema,
+    AgentSessionBranchInputPortableSchema
+  ]).superRefine(validateSessionOpenInput),
+  sessionOpenPreflight
+);
 export {
   AgentSessionBindingSchema,
   AgentSessionBranchInputPortableSchema,

package/dist/zod/structuredOutput.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod/v4';
+import type { AgentOutputSchema, AgentOutputSchemaNode, AgentStructuredOutputCapability, AgentStructuredOutputNonJsonResult, AgentStructuredOutputRequest, AgentStructuredOutputResult } from '../structuredOutput/types.js';
+export declare const AgentOutputSchemaNodePortableSchema: z.ZodType<AgentOutputSchemaNode>;
+export declare const AgentOutputSchemaPortableSchema: z.ZodType<AgentOutputSchema>;
+export declare const AgentOutputSchemaSchema: z.ZodType<AgentOutputSchema>;
+export declare const AgentStructuredOutputCapabilityPortableSchema: z.ZodType<AgentStructuredOutputCapability>;
+export declare const AgentStructuredOutputCapabilitySchema: z.ZodType<AgentStructuredOutputCapability, unknown, z.core.$ZodTypeInternals<AgentStructuredOutputCapability, unknown>>;
+export declare const AgentStructuredOutputRequestPortableSchema: z.ZodType<AgentStructuredOutputRequest>;
+export declare const AgentStructuredOutputRequestSchema: z.ZodType<AgentStructuredOutputRequest>;
+export declare const AgentStructuredOutputNonJsonResultPortableSchema: z.ZodType<AgentStructuredOutputNonJsonResult>;
+export declare const AgentStructuredOutputResultPortableSchema: z.ZodType<AgentStructuredOutputResult>;
+export declare const AgentStructuredOutputNonJsonResultSchema: z.ZodType<AgentStructuredOutputNonJsonResult>;
+export declare const AgentStructuredOutputResultSchema: z.ZodType<AgentStructuredOutputResult>;
+//# sourceMappingURL=structuredOutput.d.ts.map

package/dist/zod/structuredOutput.js

@@ -0,0 +1,209 @@
+import { z } from "zod/v4";
+import {
+  AGENT_OUTPUT_SCHEMA_BYTES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT,
+  AGENT_OUTPUT_SCHEMA_DESCRIPTION_MAX_LENGTH,
+  AGENT_OUTPUT_SCHEMA_DIALECT,
+  AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_LENGTH_BOUND_LIMIT,
+  AGENT_OUTPUT_SCHEMA_PROFILE,
+  AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH,
+  AGENT_OUTPUT_VALUE_BYTES_LIMIT,
+  AGENT_OUTPUT_VALUE_COLLECTION_LIMIT,
+  AGENT_OUTPUT_VALUE_DEPTH_LIMIT,
+  AGENT_OUTPUT_VALUE_NODES_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_ISSUE_CODE_MAX_LENGTH,
+  AGENT_STRUCTURED_OUTPUT_ISSUE_MESSAGE_MAX_LENGTH,
+  AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_BYTES_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_SEGMENTS_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_ISSUES_BYTES_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_ISSUES_LIMIT
+} from "../structuredOutput/constants.js";
+import { snapshotStructuredOutputJson } from "../structuredOutput/boundedJson.js";
+import { safeParseAgentOutputSchema } from "../structuredOutput/parsers.js";
+const encoder = new TextEncoder();
+const PropertyNameSchema = z.string().regex(new RegExp(`^(?!(?:__proto__|prototype|constructor)(?![\\s\\S]))[\\s\\S]{1,${AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH}}(?![\\s\\S])`, "u"));
+const DescriptionSchema = z.string().regex(new RegExp(`^[\\s\\S]{0,${AGENT_OUTPUT_SCHEMA_DESCRIPTION_MAX_LENGTH}}(?![\\s\\S])`, "u"));
+const LengthBoundSchema = z.number().int().min(0).max(AGENT_OUTPUT_SCHEMA_LENGTH_BOUND_LIMIT);
+const objectShape = {
+  type: z.literal("object"),
+  properties: z.record(PropertyNameSchema, z.lazy(() => AgentOutputSchemaNodePortableSchema)).readonly(),
+  required: z.array(PropertyNameSchema).max(AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT).readonly(),
+  additionalProperties: z.literal(false),
+  description: DescriptionSchema.optional()
+};
+const NullNodeSchema = z.object({
+  type: z.literal("null"),
+  description: DescriptionSchema.optional()
+}).strict().readonly();
+const NonNullNodeSchema = z.lazy(() => z.union([
+  z.object(objectShape).strict().readonly(),
+  z.object({
+    type: z.literal("array"),
+    items: AgentOutputSchemaNodePortableSchema,
+    minItems: LengthBoundSchema.optional(),
+    maxItems: LengthBoundSchema.optional(),
+    description: DescriptionSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    type: z.literal("string"),
+    enum: z.tuple([z.string()], z.string()).check(z.maxLength(AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT)).readonly().optional(),
+    minLength: LengthBoundSchema.optional(),
+    maxLength: LengthBoundSchema.optional(),
+    description: DescriptionSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    type: z.enum(["integer", "number"]),
+    minimum: z.number().finite().optional(),
+    maximum: z.number().finite().optional(),
+    description: DescriptionSchema.optional()
+  }).strict().readonly(),
+  z.object({ type: z.literal("boolean"), description: DescriptionSchema.optional() }).strict().readonly()
+]));
+const NullableNodeSchema = z.union([
+  z.object({
+    anyOf: z.tuple([NonNullNodeSchema, NullNodeSchema]).readonly(),
+    description: DescriptionSchema.optional()
+  }).strict().readonly(),
+  z.object({
+    anyOf: z.tuple([NullNodeSchema, NonNullNodeSchema]).readonly(),
+    description: DescriptionSchema.optional()
+  }).strict().transform((value) => Object.freeze({
+    anyOf: Object.freeze([value.anyOf[1], value.anyOf[0]]),
+    ...value.description === void 0 ? {} : { description: value.description }
+  }))
+]);
+const AgentOutputSchemaNodePortableSchema = z.lazy(() => z.union([
+  NonNullNodeSchema,
+  NullNodeSchema,
+  NullableNodeSchema
+]));
+const AgentOutputSchemaPortableSchema = z.object({
+  ...objectShape,
+  $schema: z.literal(AGENT_OUTPUT_SCHEMA_DIALECT).optional()
+}).strict().readonly();
+const AgentOutputSchemaSchema = z.preprocess((input, context) => {
+  const parsed = safeParseAgentOutputSchema(input);
+  if (parsed.success) return parsed.data;
+  for (const issue of parsed.issues) context.addIssue({ code: "custom", path: [...issue.path], message: issue.message });
+  return z.NEVER;
+}, AgentOutputSchemaPortableSchema);
+const AgentStructuredOutputCapabilityPortableSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("unsupported") }).strict().readonly(),
+  z.object({
+    kind: z.literal("supported"),
+    mechanism: z.literal("native"),
+    schemaProfile: z.literal(AGENT_OUTPUT_SCHEMA_PROFILE),
+    scope: z.enum(["turn", "session"]),
+    maxSchemaBytes: z.number().int().positive().max(AGENT_OUTPUT_SCHEMA_BYTES_LIMIT),
+    maxOutputBytes: z.number().int().positive().max(AGENT_OUTPUT_VALUE_BYTES_LIMIT),
+    resume: z.literal(false),
+    branch: z.literal(false)
+  }).strict().readonly()
+]);
+function boundedJsonSchema(schema, bounds) {
+  return z.preprocess((input, context) => {
+    const parsed = snapshotStructuredOutputJson(input, bounds);
+    if (parsed.success) return parsed.data;
+    for (const issue of parsed.issues) context.addIssue({ code: "custom", path: [...issue.path], message: issue.message });
+    return z.NEVER;
+  }, schema);
+}
+const AgentStructuredOutputCapabilitySchema = boundedJsonSchema(AgentStructuredOutputCapabilityPortableSchema, {
+  maxBytes: 1024,
+  maxDepth: 2,
+  maxNodes: 16,
+  maxCollectionLength: 16
+});
+const AgentStructuredOutputRequestPortableSchema = z.object({
+  kind: z.literal("json_schema"),
+  schema: AgentOutputSchemaPortableSchema
+}).strict().readonly();
+const AgentStructuredOutputRequestSchema = boundedJsonSchema(z.object({
+  kind: z.literal("json_schema"),
+  schema: AgentOutputSchemaSchema
+}).strict().readonly(), {
+  maxBytes: AGENT_OUTPUT_SCHEMA_BYTES_LIMIT + 128,
+  maxDepth: 3 * AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT + 3,
+  maxNodes: AGENT_OUTPUT_SCHEMA_BYTES_LIMIT + 4,
+  maxCollectionLength: AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT
+});
+const JsonValuePortableSchema = z.lazy(() => z.union([
+  z.string(),
+  z.number().finite(),
+  z.boolean(),
+  z.null(),
+  z.array(JsonValuePortableSchema).max(AGENT_OUTPUT_VALUE_COLLECTION_LIMIT).readonly(),
+  z.record(PropertyNameSchema, JsonValuePortableSchema).readonly()
+]));
+const JsonObjectPortableSchema = z.record(PropertyNameSchema, JsonValuePortableSchema).readonly();
+const IssuePortableSchema = z.object({
+  code: z.string().regex(new RegExp(`^[\\s\\S]{0,${AGENT_STRUCTURED_OUTPUT_ISSUE_CODE_MAX_LENGTH}}(?![\\s\\S])`, "u")),
+  message: z.string().regex(new RegExp(`^[\\s\\S]{0,${AGENT_STRUCTURED_OUTPUT_ISSUE_MESSAGE_MAX_LENGTH}}(?![\\s\\S])`, "u")),
+  path: z.array(z.union([z.string(), z.number().finite()])).max(AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_SEGMENTS_LIMIT).readonly()
+}).strict().readonly();
+const NotRequestedSchema = z.object({ kind: z.literal("not_requested") }).strict().readonly();
+const SchemaMismatchSchema = z.object({
+  kind: z.literal("unavailable"),
+  reason: z.literal("schema_mismatch"),
+  issues: z.array(IssuePortableSchema).max(AGENT_STRUCTURED_OUTPUT_ISSUES_LIMIT).readonly().optional()
+}).strict().readonly();
+const UnavailableSchema = z.object({
+  kind: z.literal("unavailable"),
+  reason: z.enum(["refused", "incomplete", "missing_output", "invalid_json", "output_limit_exceeded", "native_retries_exhausted", "provider_error"])
+}).strict().readonly();
+const AgentStructuredOutputNonJsonResultPortableSchema = z.union([
+  NotRequestedSchema,
+  SchemaMismatchSchema,
+  UnavailableSchema
+]);
+const AgentStructuredOutputResultPortableSchema = z.union([
+  AgentStructuredOutputNonJsonResultPortableSchema,
+  z.object({ kind: z.literal("json"), value: JsonObjectPortableSchema }).strict().readonly()
+]);
+const resultBounds = {
+  maxBytes: AGENT_OUTPUT_VALUE_BYTES_LIMIT + AGENT_STRUCTURED_OUTPUT_ISSUES_BYTES_LIMIT + 1024,
+  maxDepth: AGENT_OUTPUT_VALUE_DEPTH_LIMIT + 1,
+  maxNodes: AGENT_OUTPUT_VALUE_NODES_LIMIT + 128,
+  maxCollectionLength: AGENT_OUTPUT_VALUE_COLLECTION_LIMIT
+};
+function refineResult(result, context) {
+  if (result.kind === "json") {
+    const parsed = snapshotStructuredOutputJson(result.value, {
+      maxBytes: AGENT_OUTPUT_VALUE_BYTES_LIMIT,
+      maxDepth: AGENT_OUTPUT_VALUE_DEPTH_LIMIT,
+      maxNodes: AGENT_OUTPUT_VALUE_NODES_LIMIT,
+      maxCollectionLength: AGENT_OUTPUT_VALUE_COLLECTION_LIMIT
+    });
+    if (!parsed.success) {
+      for (const issue of parsed.issues) context.addIssue({ code: "custom", path: ["value", ...issue.path], message: issue.message });
+    }
+  } else if (result.kind === "unavailable" && result.reason === "schema_mismatch" && result.issues) {
+    if (encoder.encode(JSON.stringify(result.issues)).byteLength > AGENT_STRUCTURED_OUTPUT_ISSUES_BYTES_LIMIT) context.addIssue({ code: "custom", path: ["issues"], message: "Structured validation issues exceed their aggregate byte limit." });
+    for (const [index, issue] of result.issues.entries()) {
+      if (encoder.encode(JSON.stringify(issue.path)).byteLength > AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_BYTES_LIMIT) context.addIssue({ code: "custom", path: ["issues", index, "path"], message: "Structured validation issue path exceeds its serialized byte limit." });
+    }
+  }
+}
+const AgentStructuredOutputNonJsonResultSchema = boundedJsonSchema(
+  AgentStructuredOutputNonJsonResultPortableSchema,
+  resultBounds
+).superRefine(refineResult);
+const AgentStructuredOutputResultSchema = boundedJsonSchema(
+  AgentStructuredOutputResultPortableSchema,
+  resultBounds
+).superRefine(refineResult);
+export {
+  AgentOutputSchemaNodePortableSchema,
+  AgentOutputSchemaPortableSchema,
+  AgentOutputSchemaSchema,
+  AgentStructuredOutputCapabilityPortableSchema,
+  AgentStructuredOutputCapabilitySchema,
+  AgentStructuredOutputNonJsonResultPortableSchema,
+  AgentStructuredOutputNonJsonResultSchema,
+  AgentStructuredOutputRequestPortableSchema,
+  AgentStructuredOutputRequestSchema,
+  AgentStructuredOutputResultPortableSchema,
+  AgentStructuredOutputResultSchema
+};

package/dist/zod/turns.d.ts

@@ -157,6 +157,13 @@ export declare const AgentTurnInputContentCompositionSchema: z.ZodObject<{
 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>>>;
+    output: z.ZodOptional<z.ZodType<Readonly<{
+        kind: "json_schema";
+        schema: import("../index.js").AgentOutputSchema;
+    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+        kind: "json_schema";
+        schema: import("../index.js").AgentOutputSchema;
+    }>, unknown>>>;
     parts: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
@@ -239,15 +246,22 @@ export declare const AgentContentStreamKindSchema: z.ZodEnum<{
 }>;
 export declare const AgentPlanStepSchema: z.ZodType<AgentPlanStep>;
 export declare const AgentDiffSummarySchema: z.ZodType<AgentDiffSummary>;
-export declare const AgentTurnCompletedPayloadPortableSchema: z.ZodReadonly<z.ZodObject<{
+export declare const AgentTurnCompletedPayloadPortableSchema: z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"completed">;
+    structuredOutput: z.ZodType<import("../index.js").AgentStructuredOutputResult, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentStructuredOutputResult, unknown>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"failed">;
+    structuredOutput: z.ZodType<import("../index.js").AgentStructuredOutputNonJsonResult, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentStructuredOutputNonJsonResult, unknown>>;
+    reason: z.ZodOptional<z.ZodString>;
+    error: z.ZodType<import("../index.js").AgentError, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentError, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
     outcome: z.ZodEnum<{
         canceled: "canceled";
-        completed: "completed";
-        failed: "failed";
         expired: "expired";
     }>;
+    structuredOutput: z.ZodType<import("../index.js").AgentStructuredOutputNonJsonResult, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentStructuredOutputNonJsonResult, unknown>>;
     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>>;
+}, z.core.$strict>], "outcome">>;
 export declare const AgentTurnCompletedPayloadSchema: z.ZodType<AgentTurnCompletedPayload>;
 //# sourceMappingURL=turns.d.ts.map

package/dist/zod/turns.js

@@ -1,7 +1,17 @@
 import { z } from "zod/v4";
 import { AgentErrorSchema } from "./failures.js";
+import { AGENT_STRUCTURED_OUTPUT_TURN_REQUEST_BYTES_LIMIT } from "../structuredOutput/constants.js";
+import {
+  AgentStructuredOutputNonJsonResultPortableSchema,
+  AgentStructuredOutputNonJsonResultSchema,
+  AgentStructuredOutputRequestPortableSchema,
+  AgentStructuredOutputRequestSchema,
+  AgentStructuredOutputResultPortableSchema,
+  AgentStructuredOutputResultSchema
+} from "./structuredOutput.js";
 import {
   AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_EVENT_BYTES_LIMIT,
   AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
   AGENT_PROTOCOL_TEXT_MAX_LENGTH,
   AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT,
@@ -27,6 +37,7 @@ import {
   AgentIsoDateTimeSchema,
   AgentItemIdSchema,
   AgentTurnIdSchema,
+  withAcyclicProtocolInput,
   createAgentCanonicalNonBlankStringSchema
 } from "./foundation.js";
 const AGENT_PROTOCOL_INLINE_IMAGE_BASE64_MAX_LENGTH = 5e5;
@@ -139,13 +150,26 @@ const AgentTurnRunInputPortableSchema = z.object({
   turnId: AgentTurnIdSchema,
   interactionMode: AgentTurnInteractionModeSchema,
   ...AgentTurnInputContentShape,
-  deadlineAt: AgentIsoDateTimeSchema.optional()
+  deadlineAt: AgentIsoDateTimeSchema.optional(),
+  output: AgentStructuredOutputRequestPortableSchema.optional()
 }).strict().readonly();
-const AgentTurnRunInputSchema = AgentTurnInputContentRefinedSchema.safeExtend({
+const AgentTurnRunInputSchema = withAcyclicProtocolInput(AgentTurnInputContentRefinedSchema.safeExtend({
   turnId: AgentTurnIdSchema,
   interactionMode: AgentTurnInteractionModeSchema,
-  deadlineAt: AgentIsoDateTimeSchema.optional()
-}).strict().readonly();
+  deadlineAt: AgentIsoDateTimeSchema.optional(),
+  output: AgentStructuredOutputRequestSchema.optional()
+}).strict().superRefine((input, context) => {
+  if (agentProtocolSerializedJsonBytes(input) > AGENT_STRUCTURED_OUTPUT_TURN_REQUEST_BYTES_LIMIT) {
+    context.addIssue({
+      code: "custom",
+      message: `Turn run input cannot exceed ${AGENT_STRUCTURED_OUTPUT_TURN_REQUEST_BYTES_LIMIT} serialized bytes.`
+    });
+  }
+}).readonly(), {
+  maxDepth: 64,
+  maxNodes: AGENT_STRUCTURED_OUTPUT_TURN_REQUEST_BYTES_LIMIT,
+  maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
+});
 const AgentTurnInterruptionInputSchema = z.object({
   turnId: AgentTurnIdSchema,
   reason: z.enum([
@@ -413,27 +437,42 @@ const AgentDiffSummarySchema = z.object({
   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."
-    });
+function createTurnCompletedPayloadSchema(result, nonJsonResult) {
+  const reason = z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional();
+  return z.discriminatedUnion("outcome", [
+    z.object({
+      outcome: z.literal("completed"),
+      structuredOutput: result,
+      reason
+    }).strict(),
+    z.object({
+      outcome: z.literal("failed"),
+      structuredOutput: nonJsonResult,
+      reason,
+      error: AgentErrorSchema
+    }).strict(),
+    z.object({
+      outcome: z.enum(["canceled", "expired"]),
+      structuredOutput: nonJsonResult,
+      reason
+    }).strict()
+  ]).readonly();
+}
+const AgentTurnCompletedPayloadPortableSchema = createTurnCompletedPayloadSchema(
+  AgentStructuredOutputResultPortableSchema,
+  AgentStructuredOutputNonJsonResultPortableSchema
+);
+const AgentTurnCompletedPayloadSchema = withAcyclicProtocolInput(
+  createTurnCompletedPayloadSchema(
+    AgentStructuredOutputResultSchema,
+    AgentStructuredOutputNonJsonResultSchema
+  ),
+  {
+    maxDepth: 32,
+    maxNodes: AGENT_PROTOCOL_EVENT_BYTES_LIMIT,
+    maxCollectionLength: AGENT_PROTOCOL_COLLECTION_MAX_LENGTH
   }
-});
+);
 export {
   AGENT_PROTOCOL_INLINE_IMAGE_BASE64_MAX_LENGTH,
   AgentBrowserActionDetailsSchema,