@agen-ai/agent-protocol 0.4.2 → 0.4.4

package/dist/structuredOutput/schemaAdmission.js

@@ -0,0 +1,247 @@
+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_NODES_LIMIT,
+  AGENT_OUTPUT_VALUE_BYTES_LIMIT,
+  AGENT_OUTPUT_VALUE_COLLECTION_LIMIT,
+  AGENT_OUTPUT_VALUE_DEPTH_LIMIT,
+  AGENT_OUTPUT_VALUE_NODES_LIMIT
+} from "./constants.js";
+import { codePointLength, isJsonObject, serializedStringBytes } from "./boundedJson.js";
+class StructuredOutputSchemaError extends Error {
+  constructor(message, path) {
+    super(message);
+    this.message = message;
+    this.path = path;
+  }
+}
+function invalid(message, path) {
+  throw new StructuredOutputSchemaError(message, path);
+}
+function object(value, path) {
+  if (value === void 0 || !isJsonObject(value)) invalid("A schema node must be a plain object.", path);
+  return value;
+}
+function keys(value, allowed, path) {
+  if (Object.keys(value).some((key) => !allowed.includes(key))) invalid("Schema contains an unsupported keyword.", path);
+}
+function description(value, path) {
+  if (!Object.hasOwn(value, "description")) return {};
+  if (typeof value.description !== "string" || codePointLength(value.description) > AGENT_OUTPUT_SCHEMA_DESCRIPTION_MAX_LENGTH) {
+    invalid("Schema descriptions must be strings within the code-point limit.", [...path, "description"]);
+  }
+  return { description: value.description };
+}
+function bound(value, key, path, integer) {
+  if (!Object.hasOwn(value, key)) return void 0;
+  const candidate = value[key];
+  if (typeof candidate !== "number" || !Number.isFinite(candidate) || integer && (!Number.isSafeInteger(candidate) || candidate < 0 || candidate > AGENT_OUTPUT_SCHEMA_LENGTH_BOUND_LIMIT)) {
+    invalid(integer ? "Length bounds must be nonnegative safe integers within the profile ceiling." : "Numeric bounds must be finite numbers.", [...path, key]);
+  }
+  return candidate;
+}
+function ordered(minimum, maximum, path) {
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) invalid("Schema minimum must not exceed maximum.", path);
+}
+function isNullSchema(value) {
+  return "type" in value && value.type === "null";
+}
+function isNonNullSchema(value) {
+  return "type" in value && value.type !== "null";
+}
+function admitOutputSchema(input, maxOutputBytes = AGENT_OUTPUT_VALUE_BYTES_LIMIT) {
+  let nodes = 0;
+  function node(value, depth, path, root = false) {
+    nodes += 1;
+    if (nodes > AGENT_OUTPUT_SCHEMA_NODES_LIMIT || depth > AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT) {
+      invalid("Schema exceeds the node or depth limit.", path);
+    }
+    const source = object(value, path);
+    const annotation = description(source, path);
+    if (Object.hasOwn(source, "anyOf")) {
+      keys(source, ["anyOf", "description"], path);
+      if (root) invalid("The output schema root must be an object.", path);
+      const branches = source.anyOf;
+      if (!Array.isArray(branches) || branches.length !== 2) invalid("Nullable schemas require exactly one non-null and one null branch.", [...path, "anyOf"]);
+      const firstValue = branches[0];
+      const secondValue = branches[1];
+      if (firstValue === void 0 || secondValue === void 0) invalid("Nullable branches must be present.", [...path, "anyOf"]);
+      const first = node(firstValue, depth + 1, [...path, "anyOf", 0]);
+      const second = node(secondValue, depth + 1, [...path, "anyOf", 1]);
+      if (isNonNullSchema(first) && isNullSchema(second)) return Object.freeze({ anyOf: Object.freeze([first, second]), ...annotation });
+      if (isNullSchema(first) && isNonNullSchema(second)) return Object.freeze({ anyOf: Object.freeze([second, first]), ...annotation });
+      invalid("Nullable schemas require one non-null branch and prohibit nested nullable wrappers.", [...path, "anyOf"]);
+    }
+    if (root && source.type !== "object") invalid("The output schema root must be an object.", path);
+    const dialect = root ? ["$schema"] : [];
+    if (root && Object.hasOwn(source, "$schema") && source.$schema !== AGENT_OUTPUT_SCHEMA_DIALECT) invalid("Only JSON Schema draft 2020-12 is supported.", [...path, "$schema"]);
+    switch (source.type) {
+      case "object": {
+        keys(source, ["type", "properties", "required", "additionalProperties", "description", ...dialect], path);
+        const properties = object(source.properties, [...path, "properties"]);
+        const required = source.required;
+        if (source.additionalProperties !== false || !Array.isArray(required)) invalid("Object schemas must be closed and explicitly require every property.", path);
+        const names = Object.keys(properties);
+        const requiredNames = /* @__PURE__ */ new Set();
+        for (const candidate of required) {
+          if (typeof candidate !== "string" || requiredNames.has(candidate) || !Object.hasOwn(properties, candidate)) {
+            invalid("Required keys must name every property exactly once.", [...path, "required"]);
+          }
+          requiredNames.add(candidate);
+        }
+        if (requiredNames.size !== names.length) invalid("Required keys must name every property exactly once.", [...path, "required"]);
+        const parsed = {};
+        for (const name of names) {
+          const child = properties[name];
+          if (child === void 0) invalid("Object properties require schema nodes.", [...path, "properties", name]);
+          parsed[name] = node(child, depth + 1, [...path, "properties", name]);
+        }
+        return Object.freeze({ type: "object", properties: Object.freeze(parsed), required: Object.freeze(names), additionalProperties: false, ...annotation });
+      }
+      case "array": {
+        keys(source, ["type", "items", "minItems", "maxItems", "description"], path);
+        const minItems = bound(source, "minItems", path, true);
+        const maxItems = bound(source, "maxItems", path, true);
+        ordered(minItems, maxItems, path);
+        if (minItems !== void 0 && minItems > AGENT_OUTPUT_VALUE_COLLECTION_LIMIT) invalid("Array minimum cannot exceed the value collection limit.", [...path, "minItems"]);
+        const item = source.items;
+        if (item === void 0) invalid("Array schemas require one homogeneous item schema.", [...path, "items"]);
+        return Object.freeze({
+          type: "array",
+          items: node(item, depth + 1, [...path, "items"]),
+          ...minItems === void 0 ? {} : { minItems },
+          ...maxItems === void 0 ? {} : { maxItems },
+          ...annotation
+        });
+      }
+      case "string": {
+        keys(source, ["type", "enum", "minLength", "maxLength", "description"], path);
+        const minLength = bound(source, "minLength", path, true);
+        const maxLength = bound(source, "maxLength", path, true);
+        ordered(minLength, maxLength, path);
+        let values;
+        if (Object.hasOwn(source, "enum")) {
+          const candidates = source.enum;
+          if (!Array.isArray(candidates) || candidates.length === 0 || candidates.length > AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT) invalid("String enums must be nonempty and bounded.", [...path, "enum"]);
+          const strings = [];
+          const unique = /* @__PURE__ */ new Set();
+          for (const candidate of candidates) {
+            if (typeof candidate !== "string" || unique.has(candidate)) invalid("String enums require unique strings.", [...path, "enum"]);
+            const length = codePointLength(candidate);
+            if (minLength !== void 0 && length < minLength || maxLength !== void 0 && length > maxLength) invalid("Every enum value must satisfy the string length bounds.", [...path, "enum"]);
+            unique.add(candidate);
+            strings.push(candidate);
+          }
+          const [first, ...rest] = strings;
+          if (first === void 0) invalid("String enums cannot be empty.", [...path, "enum"]);
+          values = Object.freeze([first, ...rest]);
+        }
+        return Object.freeze({
+          type: "string",
+          ...values === void 0 ? {} : { enum: values },
+          ...minLength === void 0 ? {} : { minLength },
+          ...maxLength === void 0 ? {} : { maxLength },
+          ...annotation
+        });
+      }
+      case "number":
+      case "integer": {
+        keys(source, ["type", "minimum", "maximum", "description"], path);
+        const minimum2 = bound(source, "minimum", path, false);
+        const maximum = bound(source, "maximum", path, false);
+        ordered(minimum2, maximum, path);
+        if (source.type === "integer" && minimum2 !== void 0 && maximum !== void 0 && Math.ceil(minimum2) > Math.floor(maximum)) invalid("Integer bounds admit no integer value.", path);
+        return Object.freeze({ type: source.type, ...minimum2 === void 0 ? {} : { minimum: minimum2 }, ...maximum === void 0 ? {} : { maximum }, ...annotation });
+      }
+      case "boolean":
+      case "null":
+        keys(source, ["type", "description"], path);
+        return Object.freeze({ type: source.type, ...annotation });
+      default:
+        invalid("Schema node type is unsupported.", [...path, "type"]);
+    }
+  }
+  const schema = node(input, 1, [], true);
+  if (!("type" in schema) || schema.type !== "object") invalid("The output schema root must be an object.", []);
+  const minimum = minimumValueSize(schema);
+  if (minimum.bytes > AGENT_OUTPUT_VALUE_BYTES_LIMIT || minimum.nodes > AGENT_OUTPUT_VALUE_NODES_LIMIT || minimum.depth > AGENT_OUTPUT_VALUE_DEPTH_LIMIT) {
+    invalid("Schema cannot produce a value within the profile capacity limits.", []);
+  }
+  if (minimum.bytes > maxOutputBytes) {
+    invalid("Schema cannot produce a value within the configured output byte limit.", []);
+  }
+  return schema;
+}
+function decimalExponent(value) {
+  const notation = value.toExponential();
+  return Number(notation.slice(notation.indexOf("e") + 1));
+}
+function minimumNumberBytes(schema) {
+  const lower = schema.minimum ?? -Number.MAX_VALUE;
+  const upper = schema.maximum ?? Number.MAX_VALUE;
+  const minimum = schema.type === "integer" ? Math.ceil(lower) : lower;
+  const maximum = schema.type === "integer" ? Math.floor(upper) : upper;
+  if (minimum === maximum) return JSON.stringify(minimum).length;
+  if (minimum <= 0 && maximum >= 0) return 1;
+  const negative = maximum < 0;
+  const absoluteMinimum = negative ? -maximum : minimum;
+  const absoluteMaximum = negative ? -minimum : maximum;
+  let bytes = Infinity;
+  const maximumExponent = decimalExponent(absoluteMaximum);
+  for (let exponent = decimalExponent(absoluteMinimum); exponent <= maximumExponent; exponent += 1) {
+    let bandBytes;
+    if (exponent < -6 || exponent >= 21) {
+      bandBytes = 3 + String(Math.abs(exponent)).length;
+    } else if (exponent < 0) {
+      bandBytes = 2 - exponent;
+    } else {
+      const firstInteger = Math.ceil(Math.max(absoluteMinimum, Number(`1e${exponent}`)));
+      const containsInteger = firstInteger <= absoluteMaximum && firstInteger < Number(`1e${exponent + 1}`);
+      bandBytes = exponent + 1 + (containsInteger ? 0 : 2);
+    }
+    bytes = Math.min(bytes, bandBytes);
+  }
+  return bytes + (negative ? 1 : 0);
+}
+function minimumValueSize(schema) {
+  if ("anyOf" in schema) {
+    const nonNull = minimumValueSize(schema.anyOf[0]);
+    return { bytes: Math.min(4, nonNull.bytes), nodes: 1, depth: 1 };
+  }
+  switch (schema.type) {
+    case "object": {
+      const entries = Object.entries(schema.properties);
+      let bytes = 2 + Math.max(0, entries.length - 1);
+      let nodes = 1;
+      let depth = 1;
+      for (const [name, child] of entries) {
+        const minimum = minimumValueSize(child);
+        bytes += serializedStringBytes(name, AGENT_OUTPUT_SCHEMA_BYTES_LIMIT) + 1 + minimum.bytes;
+        nodes += minimum.nodes;
+        depth = Math.max(depth, 1 + minimum.depth);
+      }
+      return { bytes, nodes, depth };
+    }
+    case "array": {
+      const count = schema.minItems ?? 0;
+      const child = minimumValueSize(schema.items);
+      return { bytes: 2 + Math.max(0, count - 1) + count * child.bytes, nodes: 1 + count * child.nodes, depth: count === 0 ? 1 : 1 + child.depth };
+    }
+    case "string":
+      return { bytes: schema.enum ? Math.min(...schema.enum.map((value) => serializedStringBytes(value, AGENT_OUTPUT_SCHEMA_BYTES_LIMIT))) : 2 + (schema.minLength ?? 0), nodes: 1, depth: 1 };
+    case "boolean":
+    case "null":
+      return { bytes: 4, nodes: 1, depth: 1 };
+    case "integer":
+    case "number":
+      return { bytes: minimumNumberBytes(schema), nodes: 1, depth: 1 };
+  }
+}
+export {
+  StructuredOutputSchemaError,
+  admitOutputSchema
+};

package/dist/structuredOutput/types.d.ts

@@ -0,0 +1,75 @@
+import type { AgentJsonObject, ValidationIssue } from '../foundation/types.js';
+import type { AGENT_OUTPUT_SCHEMA_DIALECT, AGENT_OUTPUT_SCHEMA_PROFILE } from './constants.js';
+interface AgentOutputSchemaDescription {
+    readonly description?: string;
+}
+export interface AgentOutputObjectSchema extends AgentOutputSchemaDescription {
+    readonly type: 'object';
+    readonly properties: Readonly<Record<string, AgentOutputSchemaNode>>;
+    readonly required: readonly string[];
+    readonly additionalProperties: false;
+}
+export interface AgentOutputSchema extends AgentOutputObjectSchema {
+    readonly $schema?: typeof AGENT_OUTPUT_SCHEMA_DIALECT;
+}
+export interface AgentOutputArraySchema extends AgentOutputSchemaDescription {
+    readonly type: 'array';
+    readonly items: AgentOutputSchemaNode;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+}
+export interface AgentOutputStringSchema extends AgentOutputSchemaDescription {
+    readonly type: 'string';
+    readonly enum?: readonly [string, ...string[]];
+    readonly minLength?: number;
+    readonly maxLength?: number;
+}
+export interface AgentOutputNumberSchema extends AgentOutputSchemaDescription {
+    readonly type: 'integer' | 'number';
+    readonly minimum?: number;
+    readonly maximum?: number;
+}
+export interface AgentOutputBooleanSchema extends AgentOutputSchemaDescription {
+    readonly type: 'boolean';
+}
+export interface AgentOutputNullSchema extends AgentOutputSchemaDescription {
+    readonly type: 'null';
+}
+export type AgentOutputNonNullSchema = AgentOutputObjectSchema | AgentOutputArraySchema | AgentOutputStringSchema | AgentOutputNumberSchema | AgentOutputBooleanSchema;
+export interface AgentOutputNullableSchema extends AgentOutputSchemaDescription {
+    readonly anyOf: readonly [AgentOutputNonNullSchema, AgentOutputNullSchema];
+}
+export type AgentOutputSchemaNode = AgentOutputNonNullSchema | AgentOutputNullSchema | AgentOutputNullableSchema;
+export type AgentStructuredOutputCapability = Readonly<{
+    kind: 'unsupported';
+}> | Readonly<{
+    kind: 'supported';
+    mechanism: 'native';
+    schemaProfile: typeof AGENT_OUTPUT_SCHEMA_PROFILE;
+    scope: 'turn' | 'session';
+    maxSchemaBytes: number;
+    maxOutputBytes: number;
+    resume: false;
+    branch: false;
+}>;
+export type AgentStructuredOutputRequest = Readonly<{
+    kind: 'json_schema';
+    schema: AgentOutputSchema;
+}>;
+export type AgentStructuredOutputUnavailableReason = 'refused' | 'incomplete' | 'missing_output' | 'invalid_json' | 'schema_mismatch' | 'output_limit_exceeded' | 'native_retries_exhausted' | 'provider_error';
+export type AgentStructuredOutputNonJsonResult = Readonly<{
+    kind: 'not_requested';
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: 'schema_mismatch';
+    issues?: readonly ValidationIssue[];
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: Exclude<AgentStructuredOutputUnavailableReason, 'schema_mismatch'>;
+}>;
+export type AgentStructuredOutputResult = AgentStructuredOutputNonJsonResult | Readonly<{
+    kind: 'json';
+    value: AgentJsonObject;
+}>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/structuredOutput/values.d.ts

@@ -0,0 +1,5 @@
+import type { AgentJsonObject, AgentProtocolParseResult } from '../foundation/types.js';
+import { type AgentOutputLimits } from './parsers.js';
+import type { AgentOutputSchema } from './types.js';
+export declare function validateAgentOutputValue(schema: AgentOutputSchema, candidate: unknown, limits?: AgentOutputLimits): AgentProtocolParseResult<AgentJsonObject>;
+//# sourceMappingURL=values.d.ts.map

package/dist/structuredOutput/values.js

@@ -0,0 +1,89 @@
+import { codePointLength, isJsonObject, snapshotStructuredOutputJson } from "./boundedJson.js";
+import {
+  AGENT_OUTPUT_VALUE_COLLECTION_LIMIT,
+  AGENT_OUTPUT_VALUE_DEPTH_LIMIT,
+  AGENT_OUTPUT_VALUE_NODES_LIMIT
+} from "./constants.js";
+import { StructuredOutputIssues } from "./issues.js";
+import { parseOutputByteLimit, trustedOutputSchema } from "./parsers.js";
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function validateAgentOutputValue(schema, candidate, limits) {
+  const parsedLimit = parseOutputByteLimit(limits);
+  if (!parsedLimit.success) return parsedLimit;
+  const admitted = trustedOutputSchema(schema);
+  if (!admitted.success) return admitted;
+  const snapshot = snapshotStructuredOutputJson(candidate, {
+    maxBytes: parsedLimit.data,
+    maxDepth: AGENT_OUTPUT_VALUE_DEPTH_LIMIT,
+    maxNodes: AGENT_OUTPUT_VALUE_NODES_LIMIT,
+    maxCollectionLength: AGENT_OUTPUT_VALUE_COLLECTION_LIMIT
+  });
+  if (!snapshot.success) return snapshot;
+  const issues = new StructuredOutputIssues();
+  function matches(node, value, path) {
+    if (issues.full) return;
+    if ("anyOf" in node) {
+      if (value !== null) matches(node.anyOf[0], value, path);
+      return;
+    }
+    switch (node.type) {
+      case "object":
+        if (!isJsonObject(value)) break;
+        for (const key of Object.keys(value)) {
+          if (!Object.hasOwn(node.properties, key)) issues.add("schema_mismatch", "Object contains an undeclared property.", [...path, key]);
+        }
+        for (const [key, childSchema] of Object.entries(node.properties)) {
+          const child = value[key];
+          if (child === void 0) issues.add("schema_mismatch", "Object is missing a required property.", [...path, key]);
+          else matches(childSchema, child, [...path, key]);
+          if (issues.full) return;
+        }
+        return;
+      case "array":
+        if (!isJsonArray(value)) break;
+        if (node.minItems !== void 0 && value.length < node.minItems || node.maxItems !== void 0 && value.length > node.maxItems) {
+          issues.add("schema_mismatch", "Array length is outside the declared bounds.", path);
+        }
+        for (const [index, child] of value.entries()) {
+          matches(node.items, child, [...path, index]);
+          if (issues.full) return;
+        }
+        return;
+      case "string": {
+        if (typeof value !== "string") break;
+        const length = codePointLength(value);
+        if (node.minLength !== void 0 && length < node.minLength || node.maxLength !== void 0 && length > node.maxLength) {
+          issues.add("schema_mismatch", "String code-point length is outside the declared bounds.", path);
+        }
+        if (node.enum && !node.enum.includes(value)) issues.add("schema_mismatch", "String is not one of the declared enum values.", path);
+        return;
+      }
+      case "integer":
+      case "number":
+        if (typeof value !== "number" || node.type === "integer" && !Number.isInteger(value)) break;
+        if (node.minimum !== void 0 && value < node.minimum || node.maximum !== void 0 && value > node.maximum) {
+          issues.add("schema_mismatch", "Number is outside the declared inclusive bounds.", path);
+        }
+        return;
+      case "boolean":
+        if (typeof value === "boolean") return;
+        break;
+      case "null":
+        if (value === null) return;
+        break;
+    }
+    issues.add("schema_mismatch", "Value does not have the declared JSON type.", path);
+  }
+  matches(admitted.data, snapshot.data, []);
+  if (issues.issues.length > 0) return { success: false, issues: issues.issues };
+  if (!isJsonObject(snapshot.data)) {
+    issues.add("schema_mismatch", "Output must be a JSON object.");
+    return { success: false, issues: issues.issues };
+  }
+  return { success: true, data: snapshot.data };
+}
+export {
+  validateAgentOutputValue
+};

package/dist/turns/types.d.ts

@@ -1,4 +1,5 @@
 import type { AgentError, AgentEnvironmentId, AgentEffectiveContentId, AgentIsoDateTime, AgentItemId, AgentTurnId } from '../foundation/index.js';
+import type { AgentStructuredOutputNonJsonResult, AgentStructuredOutputRequest, AgentStructuredOutputResult } from '../structuredOutput/types.js';
 export interface AgentTextInputPart {
     readonly type: 'text';
     readonly text: string;
@@ -50,6 +51,7 @@ export interface AgentTurnRunInput extends AgentTurnInputContent {
     readonly turnId: AgentTurnId;
     readonly interactionMode: AgentTurnInteractionMode;
     readonly deadlineAt?: AgentIsoDateTime;
+    readonly output?: AgentStructuredOutputRequest;
 }
 export type AgentTurnInterruptionReason = 'user_requested' | 'timeout' | 'shutdown' | 'superseded' | 'other';
 export interface AgentTurnInterruptionInput {
@@ -247,10 +249,21 @@ export interface AgentDiffSummary {
     readonly malformed?: boolean;
     readonly truncated?: boolean;
 }
-export interface AgentTurnCompletedPayload {
-    readonly outcome: AgentTurnOutcome;
-    readonly reason?: string;
-    readonly error?: AgentError;
-}
+export type AgentTurnCompletedPayload = Readonly<{
+    outcome: 'completed';
+    structuredOutput: AgentStructuredOutputResult;
+    reason?: string;
+    error?: never;
+}> | Readonly<{
+    outcome: 'failed';
+    structuredOutput: AgentStructuredOutputNonJsonResult;
+    reason?: string;
+    error: AgentError;
+}> | Readonly<{
+    outcome: 'canceled' | 'expired';
+    structuredOutput: AgentStructuredOutputNonJsonResult;
+    reason?: string;
+    error?: never;
+}>;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/zod/capabilities.d.ts

@@ -139,7 +139,7 @@ export declare const AgentOperationInputCapabilitySchema: z.ZodReadonly<z.ZodObj
     }, z.core.$strict>>], "kind">;
 }, z.core.$strict>>;
 export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<{
-    protocolVersion: z.ZodLiteral<12>;
+    protocolVersion: z.ZodLiteral<13>;
     providerKey: z.ZodType<import("../index.js").AgentProviderKey, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentProviderKey, unknown>>;
     sessions: z.ZodReadonly<z.ZodObject<{
         create: z.ZodLiteral<true>;
@@ -156,6 +156,7 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
             plan: "plan";
         }>>>;
         interrupt: z.ZodBoolean;
+        structuredOutput: z.ZodType<import("../index.js").AgentStructuredOutputCapability, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentStructuredOutputCapability, unknown>>;
         steer: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
             kind: z.ZodLiteral<"unsupported">;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -396,10 +397,10 @@ export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<
         }>>>;
         fieldKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
             boolean: "boolean";
+            integer: "integer";
             single_select: "single_select";
             text: "text";
             multi_select: "multi_select";
-            integer: "integer";
         }>>>;
         executionModes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
             immediate: "immediate";

package/dist/zod/capabilities.js

@@ -1,4 +1,5 @@
 import { z } from "zod/v4";
+import { AgentStructuredOutputCapabilitySchema } from "./structuredOutput.js";
 import { AgentEnvironmentCapabilitySchema } from "./environment.js";
 import { AGENT_CONTENT_REFERENCES_MAX_LENGTH } from "../turns/types.js";
 import {
@@ -283,6 +284,7 @@ const AgentCapabilitiesPortableSchema = z.object({
   turns: z.object({
     interactionModes: z.array(z.enum(AGENT_TURN_INTERACTION_MODES)).min(1).max(AGENT_TURN_INTERACTION_MODES.length).meta({ uniqueItems: true }).readonly(),
     interrupt: z.boolean(),
+    structuredOutput: AgentStructuredOutputCapabilitySchema,
     steer: z.discriminatedUnion("kind", [
       z.object({ kind: z.literal("unsupported") }).strict().readonly(),
       z.object({