@agen-ai/agent-protocol 0.4.2 → 0.4.4

package/dist/public/index.d.ts

@@ -1,4 +1,5 @@
 export * from '../foundation/index.js';
+export * from '../structuredOutput/index.js';
 export * from '../failures/index.js';
 export * from '../accountQuota/index.js';
 export * from '../sessions/index.js';

package/dist/public/index.js

@@ -1,4 +1,5 @@
 export * from "../foundation/index.js";
+export * from "../structuredOutput/index.js";
 export * from "../failures/index.js";
 export * from "../accountQuota/index.js";
 export * from "../sessions/index.js";

package/dist/public/structuredOutput.d.ts

@@ -0,0 +1,2 @@
+export * from '../structuredOutput/index.js';
+//# sourceMappingURL=structuredOutput.d.ts.map

package/dist/public/structuredOutput.js

@@ -0,0 +1 @@
+export * from "../structuredOutput/index.js";

package/dist/sessions/types.d.ts

@@ -1,5 +1,6 @@
 import type { AgentConfigurationRevisionId, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentSessionId, AgentTurnId } from '../foundation/index.js';
 import type { AgentConfigurationValue } from '../configuration/index.js';
+import type { AgentStructuredOutputRequest } from '../structuredOutput/types.js';
 export interface AgentSessionBinding {
     readonly conversationId: AgentProviderConversationId;
     readonly historyAnchor?: AgentProviderHistoryAnchor;
@@ -20,6 +21,7 @@ export type AgentSessionConfiguration = Readonly<{
 }>;
 export interface AgentSessionCreateInput {
     readonly operation: 'create';
+    readonly output?: AgentStructuredOutputRequest;
     readonly sessionId: AgentSessionId;
     readonly configuration: AgentSessionConfiguration;
 }

package/dist/structuredOutput/boundedJson.d.ts

@@ -0,0 +1,13 @@
+import type { AgentJsonObject, AgentJsonValue, AgentProtocolParseResult } from '../foundation/types.js';
+export interface StructuredOutputJsonBounds {
+    readonly maxBytes: number;
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    readonly maxCollectionLength: number;
+}
+export declare function isJsonObject(value: AgentJsonValue): value is AgentJsonObject;
+export declare function codePointLength(value: string): number;
+export declare function isOutputPropertyName(value: string): boolean;
+export declare function serializedStringBytes(value: string, stopAfter: number): number;
+export declare function snapshotStructuredOutputJson(input: unknown, bounds: StructuredOutputJsonBounds): AgentProtocolParseResult<AgentJsonValue>;
+//# sourceMappingURL=boundedJson.d.ts.map

package/dist/structuredOutput/boundedJson.js

@@ -0,0 +1,143 @@
+import { AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH } from "./constants.js";
+import { StructuredOutputIssues } from "./issues.js";
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function codePointLength(value) {
+  let length = 0;
+  for (const _point of value) length += 1;
+  return length;
+}
+function isOutputPropertyName(value) {
+  return value.length > 0 && value.length <= 2 * AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH && value !== "__proto__" && value !== "constructor" && value !== "prototype" && codePointLength(value) <= AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH;
+}
+function serializedStringBytes(value, stopAfter) {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit === 34 || unit === 92) bytes += 2;
+    else if (unit <= 31) bytes += [8, 9, 10, 12, 13].includes(unit) ? 2 : 6;
+    else if (unit <= 127) bytes += 1;
+    else if (unit <= 2047) bytes += 2;
+    else if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index += 1;
+      } else bytes += 6;
+    } else if (unit >= 56320 && unit <= 57343) bytes += 6;
+    else bytes += 3;
+    if (bytes > stopAfter) break;
+  }
+  return bytes;
+}
+function snapshotStructuredOutputJson(input, bounds) {
+  const issues = new StructuredOutputIssues();
+  const active = /* @__PURE__ */ new WeakSet();
+  let bytes = 0;
+  let nodes = 0;
+  function fail(code, message, path) {
+    issues.add(code, message, path);
+    return void 0;
+  }
+  function charge(amount, path) {
+    bytes += amount;
+    if (bytes <= bounds.maxBytes) return true;
+    fail("output_limit_exceeded", "JSON data exceeds the serialized UTF-8 byte limit.", path);
+    return false;
+  }
+  function copy(value, depth, path) {
+    nodes += 1;
+    if (nodes > bounds.maxNodes || depth > bounds.maxDepth) {
+      return fail("output_limit_exceeded", "JSON data exceeds the node or depth limit.", path);
+    }
+    if (value === null || typeof value === "boolean") {
+      return charge(value === null ? 4 : value ? 4 : 5, path) ? value : void 0;
+    }
+    if (typeof value === "string") {
+      return charge(serializedStringBytes(value, bounds.maxBytes - bytes), path) ? value : void 0;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) return fail("invalid_json_data", "JSON numbers must be finite.", path);
+      return charge(JSON.stringify(value).length, path) ? value : void 0;
+    }
+    if (typeof value !== "object") return fail("invalid_json_data", "Only plain JSON data is accepted.", path);
+    if (active.has(value)) return fail("invalid_json_data", "JSON data must not contain cycles.", path);
+    const array = Array.isArray(value);
+    let keys;
+    let length = 0;
+    try {
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype !== (array ? Array.prototype : Object.prototype) && !(prototype === null && !array)) {
+        return fail("invalid_json_data", "JSON data must use plain object and array prototypes.", path);
+      }
+      if (array) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, "length");
+        const arrayLength = descriptor?.value;
+        if (!descriptor || !("value" in descriptor) || typeof arrayLength !== "number" || !Number.isSafeInteger(arrayLength) || arrayLength < 0 || arrayLength > bounds.maxCollectionLength) {
+          return fail("output_limit_exceeded", "JSON arrays exceed the collection limit.", path);
+        }
+        length = arrayLength;
+      }
+      keys = Reflect.ownKeys(value);
+    } catch {
+      return fail("invalid_json_data", "JSON data properties cannot be inspected safely.", path);
+    }
+    if (keys.length > bounds.maxCollectionLength + (array ? 1 : 0)) {
+      return fail("output_limit_exceeded", "JSON collections exceed the entry limit.", path);
+    }
+    if (array && keys.length !== length + 1) return fail("invalid_json_data", "JSON arrays must be dense and have no extra properties.", path);
+    const entries = [];
+    for (const key of keys) {
+      if (array && key === "length") continue;
+      if (typeof key !== "string" || !array && !isOutputPropertyName(key)) {
+        return fail("invalid_json_data", "JSON object property names must be bounded and safe.", path);
+      }
+      if (array && (!/^(?:0|[1-9][0-9]*)$/u.test(key) || Number(key) >= length)) {
+        return fail("invalid_json_data", "JSON arrays must have only indexed entries.", path);
+      }
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(value, key);
+      } catch {
+        return fail("invalid_json_data", "JSON data properties cannot be inspected safely.", path);
+      }
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+        return fail("invalid_json_data", "JSON data must contain only enumerable data properties.", path);
+      }
+      const child = descriptor.value;
+      entries.push([key, child]);
+    }
+    if (!charge(2 + Math.max(0, entries.length - 1), path)) return void 0;
+    active.add(value);
+    if (array) {
+      const result2 = [];
+      for (const [key, child] of entries) {
+        const copied = copy(child, depth + 1, [...path, Number(key)]);
+        if (copied === void 0) return void 0;
+        result2.push(copied);
+      }
+      active.delete(value);
+      return result2;
+    }
+    const result = {};
+    for (const [key, child] of entries) {
+      const childPath = [...path, key];
+      if (!charge(serializedStringBytes(key, bounds.maxBytes - bytes) + 1, childPath)) return void 0;
+      const copied = copy(child, depth + 1, childPath);
+      if (copied === void 0) return void 0;
+      result[key] = copied;
+    }
+    active.delete(value);
+    return result;
+  }
+  const data = copy(input, 1, []);
+  return data === void 0 ? { success: false, issues: issues.issues } : { success: true, data };
+}
+export {
+  codePointLength,
+  isJsonObject,
+  isOutputPropertyName,
+  serializedStringBytes,
+  snapshotStructuredOutputJson
+};

package/dist/structuredOutput/constants.d.ts

@@ -0,0 +1,24 @@
+export declare const AGENT_OUTPUT_SCHEMA_PROFILE: "agenai.output-schema.v1";
+export declare const AGENT_OUTPUT_SCHEMA_DIALECT: "https://json-schema.org/draft/2020-12/schema";
+export declare const AGENT_OUTPUT_SCHEMA_BYTES_LIMIT = 16384;
+export declare const AGENT_OUTPUT_SCHEMA_NODES_LIMIT = 256;
+export declare const AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT = 8;
+export declare const AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT = 100;
+export declare const AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH = 128;
+export declare const AGENT_OUTPUT_SCHEMA_DESCRIPTION_MAX_LENGTH = 2000;
+export declare const AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT = 100;
+export declare const AGENT_OUTPUT_SCHEMA_LENGTH_BOUND_LIMIT = 16384;
+export declare const AGENT_OUTPUT_VALUE_BYTES_LIMIT = 16384;
+export declare const AGENT_OUTPUT_VALUE_NODES_LIMIT = 1024;
+export declare const AGENT_OUTPUT_VALUE_DEPTH_LIMIT = 16;
+export declare const AGENT_OUTPUT_VALUE_COLLECTION_LIMIT = 100;
+export declare const AGENT_OUTPUT_RAW_JSON_BYTES_LIMIT = 65536;
+export declare const AGENT_STRUCTURED_OUTPUT_ISSUES_LIMIT = 8;
+export declare const AGENT_STRUCTURED_OUTPUT_ISSUES_BYTES_LIMIT = 4096;
+export declare const AGENT_STRUCTURED_OUTPUT_ISSUE_CODE_MAX_LENGTH = 64;
+export declare const AGENT_STRUCTURED_OUTPUT_ISSUE_MESSAGE_MAX_LENGTH = 256;
+export declare const AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_SEGMENTS_LIMIT = 16;
+export declare const AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_BYTES_LIMIT = 1024;
+export declare const AGENT_STRUCTURED_OUTPUT_TURN_REQUEST_BYTES_LIMIT = 1085440;
+export declare const AGENT_STRUCTURED_OUTPUT_UNAVAILABLE_REASONS: readonly ["refused", "incomplete", "missing_output", "invalid_json", "schema_mismatch", "output_limit_exceeded", "native_retries_exhausted", "provider_error"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/structuredOutput/constants.js

@@ -0,0 +1,57 @@
+const AGENT_OUTPUT_SCHEMA_PROFILE = "agenai.output-schema.v1";
+const AGENT_OUTPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+const AGENT_OUTPUT_SCHEMA_BYTES_LIMIT = 16384;
+const AGENT_OUTPUT_SCHEMA_NODES_LIMIT = 256;
+const AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT = 8;
+const AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT = 100;
+const AGENT_OUTPUT_SCHEMA_PROPERTY_NAME_MAX_LENGTH = 128;
+const AGENT_OUTPUT_SCHEMA_DESCRIPTION_MAX_LENGTH = 2e3;
+const AGENT_OUTPUT_SCHEMA_ENUM_VALUES_LIMIT = 100;
+const AGENT_OUTPUT_SCHEMA_LENGTH_BOUND_LIMIT = 16384;
+const AGENT_OUTPUT_VALUE_BYTES_LIMIT = 16384;
+const AGENT_OUTPUT_VALUE_NODES_LIMIT = 1024;
+const AGENT_OUTPUT_VALUE_DEPTH_LIMIT = 16;
+const AGENT_OUTPUT_VALUE_COLLECTION_LIMIT = 100;
+const AGENT_OUTPUT_RAW_JSON_BYTES_LIMIT = 65536;
+const AGENT_STRUCTURED_OUTPUT_ISSUES_LIMIT = 8;
+const AGENT_STRUCTURED_OUTPUT_ISSUES_BYTES_LIMIT = 4096;
+const AGENT_STRUCTURED_OUTPUT_ISSUE_CODE_MAX_LENGTH = 64;
+const AGENT_STRUCTURED_OUTPUT_ISSUE_MESSAGE_MAX_LENGTH = 256;
+const AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_SEGMENTS_LIMIT = 16;
+const AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_BYTES_LIMIT = 1024;
+const AGENT_STRUCTURED_OUTPUT_TURN_REQUEST_BYTES_LIMIT = 1085440;
+const AGENT_STRUCTURED_OUTPUT_UNAVAILABLE_REASONS = [
+  "refused",
+  "incomplete",
+  "missing_output",
+  "invalid_json",
+  "schema_mismatch",
+  "output_limit_exceeded",
+  "native_retries_exhausted",
+  "provider_error"
+];
+export {
+  AGENT_OUTPUT_RAW_JSON_BYTES_LIMIT,
+  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_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_ISSUES_BYTES_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_ISSUES_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_TURN_REQUEST_BYTES_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_UNAVAILABLE_REASONS
+};

package/dist/structuredOutput/definition.d.ts

@@ -0,0 +1,9 @@
+import type { AgentJsonObject, AgentProtocolParseResult } from '../foundation/types.js';
+import type { AgentOutputSchema } from './types.js';
+export interface AgentOutputDefinition<T> {
+    readonly schema: AgentOutputSchema;
+    readonly decode: (value: AgentJsonObject) => AgentProtocolParseResult<T>;
+}
+export declare function createAgentOutputDefinition(schema: AgentOutputSchema): AgentOutputDefinition<AgentJsonObject>;
+export declare function createAgentOutputDefinition<T>(schema: AgentOutputSchema, decode: (value: AgentJsonObject) => AgentProtocolParseResult<T>): AgentOutputDefinition<T>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/structuredOutput/definition.js

@@ -0,0 +1,15 @@
+import { parseAgentOutputSchema } from "./parsers.js";
+function createAgentOutputDefinition(schema, decode) {
+  if (decode !== void 0 && typeof decode !== "function") {
+    throw new TypeError("An output definition decoder must be a function.");
+  }
+  const ownedSchema = parseAgentOutputSchema(schema);
+  if (decode !== void 0) return Object.freeze({ schema: ownedSchema, decode });
+  return Object.freeze({
+    schema: ownedSchema,
+    decode: (value) => ({ success: true, data: value })
+  });
+}
+export {
+  createAgentOutputDefinition
+};

package/dist/structuredOutput/index.d.ts

@@ -0,0 +1,9 @@
+export * from './constants.js';
+export type * from './types.js';
+export { parseAgentOutputSchema, safeParseAgentOutputSchema } from './parsers.js';
+export type { AgentOutputLimits } from './parsers.js';
+export { validateAgentOutputValue } from './values.js';
+export { createAgentOutputDefinition } from './definition.js';
+export type { AgentOutputDefinition } from './definition.js';
+export { normalizeAgentStructuredOutputIssues } from './issues.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/structuredOutput/index.js

@@ -0,0 +1,12 @@
+export * from "./constants.js";
+import { parseAgentOutputSchema, safeParseAgentOutputSchema } from "./parsers.js";
+import { validateAgentOutputValue } from "./values.js";
+import { createAgentOutputDefinition } from "./definition.js";
+import { normalizeAgentStructuredOutputIssues } from "./issues.js";
+export {
+  createAgentOutputDefinition,
+  normalizeAgentStructuredOutputIssues,
+  parseAgentOutputSchema,
+  safeParseAgentOutputSchema,
+  validateAgentOutputValue
+};

package/dist/structuredOutput/issues.d.ts

@@ -0,0 +1,8 @@
+import type { ValidationIssue, ValidationPathSegment } from '../foundation/types.js';
+export declare class StructuredOutputIssues {
+    readonly issues: ValidationIssue[];
+    get full(): boolean;
+    add(code: string, message: string, inputPath?: readonly ValidationPathSegment[]): void;
+}
+export declare function normalizeAgentStructuredOutputIssues(input: readonly ValidationIssue[]): readonly ValidationIssue[];
+//# sourceMappingURL=issues.d.ts.map

package/dist/structuredOutput/issues.js

@@ -0,0 +1,76 @@
+import {
+  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 "./constants.js";
+const encoder = new TextEncoder();
+function boundedText(value, maxLength) {
+  let result = "";
+  let length = 0;
+  for (const point of value) {
+    if (length === maxLength) break;
+    result += point;
+    length += 1;
+  }
+  return result;
+}
+class StructuredOutputIssues {
+  issues = [];
+  get full() {
+    return this.issues.length >= AGENT_STRUCTURED_OUTPUT_ISSUES_LIMIT;
+  }
+  add(code, message, inputPath = []) {
+    if (this.full) return;
+    const path = [];
+    for (const segment of inputPath) {
+      if (path.length === AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_SEGMENTS_LIMIT) break;
+      if (typeof segment === "string" && segment.length > AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_BYTES_LIMIT || typeof segment === "number" && !Number.isFinite(segment)) break;
+      const candidate = [...path, segment];
+      if (encoder.encode(JSON.stringify(candidate)).byteLength > AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_BYTES_LIMIT) break;
+      path.push(segment);
+    }
+    const issue = {
+      code: boundedText(code, AGENT_STRUCTURED_OUTPUT_ISSUE_CODE_MAX_LENGTH),
+      path,
+      message: boundedText(message, AGENT_STRUCTURED_OUTPUT_ISSUE_MESSAGE_MAX_LENGTH)
+    };
+    if (encoder.encode(JSON.stringify([...this.issues, issue])).byteLength <= AGENT_STRUCTURED_OUTPUT_ISSUES_BYTES_LIMIT) {
+      this.issues.push(issue);
+    }
+  }
+}
+function ownData(input, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(input, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function normalizeAgentStructuredOutputIssues(input) {
+  const normalized = new StructuredOutputIssues();
+  if (!Array.isArray(input)) return Object.freeze([]);
+  const length = ownData(input, "length");
+  if (typeof length !== "number") return Object.freeze([]);
+  for (let index = 0; index < Math.min(length, AGENT_STRUCTURED_OUTPUT_ISSUES_LIMIT); index += 1) {
+    const issue = ownData(input, index);
+    if (issue === null || typeof issue !== "object") continue;
+    const code = ownData(issue, "code");
+    const message = ownData(issue, "message");
+    const sourcePath = ownData(issue, "path");
+    if (typeof code !== "string" || typeof message !== "string" || !Array.isArray(sourcePath)) continue;
+    const pathLength = ownData(sourcePath, "length");
+    if (typeof pathLength !== "number") continue;
+    const path = [];
+    for (let offset = 0; offset < Math.min(pathLength, AGENT_STRUCTURED_OUTPUT_ISSUE_PATH_SEGMENTS_LIMIT); offset += 1) {
+      const segment = ownData(sourcePath, offset);
+      if (typeof segment !== "string" && (typeof segment !== "number" || !Number.isFinite(segment))) break;
+      path.push(segment);
+    }
+    normalized.add(code, message, path);
+  }
+  return Object.freeze(normalized.issues.map((issue) => Object.freeze({ ...issue, path: Object.freeze([...issue.path]) })));
+}
+export {
+  StructuredOutputIssues,
+  normalizeAgentStructuredOutputIssues
+};

package/dist/structuredOutput/parsers.d.ts

@@ -0,0 +1,10 @@
+import { type AgentProtocolParseResult } from '../foundation/types.js';
+import type { AgentOutputSchema } from './types.js';
+export interface AgentOutputLimits {
+    readonly maxOutputBytes?: number;
+}
+export declare function parseOutputByteLimit(limits?: AgentOutputLimits): AgentProtocolParseResult<number>;
+export declare function safeParseAgentOutputSchema(input: unknown, limits?: AgentOutputLimits): AgentProtocolParseResult<AgentOutputSchema>;
+export declare function parseAgentOutputSchema(input: unknown, limits?: AgentOutputLimits): AgentOutputSchema;
+export declare function trustedOutputSchema(input: AgentOutputSchema): AgentProtocolParseResult<AgentOutputSchema>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/structuredOutput/parsers.js

@@ -0,0 +1,74 @@
+import {
+  AgentProtocolValidationError
+} from "../foundation/types.js";
+import { snapshotStructuredOutputJson } from "./boundedJson.js";
+import {
+  AGENT_OUTPUT_SCHEMA_BYTES_LIMIT,
+  AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT,
+  AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT,
+  AGENT_OUTPUT_VALUE_BYTES_LIMIT
+} from "./constants.js";
+import { StructuredOutputIssues } from "./issues.js";
+import { admitOutputSchema, StructuredOutputSchemaError } from "./schemaAdmission.js";
+const admittedSchemas = /* @__PURE__ */ new WeakSet();
+function outputByteLimit(limits) {
+  if (limits === null || typeof limits !== "object") return void 0;
+  try {
+    const prototype = Object.getPrototypeOf(limits);
+    if (prototype !== Object.prototype && prototype !== null || Reflect.ownKeys(limits).some((key) => key !== "maxOutputBytes")) return void 0;
+    const descriptor = Object.getOwnPropertyDescriptor(limits, "maxOutputBytes");
+    if (descriptor === void 0) return AGENT_OUTPUT_VALUE_BYTES_LIMIT;
+    if (!("value" in descriptor) || !descriptor.enumerable) return void 0;
+    const value = descriptor.value;
+    if (value === void 0) return AGENT_OUTPUT_VALUE_BYTES_LIMIT;
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= AGENT_OUTPUT_VALUE_BYTES_LIMIT ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseOutputByteLimit(limits = {}) {
+  const maxOutputBytes = outputByteLimit(limits);
+  if (maxOutputBytes === void 0) {
+    return { success: false, issues: [{
+      code: "invalid_output_limits",
+      path: ["maxOutputBytes"],
+      message: "Output byte limit must be a positive integer within the portable profile ceiling."
+    }] };
+  }
+  return { success: true, data: maxOutputBytes };
+}
+function safeParseAgentOutputSchema(input, limits) {
+  const parsedLimit = parseOutputByteLimit(limits);
+  if (!parsedLimit.success) return parsedLimit;
+  const snapshot = snapshotStructuredOutputJson(input, {
+    maxBytes: AGENT_OUTPUT_SCHEMA_BYTES_LIMIT,
+    maxDepth: 3 * AGENT_OUTPUT_SCHEMA_DEPTH_LIMIT + 2,
+    maxNodes: AGENT_OUTPUT_SCHEMA_BYTES_LIMIT,
+    maxCollectionLength: AGENT_OUTPUT_SCHEMA_PROPERTIES_LIMIT
+  });
+  if (!snapshot.success) return snapshot;
+  try {
+    const schema = admitOutputSchema(snapshot.data, parsedLimit.data);
+    admittedSchemas.add(schema);
+    return { success: true, data: schema };
+  } catch (error) {
+    if (!(error instanceof StructuredOutputSchemaError)) throw error;
+    const issues = new StructuredOutputIssues();
+    issues.add("invalid_output_schema", error.message, error.path);
+    return { success: false, issues: issues.issues };
+  }
+}
+function parseAgentOutputSchema(input, limits) {
+  const parsed = safeParseAgentOutputSchema(input, limits);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+function trustedOutputSchema(input) {
+  return admittedSchemas.has(input) ? { success: true, data: input } : safeParseAgentOutputSchema(input);
+}
+export {
+  parseAgentOutputSchema,
+  parseOutputByteLimit,
+  safeParseAgentOutputSchema,
+  trustedOutputSchema
+};

package/dist/structuredOutput/schemaAdmission.d.ts

@@ -0,0 +1,9 @@
+import type { AgentJsonValue, ValidationPathSegment } from '../foundation/types.js';
+import type { AgentOutputSchema } from './types.js';
+export declare class StructuredOutputSchemaError extends Error {
+    readonly message: string;
+    readonly path: readonly ValidationPathSegment[];
+    constructor(message: string, path: readonly ValidationPathSegment[]);
+}
+export declare function admitOutputSchema(input: AgentJsonValue, maxOutputBytes?: number): AgentOutputSchema;
+//# sourceMappingURL=schemaAdmission.d.ts.map