@agen-ai/agent-protocol 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Trevor Nichols
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# `@agen-ai/agent-protocol`
+
+`@agen-ai/agent-protocol` is the provider-neutral data contract for coding-agent runtimes. It
+defines opaque identifiers, sessions, turns, approval and elicitation requests, technical
+capabilities, portable artifact descriptors, and provider-observed events. The package does not
+define a transport or execution runtime.
+
+## Ownership boundary
+
+The protocol deliberately has no concept of a tenant, SaaS product, database row, assigned actor,
+host lease, persistence sequence, member visibility, billing rule, or storage backend. Opaque IDs
+are correlation values supplied by the caller; they are never authorization credentials.
+
+Use `@agen-ai/agent-runtime` for the process-local driver and adapter SPI. A product control plane
+is responsible for authorization, scheduling, persistence, audit attribution, and mapping its own
+identities to protocol IDs.
+
+`capabilities.turns.steer` is only the provider's technical ability to accept canonical input into
+the currently running turn. It does not describe, authorize, or implement future-turn queueing;
+that product concern belongs to the caller's control plane.
+
+## Entrypoints
+
+- `@agen-ai/agent-protocol` exports the complete plain API.
+- `/sessions`, `/turns`, `/requests`, `/events`, `/capabilities`, and `/artifacts` are focused plain
+  entrypoints.
+- `/zod` is the only entrypoint that exposes Zod schemas.
+- `/json-schema` exposes deterministic draft 2020-12 schema artifacts.
+
+Ordinary entrypoints expose plain TypeScript types, constants, parsers, and validator-neutral
+issues. Their declarations do not expose Zod.
+
+## Protocol-only example
+
+```ts
+import {
+  parseAgentEvent,
+  parseAgentSessionId,
+  parseAgentTurnId,
+  type AgentEvent,
+} from '@agen-ai/agent-protocol';
+
+const event: AgentEvent = parseAgentEvent({
+  protocolVersion: 6,
+  type: 'content.delta',
+  sessionId: parseAgentSessionId('external-session:42'),
+  turnId: parseAgentTurnId('external-turn:9'),
+  occurredAt: '2026-08-03T20:00:00.000Z',
+  payload: {
+    itemId: 'assistant-message:1',
+    streamKind: 'assistant_text',
+    delta: 'Hello from a provider.',
+  },
+});
+
+const roundTripped = parseAgentEvent(JSON.parse(JSON.stringify(event)));
+```
+
+Serialized values carry `protocolVersion: 6`; TypeScript API names remain unsuffixed. Unknown
+fields and unsupported protocol versions are rejected.
+
+Item snapshots are a closed union keyed by `itemKind`. Common identity and lifecycle fields are
+shared, while commands, file changes, managed tools, web/computer activity, image views, and
+reviews expose only their bounded semantic `details`. Message, reasoning, plan, compaction, and
+unknown items have no details. Review details are required and distinguish an entered target from
+an exited report. There is no metadata or provider-native attribute bag; source evidence belongs
+outside the portable event. File-change producers can use `compareStringsByUnicodeCodePoint` to
+emit the canonical path ordering required by the protocol across both BMP and supplementary
+Unicode characters.
+
+## Errors and trust
+
+Throwing parsers raise `AgentProtocolValidationError`, a `TypeError` with stable, JSON-safe
+`issues`. Each corresponding `safeParse...` function returns either parsed data or the same issue
+array without throwing. Callers should branch on that public result or error class, not on Zod
+classes or native issue objects.
+
+Opaque identifiers provide correlation, not authorization. A host must authorize the actor,
+select the provider instance, constrain the working directory, and map product identities before
+constructing protocol input. Unknown fields are rejected; the protocol has no metadata escape
+hatch for carrying authority or private provider evidence. Portable JSON objects also reject the
+prototype-sensitive keys `__proto__`, `constructor`, and `prototype`; ordinary parsers and the
+published JSON Schemas enforce the same rule. Plan-step and progress identifiers, diagnostic codes,
+messages, and error context must contain non-whitespace content without surrounding whitespace so
+validated protocol output remains canonical across transports and consumers.
+
+## Versioning and release
+
+The package is at `0.1.0` while the public API is still being proven with external adapters. Minor
+releases may include breaking changes during this beta period. Every such change will be called out
+in the release notes. Protocol V6 is independent of any host transport or product persistence
+version.
+
+The repository release proof builds and packs `@agen-ai/validation`, this package, and
+`@agen-ai/agent-runtime`; rejects workspace-only or private references; then typechecks and runs a
+consumer outside the monorepo:
+
+From the public repository root, run `pnpm check` to execute the same packed-consumer proof.
+
+That command does not publish. Registry publication, provenance submission, tags, and release
+credentials require a separately authorized release.

package/dist/artifacts/index.d.ts

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

package/dist/artifacts/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/artifacts/parsers.d.ts

@@ -0,0 +1,5 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentArtifactDescriptor } from './types.js';
+export declare function parseAgentArtifactDescriptor(input: unknown): AgentArtifactDescriptor;
+export declare function safeParseAgentArtifactDescriptor(input: unknown): AgentProtocolParseResult<AgentArtifactDescriptor>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/artifacts/parsers.js

@@ -0,0 +1,12 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import { AgentArtifactDescriptorSchema } from "../zod/artifacts.js";
+function parseAgentArtifactDescriptor(input) {
+  return parseWithSchema(AgentArtifactDescriptorSchema, input);
+}
+function safeParseAgentArtifactDescriptor(input) {
+  return safeParseWithSchema(AgentArtifactDescriptorSchema, input);
+}
+export {
+  parseAgentArtifactDescriptor,
+  safeParseAgentArtifactDescriptor
+};

package/dist/artifacts/types.d.ts

@@ -0,0 +1,19 @@
+import type { AgentArtifactId } from '../foundation/index.js';
+export declare const AGENT_ARTIFACT_KINDS: readonly ["plan", "diff", "file", "log", "image", "report", "other"];
+export declare const AGENT_ARTIFACT_DISPLAY_NAME_MAX_LENGTH = 200;
+export declare const AGENT_ARTIFACT_BYTE_SIZE_MAX: number;
+export type AgentArtifactKind = (typeof AGENT_ARTIFACT_KINDS)[number];
+export interface AgentArtifactDigest {
+    readonly algorithm: 'sha256';
+    readonly value: string;
+}
+export interface AgentArtifactDescriptor {
+    readonly artifactId: AgentArtifactId;
+    readonly kind: AgentArtifactKind;
+    readonly displayName: string;
+    readonly mediaType?: string;
+    readonly byteSize?: number;
+    readonly digest?: AgentArtifactDigest;
+    readonly summary?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/artifacts/types.js

@@ -0,0 +1,16 @@
+const AGENT_ARTIFACT_KINDS = [
+  "plan",
+  "diff",
+  "file",
+  "log",
+  "image",
+  "report",
+  "other"
+];
+const AGENT_ARTIFACT_DISPLAY_NAME_MAX_LENGTH = 200;
+const AGENT_ARTIFACT_BYTE_SIZE_MAX = Number.MAX_SAFE_INTEGER;
+export {
+  AGENT_ARTIFACT_BYTE_SIZE_MAX,
+  AGENT_ARTIFACT_DISPLAY_NAME_MAX_LENGTH,
+  AGENT_ARTIFACT_KINDS
+};

package/dist/capabilities/index.d.ts

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

package/dist/capabilities/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/capabilities/parsers.d.ts

@@ -0,0 +1,6 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentCapabilities } from './types.js';
+export declare function parseAgentCapabilities(input: unknown): AgentCapabilities;
+export declare function safeParseAgentCapabilities(input: unknown): AgentProtocolParseResult<AgentCapabilities>;
+export declare function matchesAgentCapabilities(actual: unknown, expected: unknown): boolean;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/capabilities/parsers.js

@@ -0,0 +1,18 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import { AgentCapabilitiesSchema } from "../zod/capabilities.js";
+function parseAgentCapabilities(input) {
+  return parseWithSchema(AgentCapabilitiesSchema, input);
+}
+function safeParseAgentCapabilities(input) {
+  return safeParseWithSchema(AgentCapabilitiesSchema, input);
+}
+function matchesAgentCapabilities(actual, expected) {
+  const parsedActual = safeParseAgentCapabilities(actual);
+  const parsedExpected = safeParseAgentCapabilities(expected);
+  return parsedActual.success && parsedExpected.success && JSON.stringify(parsedActual.data) === JSON.stringify(parsedExpected.data);
+}
+export {
+  matchesAgentCapabilities,
+  parseAgentCapabilities,
+  safeParseAgentCapabilities
+};

package/dist/capabilities/types.d.ts

@@ -0,0 +1,96 @@
+import type { AgentArtifactKind } from '../artifacts/index.js';
+import type { AgentProviderKey } from '../foundation/index.js';
+import type { AgentImageInputMediaType, AgentImageInputSourceKind, AgentTurnInteractionMode } from '../turns/types.js';
+export declare const AGENT_ELICITATION_MODES: readonly ["unsupported", "text", "structured"];
+export declare const AGENT_FILE_CHANGE_MODES: readonly ["none", "final_diff", "structured"];
+export declare const AGENT_AUTHENTICATION_FLOWS: readonly ["device_code", "browser", "terminal"];
+export type AgentElicitationMode = (typeof AGENT_ELICITATION_MODES)[number];
+export type AgentFileChangeMode = (typeof AGENT_FILE_CHANGE_MODES)[number];
+export type AgentAuthenticationFlow = (typeof AGENT_AUTHENTICATION_FLOWS)[number];
+export type AgentBranchCapability = Readonly<{
+    kind: 'unsupported';
+}> | Readonly<{
+    kind: 'through_turn';
+}>;
+export type AgentElicitationCapability = Readonly<{
+    kind: 'unsupported';
+}> | Readonly<{
+    kind: 'text';
+}> | Readonly<{
+    kind: 'structured';
+}>;
+export interface AgentConfigurationFieldCapability {
+    readonly key: string;
+    readonly optionIds: readonly string[];
+}
+export type AgentConfigurationCapability = Readonly<{
+    kind: 'managed';
+}> | Readonly<{
+    kind: 'selectable';
+    fields: readonly AgentConfigurationFieldCapability[];
+}>;
+export type AgentAuthenticationCapability = Readonly<{
+    kind: 'unsupported';
+}> | Readonly<{
+    kind: 'supported';
+    flows: readonly AgentAuthenticationFlow[];
+}>;
+export type AgentImageInputCapability = Readonly<{
+    kind: 'unsupported';
+}> | Readonly<{
+    kind: 'supported';
+    sourceKinds: readonly AgentImageInputSourceKind[];
+    mediaTypes: readonly AgentImageInputMediaType[];
+    maxImages: number;
+    maxBytesPerImage: number;
+    maxTotalBytes: number;
+    maxWidthPixels: number;
+    maxHeightPixels: number;
+    maxPixelsPerImage: number;
+    supportsImageOnly: boolean;
+}>;
+export interface AgentOperationInputCapability {
+    readonly text: true;
+    readonly images: AgentImageInputCapability;
+}
+export type AgentTurnSteeringCapability = Readonly<{
+    kind: 'unsupported';
+}> | Readonly<{
+    kind: 'supported';
+    input: AgentOperationInputCapability;
+}>;
+export interface AgentCapabilities {
+    readonly protocolVersion: 6;
+    readonly providerKey: AgentProviderKey;
+    readonly sessions: Readonly<{
+        create: true;
+        resume: boolean;
+        branch: AgentBranchCapability;
+    }>;
+    readonly turns: Readonly<{
+        interactionModes: readonly AgentTurnInteractionMode[];
+        interrupt: boolean;
+        steer: AgentTurnSteeringCapability;
+    }>;
+    readonly requests: Readonly<{
+        approval: boolean;
+        elicitation: AgentElicitationCapability;
+    }>;
+    readonly input: AgentOperationInputCapability;
+    readonly output: Readonly<{
+        streaming: boolean;
+        plans: boolean;
+        fileChanges: AgentFileChangeMode;
+        artifactKinds: readonly AgentArtifactKind[];
+    }>;
+    readonly configuration: AgentConfigurationCapability;
+    readonly interactionExtensions: Readonly<{
+        slashCommands: boolean;
+        mcp: boolean;
+        subagents: boolean;
+        imageGeneration: boolean;
+    }>;
+    readonly authentication: AgentAuthenticationCapability;
+    readonly versionReporting: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/capabilities/types.js

@@ -0,0 +1,20 @@
+const AGENT_ELICITATION_MODES = [
+  "unsupported",
+  "text",
+  "structured"
+];
+const AGENT_FILE_CHANGE_MODES = [
+  "none",
+  "final_diff",
+  "structured"
+];
+const AGENT_AUTHENTICATION_FLOWS = [
+  "device_code",
+  "browser",
+  "terminal"
+];
+export {
+  AGENT_AUTHENTICATION_FLOWS,
+  AGENT_ELICITATION_MODES,
+  AGENT_FILE_CHANGE_MODES
+};

package/dist/events/index.d.ts

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

package/dist/events/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/events/parsers.d.ts

@@ -0,0 +1,6 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentEvent } from './types.js';
+export declare function parseAgentEvent(input: unknown): AgentEvent;
+export declare function safeParseAgentEvent(input: unknown): AgentProtocolParseResult<AgentEvent>;
+export declare function createAgentEvent(input: AgentEvent): AgentEvent;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/events/parsers.js

@@ -0,0 +1,16 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import { AgentEventSchema } from "../zod/events.js";
+function parseAgentEvent(input) {
+  return parseWithSchema(AgentEventSchema, input);
+}
+function safeParseAgentEvent(input) {
+  return safeParseWithSchema(AgentEventSchema, input);
+}
+function createAgentEvent(input) {
+  return parseAgentEvent(input);
+}
+export {
+  createAgentEvent,
+  parseAgentEvent,
+  safeParseAgentEvent
+};

package/dist/events/types.d.ts

@@ -0,0 +1,78 @@
+import type { AgentArtifactDescriptor } from '../artifacts/index.js';
+import type { AgentArtifactId, AgentError, AgentErrorContext, AgentIsoDateTime, AgentItemId, AgentProviderRefs, AgentRequestId, AgentSessionId, AgentTurnId } from '../foundation/index.js';
+import type { AgentRequest } from '../requests/index.js';
+import type { AgentContentStreamKind, AgentDiffSummary, AgentItemSnapshot, AgentPlanStep, AgentTurnCompletedPayload, AgentTurnState } from '../turns/index.js';
+export declare const AGENT_EVENT_TYPES: readonly ["turn.started", "turn.state_changed", "turn.completed", "item.started", "item.updated", "item.completed", "content.delta", "turn.plan.updated", "turn.plan.proposed", "turn.diff.updated", "request.opened", "progress.updated", "artifact.referenced", "runtime.warning", "runtime.error", "provider.diagnostic"];
+export type AgentEventType = (typeof AGENT_EVENT_TYPES)[number];
+interface AgentEventBase<Type extends AgentEventType, Payload> {
+    readonly protocolVersion: 6;
+    readonly type: Type;
+    readonly sessionId: AgentSessionId;
+    readonly providerRefs?: AgentProviderRefs;
+    readonly occurredAt: AgentIsoDateTime;
+    readonly payload: Payload;
+}
+interface AgentTurnEventBase<Type extends AgentEventType, Payload> extends AgentEventBase<Type, Payload> {
+    readonly turnId: AgentTurnId;
+}
+interface AgentOptionallyTurnScopedEventBase<Type extends AgentEventType, Payload> extends AgentEventBase<Type, Payload> {
+    readonly turnId?: AgentTurnId;
+}
+export type AgentTurnStartedEvent = AgentTurnEventBase<'turn.started', Readonly<{
+    message?: string;
+}>>;
+export type AgentTurnStateChangedEvent = AgentTurnEventBase<'turn.state_changed', Readonly<{
+    state: AgentTurnState;
+    requestId?: AgentRequestId;
+    message?: string;
+}>>;
+export type AgentTurnCompletedEvent = AgentTurnEventBase<'turn.completed', AgentTurnCompletedPayload>;
+export type AgentItemStartedEvent = AgentTurnEventBase<'item.started', AgentItemSnapshot>;
+export type AgentItemUpdatedEvent = AgentTurnEventBase<'item.updated', AgentItemSnapshot>;
+export type AgentItemCompletedEvent = AgentTurnEventBase<'item.completed', AgentItemSnapshot>;
+export type AgentContentDeltaEvent = AgentTurnEventBase<'content.delta', Readonly<{
+    itemId: AgentItemId;
+    streamKind: AgentContentStreamKind;
+    delta: string;
+}>>;
+export type AgentPlanUpdatedEvent = AgentTurnEventBase<'turn.plan.updated', Readonly<{
+    explanation?: string;
+    steps: readonly AgentPlanStep[];
+}>>;
+export type AgentPlanProposedEvent = AgentTurnEventBase<'turn.plan.proposed', Readonly<{
+    artifactId: AgentArtifactId;
+    requestId: AgentRequestId;
+}>>;
+export type AgentDiffUpdatedEvent = AgentTurnEventBase<'turn.diff.updated', AgentDiffSummary>;
+export type AgentRequestOpenedEvent = AgentTurnEventBase<'request.opened', Readonly<{
+    request: AgentRequest;
+}>>;
+export type AgentProgressUpdatedEvent = AgentTurnEventBase<'progress.updated', Readonly<{
+    progressId: string;
+    kind: 'task' | 'hook' | 'tool' | 'unknown';
+    phase: 'started' | 'updated' | 'completed';
+    title?: string;
+    message?: string;
+    current?: number;
+    total?: number;
+}>>;
+export type AgentArtifactReferencedEvent = AgentOptionallyTurnScopedEventBase<'artifact.referenced', Readonly<{
+    artifact: AgentArtifactDescriptor;
+}>>;
+export type AgentRuntimeWarningEvent = AgentOptionallyTurnScopedEventBase<'runtime.warning', Readonly<{
+    code: string;
+    message: string;
+    retryable?: boolean;
+    context?: AgentErrorContext;
+}>>;
+export type AgentRuntimeErrorEvent = AgentOptionallyTurnScopedEventBase<'runtime.error', Readonly<{
+    error: AgentError;
+}>>;
+export type AgentProviderDiagnosticEvent = AgentOptionallyTurnScopedEventBase<'provider.diagnostic', Readonly<{
+    code: string;
+    message: string;
+    context?: AgentErrorContext;
+}>>;
+export type AgentEvent = AgentTurnStartedEvent | AgentTurnStateChangedEvent | AgentTurnCompletedEvent | AgentItemStartedEvent | AgentItemUpdatedEvent | AgentItemCompletedEvent | AgentContentDeltaEvent | AgentPlanUpdatedEvent | AgentPlanProposedEvent | AgentDiffUpdatedEvent | AgentRequestOpenedEvent | AgentProgressUpdatedEvent | AgentArtifactReferencedEvent | AgentRuntimeWarningEvent | AgentRuntimeErrorEvent | AgentProviderDiagnosticEvent;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/events/types.js

@@ -0,0 +1,21 @@
+const AGENT_EVENT_TYPES = [
+  "turn.started",
+  "turn.state_changed",
+  "turn.completed",
+  "item.started",
+  "item.updated",
+  "item.completed",
+  "content.delta",
+  "turn.plan.updated",
+  "turn.plan.proposed",
+  "turn.diff.updated",
+  "request.opened",
+  "progress.updated",
+  "artifact.referenced",
+  "runtime.warning",
+  "runtime.error",
+  "provider.diagnostic"
+];
+export {
+  AGENT_EVENT_TYPES
+};

package/dist/foundation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './parsers.js';
+export * from './ordering.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/foundation/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./parsers.js";
+export * from "./ordering.js";

package/dist/foundation/ordering.d.ts

@@ -0,0 +1,2 @@
+export declare function compareStringsByUnicodeCodePoint(left: string, right: string): number;
+//# sourceMappingURL=ordering.d.ts.map

package/dist/foundation/ordering.js

@@ -0,0 +1,15 @@
+function compareStringsByUnicodeCodePoint(left, right) {
+  const leftIterator = left[Symbol.iterator]();
+  const rightIterator = right[Symbol.iterator]();
+  while (true) {
+    const leftCodePoint = leftIterator.next();
+    const rightCodePoint = rightIterator.next();
+    if (leftCodePoint.done) return rightCodePoint.done ? 0 : -1;
+    if (rightCodePoint.done) return 1;
+    const difference = (leftCodePoint.value.codePointAt(0) ?? 0) - (rightCodePoint.value.codePointAt(0) ?? 0);
+    if (difference !== 0) return difference;
+  }
+}
+export {
+  compareStringsByUnicodeCodePoint
+};

package/dist/foundation/parsers.d.ts

@@ -0,0 +1,39 @@
+import type { AgentArtifactId, AgentConfigurationRevisionId, AgentError, AgentInstanceId, AgentIsoDateTime, AgentItemId, AgentJsonValue, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentProviderItemRef, AgentProviderKey, AgentProviderRefs, AgentProviderRequestRef, AgentProviderTurnRef, AgentRequestFieldId, AgentRequestId, AgentSessionId, AgentTurnId } from './types.js';
+import type { AgentProtocolParseResult } from './validation.js';
+export declare const parseAgentInstanceId: (input: unknown) => AgentInstanceId;
+export declare const safeParseAgentInstanceId: (input: unknown) => AgentProtocolParseResult<AgentInstanceId>;
+export declare const parseAgentSessionId: (input: unknown) => AgentSessionId;
+export declare const safeParseAgentSessionId: (input: unknown) => AgentProtocolParseResult<AgentSessionId>;
+export declare const parseAgentTurnId: (input: unknown) => AgentTurnId;
+export declare const safeParseAgentTurnId: (input: unknown) => AgentProtocolParseResult<AgentTurnId>;
+export declare const parseAgentItemId: (input: unknown) => AgentItemId;
+export declare const safeParseAgentItemId: (input: unknown) => AgentProtocolParseResult<AgentItemId>;
+export declare const parseAgentRequestId: (input: unknown) => AgentRequestId;
+export declare const safeParseAgentRequestId: (input: unknown) => AgentProtocolParseResult<AgentRequestId>;
+export declare const parseAgentRequestFieldId: (input: unknown) => AgentRequestFieldId;
+export declare const safeParseAgentRequestFieldId: (input: unknown) => AgentProtocolParseResult<AgentRequestFieldId>;
+export declare const parseAgentArtifactId: (input: unknown) => AgentArtifactId;
+export declare const safeParseAgentArtifactId: (input: unknown) => AgentProtocolParseResult<AgentArtifactId>;
+export declare const parseAgentConfigurationRevisionId: (input: unknown) => AgentConfigurationRevisionId;
+export declare const safeParseAgentConfigurationRevisionId: (input: unknown) => AgentProtocolParseResult<AgentConfigurationRevisionId>;
+export declare const parseAgentProviderConversationId: (input: unknown) => AgentProviderConversationId;
+export declare const safeParseAgentProviderConversationId: (input: unknown) => AgentProtocolParseResult<AgentProviderConversationId>;
+export declare const parseAgentProviderHistoryAnchor: (input: unknown) => AgentProviderHistoryAnchor;
+export declare const safeParseAgentProviderHistoryAnchor: (input: unknown) => AgentProtocolParseResult<AgentProviderHistoryAnchor>;
+export declare const parseAgentProviderTurnRef: (input: unknown) => AgentProviderTurnRef;
+export declare const safeParseAgentProviderTurnRef: (input: unknown) => AgentProtocolParseResult<AgentProviderTurnRef>;
+export declare const parseAgentProviderItemRef: (input: unknown) => AgentProviderItemRef;
+export declare const safeParseAgentProviderItemRef: (input: unknown) => AgentProtocolParseResult<AgentProviderItemRef>;
+export declare const parseAgentProviderRequestRef: (input: unknown) => AgentProviderRequestRef;
+export declare const safeParseAgentProviderRequestRef: (input: unknown) => AgentProtocolParseResult<AgentProviderRequestRef>;
+export declare function parseAgentProviderKey(input: unknown): AgentProviderKey;
+export declare function safeParseAgentProviderKey(input: unknown): AgentProtocolParseResult<AgentProviderKey>;
+export declare function parseAgentIsoDateTime(input: unknown): AgentIsoDateTime;
+export declare function safeParseAgentIsoDateTime(input: unknown): AgentProtocolParseResult<AgentIsoDateTime>;
+export declare function parseAgentJsonValue(input: unknown): AgentJsonValue;
+export declare function safeParseAgentJsonValue(input: unknown): AgentProtocolParseResult<AgentJsonValue>;
+export declare function parseAgentProviderRefs(input: unknown): AgentProviderRefs;
+export declare function safeParseAgentProviderRefs(input: unknown): AgentProtocolParseResult<AgentProviderRefs>;
+export declare function parseAgentError(input: unknown): AgentError;
+export declare function safeParseAgentError(input: unknown): AgentProtocolParseResult<AgentError>;
+//# sourceMappingURL=parsers.d.ts.map