@agen-ai/agent-protocol 0.1.0

package/dist/foundation/parsers.js

@@ -0,0 +1,148 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentArtifactIdSchema,
+  AgentConfigurationRevisionIdSchema,
+  AgentErrorSchema,
+  AgentInstanceIdSchema,
+  AgentIsoDateTimeSchema,
+  AgentItemIdSchema,
+  AgentJsonValueSchema,
+  AgentProviderConversationIdSchema,
+  AgentProviderHistoryAnchorSchema,
+  AgentProviderItemRefSchema,
+  AgentProviderKeySchema,
+  AgentProviderRefsSchema,
+  AgentProviderRequestRefSchema,
+  AgentProviderTurnRefSchema,
+  AgentRequestFieldIdSchema,
+  AgentRequestIdSchema,
+  AgentSessionIdSchema,
+  AgentTurnIdSchema
+} from "../zod/foundation.js";
+function idParser(schema) {
+  return {
+    parse: (input) => parseWithSchema(schema, input),
+    safeParse: (input) => safeParseWithSchema(schema, input)
+  };
+}
+const instanceIdParser = idParser(AgentInstanceIdSchema);
+const sessionIdParser = idParser(AgentSessionIdSchema);
+const turnIdParser = idParser(AgentTurnIdSchema);
+const itemIdParser = idParser(AgentItemIdSchema);
+const requestIdParser = idParser(AgentRequestIdSchema);
+const requestFieldIdParser = idParser(
+  AgentRequestFieldIdSchema
+);
+const artifactIdParser = idParser(AgentArtifactIdSchema);
+const revisionIdParser = idParser(
+  AgentConfigurationRevisionIdSchema
+);
+const conversationIdParser = idParser(
+  AgentProviderConversationIdSchema
+);
+const historyAnchorParser = idParser(
+  AgentProviderHistoryAnchorSchema
+);
+const providerTurnRefParser = idParser(
+  AgentProviderTurnRefSchema
+);
+const providerItemRefParser = idParser(
+  AgentProviderItemRefSchema
+);
+const providerRequestRefParser = idParser(
+  AgentProviderRequestRefSchema
+);
+const parseAgentInstanceId = instanceIdParser.parse;
+const safeParseAgentInstanceId = instanceIdParser.safeParse;
+const parseAgentSessionId = sessionIdParser.parse;
+const safeParseAgentSessionId = sessionIdParser.safeParse;
+const parseAgentTurnId = turnIdParser.parse;
+const safeParseAgentTurnId = turnIdParser.safeParse;
+const parseAgentItemId = itemIdParser.parse;
+const safeParseAgentItemId = itemIdParser.safeParse;
+const parseAgentRequestId = requestIdParser.parse;
+const safeParseAgentRequestId = requestIdParser.safeParse;
+const parseAgentRequestFieldId = requestFieldIdParser.parse;
+const safeParseAgentRequestFieldId = requestFieldIdParser.safeParse;
+const parseAgentArtifactId = artifactIdParser.parse;
+const safeParseAgentArtifactId = artifactIdParser.safeParse;
+const parseAgentConfigurationRevisionId = revisionIdParser.parse;
+const safeParseAgentConfigurationRevisionId = revisionIdParser.safeParse;
+const parseAgentProviderConversationId = conversationIdParser.parse;
+const safeParseAgentProviderConversationId = conversationIdParser.safeParse;
+const parseAgentProviderHistoryAnchor = historyAnchorParser.parse;
+const safeParseAgentProviderHistoryAnchor = historyAnchorParser.safeParse;
+const parseAgentProviderTurnRef = providerTurnRefParser.parse;
+const safeParseAgentProviderTurnRef = providerTurnRefParser.safeParse;
+const parseAgentProviderItemRef = providerItemRefParser.parse;
+const safeParseAgentProviderItemRef = providerItemRefParser.safeParse;
+const parseAgentProviderRequestRef = providerRequestRefParser.parse;
+const safeParseAgentProviderRequestRef = providerRequestRefParser.safeParse;
+function parseAgentProviderKey(input) {
+  return parseWithSchema(AgentProviderKeySchema, input);
+}
+function safeParseAgentProviderKey(input) {
+  return safeParseWithSchema(AgentProviderKeySchema, input);
+}
+function parseAgentIsoDateTime(input) {
+  return parseWithSchema(AgentIsoDateTimeSchema, input);
+}
+function safeParseAgentIsoDateTime(input) {
+  return safeParseWithSchema(AgentIsoDateTimeSchema, input);
+}
+function parseAgentJsonValue(input) {
+  return parseWithSchema(AgentJsonValueSchema, input);
+}
+function safeParseAgentJsonValue(input) {
+  return safeParseWithSchema(AgentJsonValueSchema, input);
+}
+function parseAgentProviderRefs(input) {
+  return parseWithSchema(AgentProviderRefsSchema, input);
+}
+function safeParseAgentProviderRefs(input) {
+  return safeParseWithSchema(AgentProviderRefsSchema, input);
+}
+function parseAgentError(input) {
+  return parseWithSchema(AgentErrorSchema, input);
+}
+function safeParseAgentError(input) {
+  return safeParseWithSchema(AgentErrorSchema, input);
+}
+export {
+  parseAgentArtifactId,
+  parseAgentConfigurationRevisionId,
+  parseAgentError,
+  parseAgentInstanceId,
+  parseAgentIsoDateTime,
+  parseAgentItemId,
+  parseAgentJsonValue,
+  parseAgentProviderConversationId,
+  parseAgentProviderHistoryAnchor,
+  parseAgentProviderItemRef,
+  parseAgentProviderKey,
+  parseAgentProviderRefs,
+  parseAgentProviderRequestRef,
+  parseAgentProviderTurnRef,
+  parseAgentRequestFieldId,
+  parseAgentRequestId,
+  parseAgentSessionId,
+  parseAgentTurnId,
+  safeParseAgentArtifactId,
+  safeParseAgentConfigurationRevisionId,
+  safeParseAgentError,
+  safeParseAgentInstanceId,
+  safeParseAgentIsoDateTime,
+  safeParseAgentItemId,
+  safeParseAgentJsonValue,
+  safeParseAgentProviderConversationId,
+  safeParseAgentProviderHistoryAnchor,
+  safeParseAgentProviderItemRef,
+  safeParseAgentProviderKey,
+  safeParseAgentProviderRefs,
+  safeParseAgentProviderRequestRef,
+  safeParseAgentProviderTurnRef,
+  safeParseAgentRequestFieldId,
+  safeParseAgentRequestId,
+  safeParseAgentSessionId,
+  safeParseAgentTurnId
+};

package/dist/foundation/types.d.ts

@@ -0,0 +1,62 @@
+export type { AgentProtocolParseFailure, AgentProtocolParseResult, AgentProtocolParseSuccess, ValidationIssue, ValidationPathSegment, } from './validation.js';
+export { AgentProtocolValidationError } from './validation.js';
+export declare const AGENT_PROTOCOL_VERSION: 6;
+export declare const AGENT_PROTOCOL_ID_MAX_LENGTH = 256;
+export declare const AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH = 512;
+export declare const AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH = 100;
+export declare const AGENT_PROTOCOL_CODE_MAX_LENGTH = 120;
+export declare const AGENT_PROTOCOL_TEXT_MAX_LENGTH = 4000;
+export declare const AGENT_PROTOCOL_SUMMARY_MAX_LENGTH = 2000;
+export declare const AGENT_PROTOCOL_COLLECTION_MAX_LENGTH = 100;
+export declare const AGENT_PROTOCOL_JSON_KEY_MAX_LENGTH = 128;
+export declare const AGENT_PROTOCOL_JSON_DEPTH_LIMIT = 16;
+export declare const AGENT_PROTOCOL_JSON_BYTES_LIMIT = 32768;
+export declare const AGENT_PROTOCOL_EVENT_BYTES_LIMIT = 32768;
+export declare const AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT = 1064960;
+declare const agentProtocolIdBrand: unique symbol;
+type AgentProtocolId<Kind extends string> = string & {
+    readonly [agentProtocolIdBrand]: Kind;
+};
+export type AgentInstanceId = AgentProtocolId<'AgentInstanceId'>;
+export type AgentSessionId = AgentProtocolId<'AgentSessionId'>;
+export type AgentTurnId = AgentProtocolId<'AgentTurnId'>;
+export type AgentItemId = AgentProtocolId<'AgentItemId'>;
+export type AgentRequestId = AgentProtocolId<'AgentRequestId'>;
+export type AgentRequestFieldId = AgentProtocolId<'AgentRequestFieldId'>;
+export type AgentArtifactId = AgentProtocolId<'AgentArtifactId'>;
+export type AgentConfigurationRevisionId = AgentProtocolId<'AgentConfigurationRevisionId'>;
+export type AgentProviderConversationId = AgentProtocolId<'AgentProviderConversationId'>;
+export type AgentProviderHistoryAnchor = AgentProtocolId<'AgentProviderHistoryAnchor'>;
+export type AgentProviderTurnRef = AgentProtocolId<'AgentProviderTurnRef'>;
+export type AgentProviderItemRef = AgentProtocolId<'AgentProviderItemRef'>;
+export type AgentProviderRequestRef = AgentProtocolId<'AgentProviderRequestRef'>;
+export type AgentProviderKey = string & {
+    readonly [agentProtocolIdBrand]: 'AgentProviderKey';
+};
+export type AgentIsoDateTime = string & {
+    readonly [agentProtocolIdBrand]: 'AgentIsoDateTime';
+};
+export type AgentJsonPrimitive = string | number | boolean | null;
+export type AgentJsonValue = AgentJsonPrimitive | readonly AgentJsonValue[] | {
+    readonly [key: string]: AgentJsonValue;
+};
+export interface AgentProviderRefs {
+    readonly conversationId?: AgentProviderConversationId;
+    readonly historyAnchor?: AgentProviderHistoryAnchor;
+    readonly turnId?: AgentProviderTurnRef;
+    readonly itemId?: AgentProviderItemRef;
+    readonly requestId?: AgentProviderRequestRef;
+}
+export interface AgentErrorContext {
+    readonly operation?: string;
+    readonly component?: string;
+    readonly status?: string;
+}
+export interface AgentError {
+    readonly code: string;
+    readonly message: string;
+    readonly retryable: boolean;
+    readonly context?: AgentErrorContext;
+}
+export declare function agentProtocolSerializedJsonBytes(value: unknown): number;
+//# sourceMappingURL=types.d.ts.map

package/dist/foundation/types.js

@@ -0,0 +1,39 @@
+import { AgentProtocolValidationError } from "./validation.js";
+const AGENT_PROTOCOL_VERSION = 6;
+const AGENT_PROTOCOL_ID_MAX_LENGTH = 256;
+const AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH = 512;
+const AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH = 100;
+const AGENT_PROTOCOL_CODE_MAX_LENGTH = 120;
+const AGENT_PROTOCOL_TEXT_MAX_LENGTH = 4e3;
+const AGENT_PROTOCOL_SUMMARY_MAX_LENGTH = 2e3;
+const AGENT_PROTOCOL_COLLECTION_MAX_LENGTH = 100;
+const AGENT_PROTOCOL_JSON_KEY_MAX_LENGTH = 128;
+const AGENT_PROTOCOL_JSON_DEPTH_LIMIT = 16;
+const AGENT_PROTOCOL_JSON_BYTES_LIMIT = 32768;
+const AGENT_PROTOCOL_EVENT_BYTES_LIMIT = 32768;
+const AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT = 1064960;
+const textEncoder = new TextEncoder();
+function agentProtocolSerializedJsonBytes(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) {
+    throw new TypeError("Agent protocol value is not JSON serializable.");
+  }
+  return textEncoder.encode(serialized).byteLength;
+}
+export {
+  AGENT_PROTOCOL_CODE_MAX_LENGTH,
+  AGENT_PROTOCOL_COLLECTION_MAX_LENGTH,
+  AGENT_PROTOCOL_EVENT_BYTES_LIMIT,
+  AGENT_PROTOCOL_ID_MAX_LENGTH,
+  AGENT_PROTOCOL_JSON_BYTES_LIMIT,
+  AGENT_PROTOCOL_JSON_DEPTH_LIMIT,
+  AGENT_PROTOCOL_JSON_KEY_MAX_LENGTH,
+  AGENT_PROTOCOL_PROVIDER_KEY_MAX_LENGTH,
+  AGENT_PROTOCOL_PROVIDER_REFERENCE_MAX_LENGTH,
+  AGENT_PROTOCOL_SUMMARY_MAX_LENGTH,
+  AGENT_PROTOCOL_TEXT_MAX_LENGTH,
+  AGENT_PROTOCOL_TURN_INPUT_CONTENT_BYTES_LIMIT,
+  AGENT_PROTOCOL_VERSION,
+  AgentProtocolValidationError,
+  agentProtocolSerializedJsonBytes
+};

package/dist/foundation/validation.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationIssue } from '@agen-ai/validation';
+export type { ValidationIssue, ValidationPathSegment } from '@agen-ai/validation';
+export interface AgentProtocolParseSuccess<T> {
+    readonly success: true;
+    readonly data: T;
+}
+export interface AgentProtocolParseFailure {
+    readonly success: false;
+    readonly issues: readonly ValidationIssue[];
+}
+export type AgentProtocolParseResult<T> = AgentProtocolParseSuccess<T> | AgentProtocolParseFailure;
+export declare class AgentProtocolValidationError extends TypeError {
+    readonly issues: readonly ValidationIssue[];
+    constructor(issues: readonly ValidationIssue[]);
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/foundation/validation.js

@@ -0,0 +1,11 @@
+class AgentProtocolValidationError extends TypeError {
+  issues;
+  constructor(issues) {
+    super("Agent protocol validation failed.");
+    this.name = "AgentProtocolValidationError";
+    this.issues = issues;
+  }
+}
+export {
+  AgentProtocolValidationError
+};

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/internal/parsers.d.ts

@@ -0,0 +1,5 @@
+import type { ZodType } from 'zod/v4';
+import { type AgentProtocolParseResult } from '../foundation/validation.js';
+export declare function safeParseWithSchema<T>(schema: ZodType<T>, input: unknown): AgentProtocolParseResult<T>;
+export declare function parseWithSchema<T>(schema: ZodType<T>, input: unknown): T;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/internal/parsers.js

@@ -0,0 +1,21 @@
+import { normalizeZodValidationError } from "@agen-ai/validation/zod";
+import {
+  AgentProtocolValidationError
+} from "../foundation/validation.js";
+function safeParseWithSchema(schema, input) {
+  const parsed = schema.safeParse(input);
+  if (parsed.success) return { success: true, data: parsed.data };
+  return {
+    success: false,
+    issues: normalizeZodValidationError(schema, parsed.error, input)
+  };
+}
+function parseWithSchema(schema, input) {
+  const parsed = safeParseWithSchema(schema, input);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+export {
+  parseWithSchema,
+  safeParseWithSchema
+};