recoder-a2a-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1798 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  A2AErrorCategoryEnum: () => A2AErrorCategoryEnum,
+  A2AErrorCodeEnum: () => A2AErrorCodeEnum,
+  A2AErrorSeverityEnum: () => A2AErrorSeverityEnum,
+  A2AStructuredError: () => A2AStructuredError,
+  A2A_ERROR_CODE_REGISTRY: () => A2A_ERROR_CODE_REGISTRY,
+  ALLOWED_STATE_TRANSITIONS: () => ALLOWED_STATE_TRANSITIONS,
+  AUDIT_EVENT_TYPES: () => AUDIT_EVENT_TYPES,
+  AUDIT_EVENT_VERSION: () => AUDIT_EVENT_VERSION,
+  AuditActorKindEnum: () => AuditActorKindEnum,
+  AuditEventTypeEnum: () => AuditEventTypeEnum,
+  AuditSeverityEnum: () => AuditSeverityEnum,
+  AuditTargetKindEnum: () => AuditTargetKindEnum,
+  TASK_ENVELOPE_VERSION: () => TASK_ENVELOPE_VERSION,
+  TASK_STATES: () => TASK_STATES,
+  TERMINAL_TASK_STATES: () => TERMINAL_TASK_STATES,
+  TaskStateEnum: () => TaskStateEnum,
+  a2aErrorToTaskErrorInfo: () => a2aErrorToTaskErrorInfo,
+  assertAuditEvent: () => assertAuditEvent,
+  assertTaskEnvelope: () => assertTaskEnvelope,
+  buildA2AError: () => buildA2AError,
+  buildClaudeEnvelope: () => buildClaudeEnvelope,
+  buildCodexEnvelope: () => buildCodexEnvelope,
+  cancelEnvelope: () => cancelEnvelope,
+  canonicalToClaudeState: () => canonicalToClaudeState,
+  canonicalToCodexState: () => canonicalToCodexState,
+  canonicalToConnectorState: () => canonicalToConnectorState,
+  checkConnectorTransition: () => checkConnectorTransition,
+  completeEnvelope: () => completeEnvelope,
+  createAuditEvent: () => createAuditEvent,
+  createTaskEnvelope: () => createTaskEnvelope,
+  emitAuditForTransition: () => emitAuditForTransition,
+  emitConnectorAttached: () => emitConnectorAttached,
+  emitConnectorError: () => emitConnectorError,
+  emitConnectorHealth: () => emitConnectorHealth,
+  emitPolicyApproved: () => emitPolicyApproved,
+  emitPolicyChecked: () => emitPolicyChecked,
+  emitPolicyDenied: () => emitPolicyDenied,
+  emitTaskCancelled: () => emitTaskCancelled,
+  emitTaskCompleted: () => emitTaskCompleted,
+  emitTaskFailed: () => emitTaskFailed,
+  emitTaskInputRequired: () => emitTaskInputRequired,
+  emitTaskProgress: () => emitTaskProgress,
+  emitTaskStarted: () => emitTaskStarted,
+  emitTaskSubmitted: () => emitTaskSubmitted,
+  failEnvelope: () => failEnvelope,
+  getErrorCodeMeta: () => getErrorCodeMeta,
+  isA2AErrorCode: () => isA2AErrorCode,
+  isConnectorTerminalState: () => isConnectorTerminalState,
+  isTerminalState: () => isTerminalState,
+  isValidA2AError: () => isValidA2AError,
+  isValidAuditEvent: () => isValidAuditEvent,
+  isValidTaskEnvelope: () => isValidTaskEnvelope,
+  isValidTransition: () => isValidTransition,
+  mapClaudeError: () => mapClaudeError,
+  mapClaudeState: () => mapClaudeState,
+  mapClaudeStateStrict: () => mapClaudeStateStrict,
+  mapCodexError: () => mapCodexError,
+  mapCodexState: () => mapCodexState,
+  mapCodexStateStrict: () => mapCodexStateStrict,
+  mapConnectorError: () => mapConnectorError,
+  mapConnectorState: () => mapConnectorState,
+  mapConnectorStateStrict: () => mapConnectorStateStrict,
+  mapHttpError: () => mapHttpError,
+  startEnvelope: () => startEnvelope,
+  transitionTaskEnvelope: () => transitionTaskEnvelope,
+  validateA2AError: () => validateA2AError,
+  validateAuditEvent: () => validateAuditEvent,
+  validateTaskEnvelope: () => validateTaskEnvelope,
+  wrapUnknownError: () => wrapUnknownError
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../shared/src/a2a/schemas/task-envelope.ts
+var TASK_ENVELOPE_VERSION = "1.0.0";
+var TaskStateEnum = {
+  /** Task has been created and is awaiting execution. */
+  Submitted: "submitted",
+  /** Task is actively being processed by the assignee agent. */
+  Working: "working",
+  /** The assignee needs additional input before it can continue. */
+  InputRequired: "input-required",
+  /** Task finished successfully. */
+  Completed: "completed",
+  /** Task terminated with an error. */
+  Failed: "failed",
+  /** Task was explicitly cancelled by a requester or operator. */
+  Cancelled: "cancelled"
+};
+var TASK_STATES = [
+  TaskStateEnum.Submitted,
+  TaskStateEnum.Working,
+  TaskStateEnum.InputRequired,
+  TaskStateEnum.Completed,
+  TaskStateEnum.Failed,
+  TaskStateEnum.Cancelled
+];
+var TERMINAL_TASK_STATES = /* @__PURE__ */ new Set([
+  TaskStateEnum.Completed,
+  TaskStateEnum.Failed,
+  TaskStateEnum.Cancelled
+]);
+function isTerminalState(state) {
+  return TERMINAL_TASK_STATES.has(state);
+}
+function createTaskEnvelope(input) {
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    envelope_version: TASK_ENVELOPE_VERSION,
+    id: input.id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    trace_id: input.trace_id,
+    parent_id: input.parent_id,
+    state: input.initial_state ?? TaskStateEnum.Submitted,
+    history: [],
+    requester: input.requester,
+    assignee: input.assignee,
+    connector: input.connector,
+    payload: input.payload,
+    created_at: now,
+    updated_at: now,
+    metadata: input.metadata,
+    tags: input.tags
+  };
+}
+var ALLOWED_STATE_TRANSITIONS = {
+  [TaskStateEnum.Submitted]: [TaskStateEnum.Working, TaskStateEnum.Cancelled, TaskStateEnum.Failed],
+  [TaskStateEnum.Working]: [
+    TaskStateEnum.Completed,
+    TaskStateEnum.Failed,
+    TaskStateEnum.Cancelled,
+    TaskStateEnum.InputRequired
+  ],
+  [TaskStateEnum.InputRequired]: [TaskStateEnum.Working, TaskStateEnum.Cancelled, TaskStateEnum.Failed],
+  [TaskStateEnum.Completed]: [],
+  [TaskStateEnum.Failed]: [],
+  [TaskStateEnum.Cancelled]: []
+};
+function isValidTransition(from, to) {
+  return (ALLOWED_STATE_TRANSITIONS[from] ?? []).includes(to);
+}
+function transitionTaskEnvelope(envelope, to, options) {
+  if (!isValidTransition(envelope.state, to)) {
+    throw new Error(
+      `Invalid task state transition: ${envelope.state} -> ${to} (task ${envelope.id})`
+    );
+  }
+  const now = options?.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const transition = {
+    from: envelope.state,
+    to,
+    transitioned_at: now,
+    reason: options?.reason,
+    triggered_by: options?.triggered_by
+  };
+  return {
+    ...envelope,
+    state: to,
+    updated_at: now,
+    history: [...envelope.history ?? [], transition]
+  };
+}
+
+// ../../shared/src/a2a/schemas/audit-event.ts
+var AUDIT_EVENT_VERSION = "1.0.0";
+var AuditEventTypeEnum = {
+  // -- task lifecycle ---------------------------------------------------------
+  /** A new task was submitted. */
+  TaskSubmitted: "task.submitted",
+  /** Task execution started. */
+  TaskStarted: "task.started",
+  /** Task made progress (intermediate update). */
+  TaskProgress: "task.progress",
+  /** Assignee agent needs additional input. */
+  TaskInputRequired: "task.input_required",
+  /** Task completed successfully. */
+  TaskCompleted: "task.completed",
+  /** Task failed with an error. */
+  TaskFailed: "task.failed",
+  /** Task was cancelled. */
+  TaskCancelled: "task.cancelled",
+  // -- policy decisions -------------------------------------------------------
+  /** A policy check was performed. */
+  PolicyChecked: "policy.checked",
+  /** A policy action was approved (auto or prompt). */
+  PolicyApproved: "policy.approved",
+  /** A policy action was denied. */
+  PolicyDenied: "policy.denied",
+  // -- connector events -------------------------------------------------------
+  /** A connector was attached to an agent. */
+  ConnectorAttached: "connector.attached",
+  /** A connector was detached from an agent. */
+  ConnectorDetached: "connector.detached",
+  /** A connector emitted a diagnostic or health event. */
+  ConnectorHealth: "connector.health",
+  /** A connector encountered an error. */
+  ConnectorError: "connector.error",
+  // -- agent registry ---------------------------------------------------------
+  /** An agent was registered. */
+  AgentRegistered: "agent.registered",
+  /** An agent was unregistered. */
+  AgentUnregistered: "agent.unregistered",
+  /** An agent's capabilities were updated. */
+  AgentUpdated: "agent.updated",
+  // -- collaboration ----------------------------------------------------------
+  /** A collaboration channel was created. */
+  ChannelCreated: "collaboration.channel_created",
+  /** A collaboration thread was created. */
+  ThreadCreated: "collaboration.thread_created",
+  /** A message was sent in a collaboration thread. */
+  MessageSent: "collaboration.message_sent",
+  // -- system -----------------------------------------------------------------
+  /** A system-level configuration change. */
+  SystemConfig: "system.config",
+  /** A system-level error or warning. */
+  SystemError: "system.error"
+};
+var AUDIT_EVENT_TYPES = Object.values(AuditEventTypeEnum);
+var AuditActorKindEnum = {
+  /** An AI agent. */
+  Agent: "agent",
+  /** A human user. */
+  User: "user",
+  /** An internal system service (e.g. policy engine, scheduler). */
+  System: "system",
+  /** A connector/adapter. */
+  Connector: "connector"
+};
+var AuditTargetKindEnum = {
+  Task: "task",
+  Agent: "agent",
+  Connector: "connector",
+  Channel: "channel",
+  Thread: "thread",
+  Message: "message",
+  Policy: "policy",
+  Workspace: "workspace",
+  System: "system"
+};
+var AuditSeverityEnum = {
+  /** Informational -- normal operation. */
+  Info: "info",
+  /** Warning -- something unexpected but not an error. */
+  Warning: "warning",
+  /** Error -- an operation failed. */
+  Error: "error",
+  /** Critical -- a severe failure requiring immediate attention. */
+  Critical: "critical"
+};
+function createAuditEvent(input) {
+  return {
+    schema_version: AUDIT_EVENT_VERSION,
+    id: input.id,
+    event_type: input.event_type,
+    severity: input.severity,
+    actor: input.actor,
+    target: input.target,
+    trace_id: input.trace_id,
+    parent_event_id: input.parent_event_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    timestamp: input.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    duration_ms: input.duration_ms,
+    policy: input.policy,
+    metadata: input.metadata,
+    tags: input.tags
+  };
+}
+
+// ../../shared/src/a2a/schemas/error-taxonomy.ts
+var A2AErrorSeverityEnum = {
+  /** Low impact -- informational or gracefully handled. */
+  Low: "low",
+  /** Medium impact -- degraded functionality but system continues. */
+  Medium: "medium",
+  /** High impact -- a key operation failed and needs attention. */
+  High: "high",
+  /** Critical -- system stability at risk, immediate action required. */
+  Critical: "critical"
+};
+var A2AErrorCategoryEnum = {
+  /** Errors in the envelope or message format (validation, parsing). */
+  Envelope: "envelope",
+  /** Errors in the connector/adapter layer. */
+  Connector: "connector",
+  /** Errors in the policy/approval plane. */
+  Policy: "policy",
+  /** Errors in the task orchestration layer. */
+  Task: "task",
+  /** Errors in the agent registry. */
+  Registry: "registry",
+  /** Errors in the collaboration service. */
+  Collaboration: "collaboration",
+  /** Transport/network-level errors. */
+  Transport: "transport",
+  /** Authentication and authorization errors. */
+  Auth: "auth",
+  /** Rate-limiting and quota errors. */
+  RateLimit: "rate_limit",
+  /** Internal / unexpected errors. */
+  Internal: "internal"
+};
+var A2AErrorCodeEnum = {
+  // -- envelope ---------------------------------------------------------------
+  /** The envelope failed structural validation. */
+  InvalidEnvelope: "INVALID_ENVELOPE",
+  /** The envelope version is unsupported. */
+  UnsupportedEnvelopeVersion: "UNSUPPORTED_ENVELOPE_VERSION",
+  /** A required field is missing from the envelope. */
+  MissingEnvelopeField: "MISSING_ENVELOPE_FIELD",
+  /** The payload kind is unknown or malformed. */
+  InvalidPayload: "INVALID_PAYLOAD",
+  /** Compatibility alias used by older gateway/workspace routes. */
+  InvalidParams: "INVALID_ENVELOPE",
+  // -- connector --------------------------------------------------------------
+  /** No connector is attached for the target agent. */
+  ConnectorNotFound: "CONNECTOR_NOT_FOUND",
+  /** The connector timed out during task execution. */
+  ConnectorTimeout: "CONNECTOR_TIMEOUT",
+  /** The connector returned an unexpected error. */
+  ConnectorError: "CONNECTOR_ERROR",
+  /** The connector is temporarily unavailable. */
+  ConnectorUnavailable: "CONNECTOR_UNAVAILABLE",
+  /** Protocol mismatch between connector and remote agent. */
+  ProtocolMismatch: "PROTOCOL_MISMATCH",
+  // -- policy -----------------------------------------------------------------
+  /** The policy plane denied the requested action. */
+  PolicyDenied: "POLICY_DENIED",
+  /** No prompt handler is configured for the policy rule. */
+  PolicyHandlerMissing: "POLICY_HANDLER_MISSING",
+  /** The policy evaluation timed out. */
+  PolicyTimeout: "POLICY_TIMEOUT",
+  // -- task -------------------------------------------------------------------
+  /** The task was not found. */
+  TaskNotFound: "TASK_NOT_FOUND",
+  /** An invalid state transition was attempted. */
+  InvalidStateTransition: "INVALID_STATE_TRANSITION",
+  /** The task has already reached a terminal state. */
+  TaskAlreadyTerminal: "TASK_ALREADY_TERMINAL",
+  /** The task failed during execution. */
+  TaskExecutionFailed: "TASK_EXECUTION_FAILED",
+  /** The task was cancelled. */
+  TaskCancelled: "TASK_CANCELLED",
+  // -- registry ---------------------------------------------------------------
+  /** The agent was not found in the registry. */
+  AgentNotFound: "AGENT_NOT_FOUND",
+  /** The agent is already registered. */
+  AgentAlreadyRegistered: "AGENT_ALREADY_REGISTERED",
+  /** The agent does not have the requested capability. */
+  CapabilityNotFound: "CAPABILITY_NOT_FOUND",
+  // -- collaboration ----------------------------------------------------------
+  /** The channel was not found. */
+  ChannelNotFound: "CHANNEL_NOT_FOUND",
+  /** The thread was not found. */
+  ThreadNotFound: "THREAD_NOT_FOUND",
+  /** The message was not found. */
+  MessageNotFound: "MESSAGE_NOT_FOUND",
+  /** The sender is not a member of the target channel. */
+  NotChannelMember: "NOT_CHANNEL_MEMBER",
+  // -- transport --------------------------------------------------------------
+  /** A network request failed. */
+  NetworkError: "NETWORK_ERROR",
+  /** The remote endpoint returned an unexpected status. */
+  UnexpectedStatus: "UNEXPECTED_STATUS",
+  /** The request or response body could not be parsed. */
+  SerializationError: "SERIALIZATION_ERROR",
+  // -- auth -------------------------------------------------------------------
+  /** Authentication failed (invalid or missing credentials). */
+  AuthenticationFailed: "AUTHENTICATION_FAILED",
+  /** The caller is not authorized for the requested operation. */
+  AuthorizationDenied: "AUTHORIZATION_DENIED",
+  /** The access token has expired. */
+  TokenExpired: "TOKEN_EXPIRED",
+  // -- rate limit -------------------------------------------------------------
+  /** The caller has exceeded the rate limit. */
+  RateLimitExceeded: "RATE_LIMIT_EXCEEDED",
+  /** The caller has exceeded their usage quota. */
+  QuotaExceeded: "QUOTA_EXCEEDED",
+  // -- internal ---------------------------------------------------------------
+  /** An unexpected internal error occurred. */
+  InternalError: "INTERNAL_ERROR",
+  /** A configuration error was detected. */
+  ConfigurationError: "CONFIGURATION_ERROR"
+};
+var A2A_ERROR_CODE_REGISTRY = {
+  // envelope
+  [A2AErrorCodeEnum.InvalidEnvelope]: {
+    code: A2AErrorCodeEnum.InvalidEnvelope,
+    category: A2AErrorCategoryEnum.Envelope,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The envelope failed structural validation."
+  },
+  [A2AErrorCodeEnum.UnsupportedEnvelopeVersion]: {
+    code: A2AErrorCodeEnum.UnsupportedEnvelopeVersion,
+    category: A2AErrorCategoryEnum.Envelope,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The envelope version is not supported by this service."
+  },
+  [A2AErrorCodeEnum.MissingEnvelopeField]: {
+    code: A2AErrorCodeEnum.MissingEnvelopeField,
+    category: A2AErrorCategoryEnum.Envelope,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "A required field is missing from the envelope."
+  },
+  [A2AErrorCodeEnum.InvalidPayload]: {
+    code: A2AErrorCodeEnum.InvalidPayload,
+    category: A2AErrorCategoryEnum.Envelope,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The payload kind is unknown or malformed."
+  },
+  // connector
+  [A2AErrorCodeEnum.ConnectorNotFound]: {
+    code: A2AErrorCodeEnum.ConnectorNotFound,
+    category: A2AErrorCategoryEnum.Connector,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: false,
+    description: "No connector is attached for the target agent."
+  },
+  [A2AErrorCodeEnum.ConnectorTimeout]: {
+    code: A2AErrorCodeEnum.ConnectorTimeout,
+    category: A2AErrorCategoryEnum.Connector,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: true,
+    description: "The connector timed out during task execution."
+  },
+  [A2AErrorCodeEnum.ConnectorError]: {
+    code: A2AErrorCodeEnum.ConnectorError,
+    category: A2AErrorCategoryEnum.Connector,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: true,
+    description: "The connector returned an unexpected error."
+  },
+  [A2AErrorCodeEnum.ConnectorUnavailable]: {
+    code: A2AErrorCodeEnum.ConnectorUnavailable,
+    category: A2AErrorCategoryEnum.Connector,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: true,
+    description: "The connector is temporarily unavailable."
+  },
+  [A2AErrorCodeEnum.ProtocolMismatch]: {
+    code: A2AErrorCodeEnum.ProtocolMismatch,
+    category: A2AErrorCategoryEnum.Connector,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: false,
+    description: "Protocol mismatch between connector and remote agent."
+  },
+  // policy
+  [A2AErrorCodeEnum.PolicyDenied]: {
+    code: A2AErrorCodeEnum.PolicyDenied,
+    category: A2AErrorCategoryEnum.Policy,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The policy plane denied the requested action."
+  },
+  [A2AErrorCodeEnum.PolicyHandlerMissing]: {
+    code: A2AErrorCodeEnum.PolicyHandlerMissing,
+    category: A2AErrorCategoryEnum.Policy,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "No prompt handler is configured for the policy rule."
+  },
+  [A2AErrorCodeEnum.PolicyTimeout]: {
+    code: A2AErrorCodeEnum.PolicyTimeout,
+    category: A2AErrorCategoryEnum.Policy,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: true,
+    description: "The policy evaluation timed out."
+  },
+  // task
+  [A2AErrorCodeEnum.TaskNotFound]: {
+    code: A2AErrorCodeEnum.TaskNotFound,
+    category: A2AErrorCategoryEnum.Task,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The task was not found."
+  },
+  [A2AErrorCodeEnum.InvalidStateTransition]: {
+    code: A2AErrorCodeEnum.InvalidStateTransition,
+    category: A2AErrorCategoryEnum.Task,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "An invalid state transition was attempted."
+  },
+  [A2AErrorCodeEnum.TaskAlreadyTerminal]: {
+    code: A2AErrorCodeEnum.TaskAlreadyTerminal,
+    category: A2AErrorCategoryEnum.Task,
+    severity: A2AErrorSeverityEnum.Low,
+    retryable: false,
+    description: "The task has already reached a terminal state."
+  },
+  [A2AErrorCodeEnum.TaskExecutionFailed]: {
+    code: A2AErrorCodeEnum.TaskExecutionFailed,
+    category: A2AErrorCategoryEnum.Task,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: true,
+    description: "The task failed during execution."
+  },
+  [A2AErrorCodeEnum.TaskCancelled]: {
+    code: A2AErrorCodeEnum.TaskCancelled,
+    category: A2AErrorCategoryEnum.Task,
+    severity: A2AErrorSeverityEnum.Low,
+    retryable: false,
+    description: "The task was cancelled."
+  },
+  // registry
+  [A2AErrorCodeEnum.AgentNotFound]: {
+    code: A2AErrorCodeEnum.AgentNotFound,
+    category: A2AErrorCategoryEnum.Registry,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The agent was not found in the registry."
+  },
+  [A2AErrorCodeEnum.AgentAlreadyRegistered]: {
+    code: A2AErrorCodeEnum.AgentAlreadyRegistered,
+    category: A2AErrorCategoryEnum.Registry,
+    severity: A2AErrorSeverityEnum.Low,
+    retryable: false,
+    description: "The agent is already registered."
+  },
+  [A2AErrorCodeEnum.CapabilityNotFound]: {
+    code: A2AErrorCodeEnum.CapabilityNotFound,
+    category: A2AErrorCategoryEnum.Registry,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The agent does not have the requested capability."
+  },
+  // collaboration
+  [A2AErrorCodeEnum.ChannelNotFound]: {
+    code: A2AErrorCodeEnum.ChannelNotFound,
+    category: A2AErrorCategoryEnum.Collaboration,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The channel was not found."
+  },
+  [A2AErrorCodeEnum.ThreadNotFound]: {
+    code: A2AErrorCodeEnum.ThreadNotFound,
+    category: A2AErrorCategoryEnum.Collaboration,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The thread was not found."
+  },
+  [A2AErrorCodeEnum.MessageNotFound]: {
+    code: A2AErrorCodeEnum.MessageNotFound,
+    category: A2AErrorCategoryEnum.Collaboration,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The message was not found."
+  },
+  [A2AErrorCodeEnum.NotChannelMember]: {
+    code: A2AErrorCodeEnum.NotChannelMember,
+    category: A2AErrorCategoryEnum.Collaboration,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The sender is not a member of the target channel."
+  },
+  // transport
+  [A2AErrorCodeEnum.NetworkError]: {
+    code: A2AErrorCodeEnum.NetworkError,
+    category: A2AErrorCategoryEnum.Transport,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: true,
+    description: "A network request failed."
+  },
+  [A2AErrorCodeEnum.UnexpectedStatus]: {
+    code: A2AErrorCodeEnum.UnexpectedStatus,
+    category: A2AErrorCategoryEnum.Transport,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: true,
+    description: "The remote endpoint returned an unexpected status."
+  },
+  [A2AErrorCodeEnum.SerializationError]: {
+    code: A2AErrorCodeEnum.SerializationError,
+    category: A2AErrorCategoryEnum.Transport,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The request or response body could not be parsed."
+  },
+  // auth
+  [A2AErrorCodeEnum.AuthenticationFailed]: {
+    code: A2AErrorCodeEnum.AuthenticationFailed,
+    category: A2AErrorCategoryEnum.Auth,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: false,
+    description: "Authentication failed (invalid or missing credentials)."
+  },
+  [A2AErrorCodeEnum.AuthorizationDenied]: {
+    code: A2AErrorCodeEnum.AuthorizationDenied,
+    category: A2AErrorCategoryEnum.Auth,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The caller is not authorized for the requested operation."
+  },
+  [A2AErrorCodeEnum.TokenExpired]: {
+    code: A2AErrorCodeEnum.TokenExpired,
+    category: A2AErrorCategoryEnum.Auth,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: true,
+    description: "The access token has expired."
+  },
+  // rate limit
+  [A2AErrorCodeEnum.RateLimitExceeded]: {
+    code: A2AErrorCodeEnum.RateLimitExceeded,
+    category: A2AErrorCategoryEnum.RateLimit,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: true,
+    description: "The caller has exceeded the rate limit."
+  },
+  [A2AErrorCodeEnum.QuotaExceeded]: {
+    code: A2AErrorCodeEnum.QuotaExceeded,
+    category: A2AErrorCategoryEnum.RateLimit,
+    severity: A2AErrorSeverityEnum.Medium,
+    retryable: false,
+    description: "The caller has exceeded their usage quota."
+  },
+  // internal
+  [A2AErrorCodeEnum.InternalError]: {
+    code: A2AErrorCodeEnum.InternalError,
+    category: A2AErrorCategoryEnum.Internal,
+    severity: A2AErrorSeverityEnum.Critical,
+    retryable: false,
+    description: "An unexpected internal error occurred."
+  },
+  [A2AErrorCodeEnum.ConfigurationError]: {
+    code: A2AErrorCodeEnum.ConfigurationError,
+    category: A2AErrorCategoryEnum.Internal,
+    severity: A2AErrorSeverityEnum.High,
+    retryable: false,
+    description: "A configuration error was detected."
+  }
+};
+function buildA2AError(input) {
+  const meta = A2A_ERROR_CODE_REGISTRY[input.code];
+  return {
+    code: input.code,
+    category: meta.category,
+    message: input.message,
+    severity: input.severity ?? meta.severity,
+    retryable: input.retryable ?? meta.retryable,
+    details: input.details,
+    timestamp: input.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    trace_id: input.trace_id
+  };
+}
+function getErrorCodeMeta(code) {
+  return A2A_ERROR_CODE_REGISTRY[code];
+}
+function isA2AErrorCode(code) {
+  return code in A2A_ERROR_CODE_REGISTRY;
+}
+var A2AStructuredError = class _A2AStructuredError extends Error {
+  /** The structured error payload. */
+  a2aError;
+  constructor(a2aError) {
+    super(`[${a2aError.code}] ${a2aError.message}`);
+    this.name = "A2AStructuredError";
+    this.a2aError = a2aError;
+    Object.setPrototypeOf(this, _A2AStructuredError.prototype);
+  }
+  /** Convenience getter for the error code. */
+  get code() {
+    return this.a2aError.code;
+  }
+  /** Convenience getter for the error category. */
+  get category() {
+    return this.a2aError.category;
+  }
+  /** Convenience getter for the severity. */
+  get severity() {
+    return this.a2aError.severity;
+  }
+  /** Whether this error is retryable. */
+  get retryable() {
+    return this.a2aError.retryable;
+  }
+};
+
+// src/state-mapping.ts
+var CODEX_TO_CANONICAL = {
+  queued: TaskStateEnum.Submitted,
+  running: TaskStateEnum.Working,
+  waiting_for_input: TaskStateEnum.InputRequired,
+  completed: TaskStateEnum.Completed,
+  failed: TaskStateEnum.Failed,
+  error: TaskStateEnum.Failed,
+  cancelled: TaskStateEnum.Cancelled,
+  timeout: TaskStateEnum.Failed
+};
+var CANONICAL_TO_CODEX = {
+  [TaskStateEnum.Submitted]: "queued",
+  [TaskStateEnum.Working]: "running",
+  [TaskStateEnum.InputRequired]: "waiting_for_input",
+  [TaskStateEnum.Completed]: "completed",
+  [TaskStateEnum.Failed]: "failed",
+  [TaskStateEnum.Cancelled]: "cancelled"
+};
+function mapCodexState(nativeState) {
+  return CODEX_TO_CANONICAL[nativeState];
+}
+function mapCodexStateStrict(nativeState) {
+  const mapped = mapCodexState(nativeState);
+  if (mapped === void 0) {
+    throw new Error(`Unknown Codex state: "${nativeState}"`);
+  }
+  return mapped;
+}
+function canonicalToCodexState(canonicalState) {
+  return CANONICAL_TO_CODEX[canonicalState];
+}
+var CLAUDE_TO_CANONICAL = {
+  pending: TaskStateEnum.Submitted,
+  streaming: TaskStateEnum.Working,
+  processing: TaskStateEnum.Working,
+  waiting_for_approval: TaskStateEnum.InputRequired,
+  waiting_for_input: TaskStateEnum.InputRequired,
+  done: TaskStateEnum.Completed,
+  completed: TaskStateEnum.Completed,
+  error: TaskStateEnum.Failed,
+  failed: TaskStateEnum.Failed,
+  aborted: TaskStateEnum.Cancelled,
+  cancelled: TaskStateEnum.Cancelled,
+  timeout: TaskStateEnum.Failed
+};
+var CANONICAL_TO_CLAUDE = {
+  [TaskStateEnum.Submitted]: "pending",
+  [TaskStateEnum.Working]: "streaming",
+  [TaskStateEnum.InputRequired]: "waiting_for_input",
+  [TaskStateEnum.Completed]: "done",
+  [TaskStateEnum.Failed]: "error",
+  [TaskStateEnum.Cancelled]: "aborted"
+};
+function mapClaudeState(nativeState) {
+  return CLAUDE_TO_CANONICAL[nativeState];
+}
+function mapClaudeStateStrict(nativeState) {
+  const mapped = mapClaudeState(nativeState);
+  if (mapped === void 0) {
+    throw new Error(`Unknown Claude Code state: "${nativeState}"`);
+  }
+  return mapped;
+}
+function canonicalToClaudeState(canonicalState) {
+  return CANONICAL_TO_CLAUDE[canonicalState];
+}
+function mapConnectorState(platform, nativeState) {
+  switch (platform) {
+    case "codex":
+      return mapCodexState(nativeState);
+    case "claude_code":
+      return mapClaudeState(nativeState);
+    default:
+      return void 0;
+  }
+}
+function mapConnectorStateStrict(platform, nativeState) {
+  const mapped = mapConnectorState(platform, nativeState);
+  if (mapped === void 0) {
+    throw new Error(
+      `Cannot map state "${nativeState}" for platform "${platform}"`
+    );
+  }
+  return mapped;
+}
+function canonicalToConnectorState(platform, canonicalState) {
+  switch (platform) {
+    case "codex":
+      return canonicalToCodexState(canonicalState);
+    case "claude_code":
+      return canonicalToClaudeState(canonicalState);
+    default:
+      return void 0;
+  }
+}
+function checkConnectorTransition(currentCanonical, platform, newNativeState) {
+  const mappedState = mapConnectorState(platform, newNativeState);
+  if (mappedState === void 0) {
+    return {
+      valid: false,
+      mappedState: void 0,
+      error: `Unknown ${platform} state: "${newNativeState}"`
+    };
+  }
+  if (mappedState === currentCanonical) {
+    return { valid: true, mappedState };
+  }
+  if (!isValidTransition(currentCanonical, mappedState)) {
+    return {
+      valid: false,
+      mappedState,
+      error: `Invalid transition: ${currentCanonical} -> ${mappedState} (from ${platform} state "${newNativeState}")`
+    };
+  }
+  return { valid: true, mappedState };
+}
+function isConnectorTerminalState(platform, nativeState) {
+  const mapped = mapConnectorState(platform, nativeState);
+  return mapped !== void 0 && isTerminalState(mapped);
+}
+
+// src/error-mapping.ts
+var CODEX_ERROR_MAP = {
+  timeout: A2AErrorCodeEnum.ConnectorTimeout,
+  rate_limit: A2AErrorCodeEnum.RateLimitExceeded,
+  quota_exceeded: A2AErrorCodeEnum.QuotaExceeded,
+  auth_error: A2AErrorCodeEnum.AuthenticationFailed,
+  connection_error: A2AErrorCodeEnum.NetworkError,
+  invalid_request: A2AErrorCodeEnum.InvalidPayload,
+  execution_error: A2AErrorCodeEnum.TaskExecutionFailed,
+  model_error: A2AErrorCodeEnum.ConnectorError,
+  internal_error: A2AErrorCodeEnum.InternalError,
+  cancelled: A2AErrorCodeEnum.TaskCancelled
+};
+function mapCodexError(input) {
+  const code = CODEX_ERROR_MAP[input.type] ?? A2AErrorCodeEnum.ConnectorError;
+  return buildA2AError({
+    code,
+    message: input.message,
+    details: {
+      ...input.details,
+      connector_platform: "codex",
+      original_error_type: input.type,
+      ...input.statusCode !== void 0 ? { status_code: input.statusCode } : {}
+    },
+    trace_id: input.traceId
+  });
+}
+var CLAUDE_ERROR_MAP = {
+  overloaded: A2AErrorCodeEnum.ConnectorUnavailable,
+  rate_limit: A2AErrorCodeEnum.RateLimitExceeded,
+  authentication_error: A2AErrorCodeEnum.AuthenticationFailed,
+  permission_error: A2AErrorCodeEnum.AuthorizationDenied,
+  invalid_request: A2AErrorCodeEnum.InvalidPayload,
+  api_error: A2AErrorCodeEnum.ConnectorError,
+  timeout: A2AErrorCodeEnum.ConnectorTimeout,
+  connection_error: A2AErrorCodeEnum.NetworkError,
+  tool_execution_error: A2AErrorCodeEnum.TaskExecutionFailed,
+  context_length_exceeded: A2AErrorCodeEnum.QuotaExceeded,
+  cancelled: A2AErrorCodeEnum.TaskCancelled,
+  aborted: A2AErrorCodeEnum.TaskCancelled
+};
+function mapClaudeError(input) {
+  const code = CLAUDE_ERROR_MAP[input.type] ?? A2AErrorCodeEnum.ConnectorError;
+  return buildA2AError({
+    code,
+    message: input.message,
+    details: {
+      ...input.details,
+      connector_platform: "claude_code",
+      original_error_type: input.type,
+      ...input.statusCode !== void 0 ? { status_code: input.statusCode } : {}
+    },
+    trace_id: input.traceId
+  });
+}
+var HTTP_STATUS_MAP = {
+  400: A2AErrorCodeEnum.InvalidPayload,
+  401: A2AErrorCodeEnum.AuthenticationFailed,
+  403: A2AErrorCodeEnum.AuthorizationDenied,
+  404: A2AErrorCodeEnum.ConnectorNotFound,
+  408: A2AErrorCodeEnum.ConnectorTimeout,
+  409: A2AErrorCodeEnum.InvalidStateTransition,
+  422: A2AErrorCodeEnum.InvalidEnvelope,
+  429: A2AErrorCodeEnum.RateLimitExceeded,
+  500: A2AErrorCodeEnum.InternalError,
+  502: A2AErrorCodeEnum.NetworkError,
+  503: A2AErrorCodeEnum.ConnectorUnavailable,
+  504: A2AErrorCodeEnum.ConnectorTimeout
+};
+function mapHttpError(statusCode, message, options) {
+  const code = HTTP_STATUS_MAP[statusCode] ?? A2AErrorCodeEnum.UnexpectedStatus;
+  return buildA2AError({
+    code,
+    message,
+    details: {
+      ...options?.details,
+      http_status: statusCode,
+      ...options?.platform ? { connector_platform: options.platform } : {}
+    },
+    trace_id: options?.traceId
+  });
+}
+function mapConnectorError(input) {
+  switch (input.platform) {
+    case "codex":
+      return mapCodexError(input);
+    case "claude_code":
+      return mapClaudeError(input);
+    default:
+      if (input.statusCode !== void 0) {
+        return mapHttpError(input.statusCode, input.message, {
+          traceId: input.traceId,
+          details: { ...input.details, original_error_type: input.type },
+          platform: input.platform
+        });
+      }
+      return buildA2AError({
+        code: A2AErrorCodeEnum.ConnectorError,
+        message: input.message,
+        details: {
+          ...input.details,
+          connector_platform: input.platform,
+          original_error_type: input.type
+        },
+        trace_id: input.traceId
+      });
+  }
+}
+function wrapUnknownError(err, options) {
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
+  const details = {};
+  if (options?.platform) {
+    details.connector_platform = options.platform;
+  }
+  if (err instanceof Error) {
+    details.error_name = err.name;
+    if (err.stack) {
+      details.stack_preview = err.stack.split("\n").slice(0, 3).join("\n");
+    }
+  }
+  return buildA2AError({
+    code: A2AErrorCodeEnum.InternalError,
+    message,
+    details,
+    trace_id: options?.traceId
+  });
+}
+
+// src/envelope-builders.ts
+function buildCodexEnvelope(input, options) {
+  const connectorMeta = {
+    ...options?.connector_metadata
+  };
+  if (options?.model) connectorMeta.model = options.model;
+  if (options?.endpoint) connectorMeta.endpoint = options.endpoint;
+  const connector = {
+    platform: "codex",
+    protocol: "jsonrpc",
+    connector_id: options?.connector_id ?? "codex-v1",
+    name: "Codex Adapter",
+    metadata: Object.keys(connectorMeta).length > 0 ? connectorMeta : void 0
+  };
+  const assignee = input.assignee ?? {
+    agent_id: `codex-agent-${input.workspace_id}`,
+    platform: "codex",
+    name: "Codex Agent"
+  };
+  return createTaskEnvelope({
+    id: input.id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    trace_id: input.trace_id,
+    parent_id: input.parent_id,
+    requester: input.requester,
+    assignee,
+    connector,
+    payload: input.payload,
+    metadata: input.metadata,
+    tags: input.tags,
+    initial_state: input.initial_state,
+    now: input.now
+  });
+}
+function buildClaudeEnvelope(input, options) {
+  const connectorMeta = {
+    ...options?.connector_metadata
+  };
+  if (options?.model) connectorMeta.model = options.model;
+  if (options?.endpoint) connectorMeta.endpoint = options.endpoint;
+  if (options?.max_tokens !== void 0) connectorMeta.max_tokens = options.max_tokens;
+  const connector = {
+    platform: "claude_code",
+    protocol: "jsonrpc",
+    connector_id: options?.connector_id ?? "claude-code-v1",
+    name: "Claude Code Adapter",
+    metadata: Object.keys(connectorMeta).length > 0 ? connectorMeta : void 0
+  };
+  const assignee = input.assignee ?? {
+    agent_id: `claude-agent-${input.workspace_id}`,
+    platform: "claude_code",
+    name: "Claude Code Agent"
+  };
+  return createTaskEnvelope({
+    id: input.id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    trace_id: input.trace_id,
+    parent_id: input.parent_id,
+    requester: input.requester,
+    assignee,
+    connector,
+    payload: input.payload,
+    metadata: input.metadata,
+    tags: input.tags,
+    initial_state: input.initial_state,
+    now: input.now
+  });
+}
+function completeEnvelope(envelope, result, options) {
+  const transitioned = transitionTaskEnvelope(envelope, TaskStateEnum.Completed, options);
+  return {
+    ...transitioned,
+    result
+  };
+}
+function failEnvelope(envelope, error, options) {
+  const transitioned = transitionTaskEnvelope(envelope, TaskStateEnum.Failed, options);
+  return {
+    ...transitioned,
+    error
+  };
+}
+function cancelEnvelope(envelope, options) {
+  return transitionTaskEnvelope(envelope, TaskStateEnum.Cancelled, options);
+}
+function startEnvelope(envelope, options) {
+  return transitionTaskEnvelope(envelope, TaskStateEnum.Working, options);
+}
+function a2aErrorToTaskErrorInfo(a2aError) {
+  return {
+    code: a2aError.code,
+    category: a2aError.category,
+    message: a2aError.message,
+    severity: a2aError.severity,
+    retryable: a2aError.retryable,
+    details: a2aError.details
+  };
+}
+
+// src/audit-helpers.ts
+function agentActor(agentId, platform, name) {
+  return {
+    kind: AuditActorKindEnum.Agent,
+    id: agentId,
+    platform,
+    name
+  };
+}
+function connectorActor(connectorId, platform, name) {
+  return {
+    kind: AuditActorKindEnum.Connector,
+    id: connectorId,
+    platform,
+    name
+  };
+}
+function systemActor(systemId = "control-plane") {
+  return {
+    kind: AuditActorKindEnum.System,
+    id: systemId,
+    name: "A2A Control Plane"
+  };
+}
+function taskTarget(taskId) {
+  return {
+    kind: AuditTargetKindEnum.Task,
+    id: taskId
+  };
+}
+function connectorTarget(connectorId, name) {
+  return {
+    kind: AuditTargetKindEnum.Connector,
+    id: connectorId,
+    name
+  };
+}
+function emitTaskSubmitted(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskSubmitted,
+    severity: AuditSeverityEnum.Info,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitTaskStarted(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskStarted,
+    severity: AuditSeverityEnum.Info,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitTaskProgress(input) {
+  const metadata = { ...input.metadata };
+  if (input.progress_pct !== void 0) {
+    metadata.progress_pct = input.progress_pct;
+  }
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskProgress,
+    severity: AuditSeverityEnum.Info,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitTaskInputRequired(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskInputRequired,
+    severity: AuditSeverityEnum.Info,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitTaskCompleted(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskCompleted,
+    severity: AuditSeverityEnum.Info,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    duration_ms: input.duration_ms,
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitTaskFailed(input) {
+  const metadata = { ...input.metadata };
+  if (input.error_code) metadata.error_code = input.error_code;
+  if (input.error_message) metadata.error_message = input.error_message;
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskFailed,
+    severity: AuditSeverityEnum.Error,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    duration_ms: input.duration_ms,
+    metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitTaskCancelled(input) {
+  const metadata = { ...input.metadata };
+  if (input.reason) metadata.cancellation_reason = input.reason;
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.TaskCancelled,
+    severity: AuditSeverityEnum.Info,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitConnectorAttached(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.ConnectorAttached,
+    severity: AuditSeverityEnum.Info,
+    actor: systemActor(),
+    target: connectorTarget(input.connector_id, input.connector_name),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata: {
+      ...input.metadata,
+      connector_platform: input.connector_platform
+    },
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitConnectorHealth(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.ConnectorHealth,
+    severity: input.healthy ? AuditSeverityEnum.Info : AuditSeverityEnum.Warning,
+    actor: connectorActor(input.connector_id, input.connector_platform, input.connector_name),
+    target: connectorTarget(input.connector_id, input.connector_name),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata: {
+      ...input.metadata,
+      healthy: input.healthy,
+      ...input.latency_ms !== void 0 ? { latency_ms: input.latency_ms } : {}
+    },
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitConnectorError(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.ConnectorError,
+    severity: AuditSeverityEnum.Error,
+    actor: connectorActor(input.connector_id, input.connector_platform, input.connector_name),
+    target: connectorTarget(input.connector_id, input.connector_name),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    metadata: {
+      ...input.metadata,
+      ...input.error_code ? { error_code: input.error_code } : {},
+      error_message: input.error_message
+    },
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitPolicyChecked(input) {
+  const policyContext = {
+    action: input.action,
+    rule: input.rule,
+    approved: input.approved,
+    reason: input.reason,
+    agent_id: input.agent_id
+  };
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.PolicyChecked,
+    severity: AuditSeverityEnum.Info,
+    actor: systemActor("policy-engine"),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    duration_ms: input.duration_ms,
+    policy: policyContext,
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitPolicyApproved(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.PolicyApproved,
+    severity: AuditSeverityEnum.Info,
+    actor: systemActor("policy-engine"),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    duration_ms: input.duration_ms,
+    policy: {
+      action: input.action,
+      rule: input.rule,
+      approved: true,
+      reason: input.reason,
+      agent_id: input.agent_id
+    },
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+function emitPolicyDenied(input) {
+  return createAuditEvent({
+    id: input.id,
+    event_type: AuditEventTypeEnum.PolicyDenied,
+    severity: AuditSeverityEnum.Warning,
+    actor: systemActor("policy-engine"),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    duration_ms: input.duration_ms,
+    policy: {
+      action: input.action,
+      rule: input.rule,
+      approved: false,
+      reason: input.reason,
+      agent_id: input.agent_id
+    },
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+var STATE_TO_EVENT_TYPE = {
+  submitted: AuditEventTypeEnum.TaskSubmitted,
+  working: AuditEventTypeEnum.TaskStarted,
+  "input-required": AuditEventTypeEnum.TaskInputRequired,
+  completed: AuditEventTypeEnum.TaskCompleted,
+  failed: AuditEventTypeEnum.TaskFailed,
+  cancelled: AuditEventTypeEnum.TaskCancelled
+};
+function emitAuditForTransition(input, newState) {
+  const eventType = STATE_TO_EVENT_TYPE[newState] ?? AuditEventTypeEnum.TaskProgress;
+  const severity = newState === "failed" ? AuditSeverityEnum.Error : newState === "cancelled" ? AuditSeverityEnum.Warning : AuditSeverityEnum.Info;
+  return createAuditEvent({
+    id: input.id,
+    event_type: eventType,
+    severity,
+    actor: agentActor(input.actor_agent_id, input.actor_platform, input.actor_name),
+    target: taskTarget(input.task_id),
+    trace_id: input.trace_id,
+    workspace_id: input.workspace_id,
+    thread_id: input.thread_id,
+    task_id: input.task_id,
+    parent_event_id: input.parent_event_id,
+    duration_ms: input.duration_ms,
+    metadata: input.metadata,
+    tags: input.tags,
+    now: input.now
+  });
+}
+
+// src/validation.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isValidISODate(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+var VALID_PLATFORMS = /* @__PURE__ */ new Set([
+  "codex",
+  "claude_code",
+  "recoder_web",
+  "recoder_pm",
+  "recoder_agency",
+  "recoder_backend",
+  "recoder_desktop",
+  "custom"
+]);
+var VALID_PROTOCOLS = /* @__PURE__ */ new Set(["a2a", "mcp", "jsonrpc", "rest", "file_git"]);
+var VALID_TASK_STATES = new Set(TASK_STATES);
+var VALID_AUDIT_EVENT_TYPES = new Set(AUDIT_EVENT_TYPES);
+var VALID_ACTOR_KINDS = /* @__PURE__ */ new Set(["agent", "user", "system", "connector"]);
+var VALID_TARGET_KINDS = /* @__PURE__ */ new Set([
+  "task",
+  "agent",
+  "connector",
+  "channel",
+  "thread",
+  "message",
+  "policy",
+  "workspace",
+  "system"
+]);
+var VALID_SEVERITIES = /* @__PURE__ */ new Set(["low", "medium", "high", "critical"]);
+var VALID_AUDIT_SEVERITIES = /* @__PURE__ */ new Set(["info", "warning", "error", "critical"]);
+function validateAgentRef(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "must be an object" });
+    return;
+  }
+  if (!isNonEmptyString(value.agent_id)) {
+    issues.push({ path: `${path}.agent_id`, message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.platform) || !VALID_PLATFORMS.has(value.platform)) {
+    issues.push({
+      path: `${path}.platform`,
+      message: `must be one of: ${[...VALID_PLATFORMS].join(", ")}`
+    });
+  }
+}
+function validateConnectorInfo(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "must be an object" });
+    return;
+  }
+  if (!isNonEmptyString(value.platform) || !VALID_PLATFORMS.has(value.platform)) {
+    issues.push({
+      path: `${path}.platform`,
+      message: `must be one of: ${[...VALID_PLATFORMS].join(", ")}`
+    });
+  }
+  if (!isNonEmptyString(value.protocol) || !VALID_PROTOCOLS.has(value.protocol)) {
+    issues.push({
+      path: `${path}.protocol`,
+      message: `must be one of: ${[...VALID_PROTOCOLS].join(", ")}`
+    });
+  }
+  if (!isNonEmptyString(value.connector_id)) {
+    issues.push({
+      path: `${path}.connector_id`,
+      message: "must be a non-empty string"
+    });
+  }
+}
+function validatePayloadItem(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "must be an object" });
+    return;
+  }
+  const validKinds = /* @__PURE__ */ new Set(["text", "json", "command", "artifact"]);
+  if (!isNonEmptyString(value.kind) || !validKinds.has(value.kind)) {
+    issues.push({
+      path: `${path}.kind`,
+      message: `must be one of: ${[...validKinds].join(", ")}`
+    });
+    return;
+  }
+  switch (value.kind) {
+    case "text":
+      if (!isNonEmptyString(value.text)) {
+        issues.push({ path: `${path}.text`, message: "must be a non-empty string" });
+      }
+      break;
+    case "json":
+      if (!isRecord(value.data)) {
+        issues.push({ path: `${path}.data`, message: "must be an object" });
+      }
+      break;
+    case "command":
+      if (!isNonEmptyString(value.command)) {
+        issues.push({ path: `${path}.command`, message: "must be a non-empty string" });
+      }
+      break;
+    case "artifact":
+      if (!isNonEmptyString(value.mimeType) && !isNonEmptyString(value.mime_type)) {
+        issues.push({ path: `${path}.mimeType`, message: "must be a non-empty string" });
+      }
+      if (!isNonEmptyString(value.content)) {
+        issues.push({ path: `${path}.content`, message: "must be a non-empty string" });
+      }
+      break;
+  }
+}
+function validateTaskEnvelope(value, options) {
+  const issues = [];
+  if (!isRecord(value)) {
+    return { valid: false, issues: [{ path: "$", message: "must be an object" }] };
+  }
+  if (!isNonEmptyString(value.envelope_version)) {
+    issues.push({ path: "envelope_version", message: "must be a non-empty string" });
+  } else if (options?.strictVersion && value.envelope_version !== TASK_ENVELOPE_VERSION) {
+    issues.push({
+      path: "envelope_version",
+      message: `must equal "${TASK_ENVELOPE_VERSION}"`
+    });
+  }
+  if (!isNonEmptyString(value.id)) {
+    issues.push({ path: "id", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.workspace_id)) {
+    issues.push({ path: "workspace_id", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.thread_id)) {
+    issues.push({ path: "thread_id", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.trace_id)) {
+    issues.push({ path: "trace_id", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.state) || !VALID_TASK_STATES.has(value.state)) {
+    issues.push({
+      path: "state",
+      message: `must be one of: ${[...VALID_TASK_STATES].join(", ")}`
+    });
+  }
+  validateAgentRef(value.requester, "requester", issues);
+  validateAgentRef(value.assignee, "assignee", issues);
+  validateConnectorInfo(value.connector, "connector", issues);
+  if (value.payload === void 0 || value.payload === null) {
+    issues.push({ path: "payload", message: "is required" });
+  } else if (Array.isArray(value.payload)) {
+    value.payload.forEach(
+      (item, i) => validatePayloadItem(item, `payload[${i}]`, issues)
+    );
+  } else {
+    validatePayloadItem(value.payload, "payload", issues);
+  }
+  if (!isValidISODate(value.created_at)) {
+    issues.push({ path: "created_at", message: "must be a valid ISO-8601 timestamp" });
+  }
+  if (!isValidISODate(value.updated_at)) {
+    issues.push({ path: "updated_at", message: "must be a valid ISO-8601 timestamp" });
+  }
+  if (value.error !== void 0) {
+    if (!isRecord(value.error)) {
+      issues.push({ path: "error", message: "must be an object when present" });
+    } else {
+      if (!isNonEmptyString(value.error.code)) {
+        issues.push({ path: "error.code", message: "must be a non-empty string" });
+      }
+      if (!isNonEmptyString(value.error.category)) {
+        issues.push({ path: "error.category", message: "must be a non-empty string" });
+      }
+      if (!isNonEmptyString(value.error.message)) {
+        issues.push({ path: "error.message", message: "must be a non-empty string" });
+      }
+      if (!isNonEmptyString(value.error.severity) || !VALID_SEVERITIES.has(value.error.severity)) {
+        issues.push({
+          path: "error.severity",
+          message: `must be one of: ${[...VALID_SEVERITIES].join(", ")}`
+        });
+      }
+      if (typeof value.error.retryable !== "boolean") {
+        issues.push({ path: "error.retryable", message: "must be a boolean" });
+      }
+    }
+  }
+  return { valid: issues.length === 0, issues };
+}
+function isValidTaskEnvelope(value) {
+  return validateTaskEnvelope(value).valid;
+}
+function assertTaskEnvelope(value) {
+  const result = validateTaskEnvelope(value);
+  if (!result.valid) {
+    const summary = result.issues.map((i) => `  ${i.path}: ${i.message}`).join("\n");
+    throw new Error(`Invalid TaskEnvelope:
+${summary}`);
+  }
+}
+function validateAuditActor(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "must be an object" });
+    return;
+  }
+  if (!isNonEmptyString(value.kind) || !VALID_ACTOR_KINDS.has(value.kind)) {
+    issues.push({
+      path: `${path}.kind`,
+      message: `must be one of: ${[...VALID_ACTOR_KINDS].join(", ")}`
+    });
+  }
+  if (!isNonEmptyString(value.id)) {
+    issues.push({ path: `${path}.id`, message: "must be a non-empty string" });
+  }
+}
+function validateAuditTarget(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "must be an object" });
+    return;
+  }
+  if (!isNonEmptyString(value.kind) || !VALID_TARGET_KINDS.has(value.kind)) {
+    issues.push({
+      path: `${path}.kind`,
+      message: `must be one of: ${[...VALID_TARGET_KINDS].join(", ")}`
+    });
+  }
+  if (!isNonEmptyString(value.id)) {
+    issues.push({ path: `${path}.id`, message: "must be a non-empty string" });
+  }
+}
+function validateAuditEvent(value, options) {
+  const issues = [];
+  if (!isRecord(value)) {
+    return { valid: false, issues: [{ path: "$", message: "must be an object" }] };
+  }
+  if (!isNonEmptyString(value.schema_version)) {
+    issues.push({ path: "schema_version", message: "must be a non-empty string" });
+  } else if (options?.strictVersion && value.schema_version !== AUDIT_EVENT_VERSION) {
+    issues.push({
+      path: "schema_version",
+      message: `must equal "${AUDIT_EVENT_VERSION}"`
+    });
+  }
+  if (!isNonEmptyString(value.id)) {
+    issues.push({ path: "id", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.event_type) || !VALID_AUDIT_EVENT_TYPES.has(value.event_type)) {
+    issues.push({
+      path: "event_type",
+      message: `must be one of the canonical audit event types`
+    });
+  }
+  if (value.severity !== void 0 && (!isNonEmptyString(value.severity) || !VALID_AUDIT_SEVERITIES.has(value.severity))) {
+    issues.push({
+      path: "severity",
+      message: `must be one of: ${[...VALID_AUDIT_SEVERITIES].join(", ")}`
+    });
+  }
+  validateAuditActor(value.actor, "actor", issues);
+  validateAuditTarget(value.target, "target", issues);
+  if (!isNonEmptyString(value.trace_id)) {
+    issues.push({ path: "trace_id", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.workspace_id)) {
+    issues.push({ path: "workspace_id", message: "must be a non-empty string" });
+  }
+  if (!isValidISODate(value.timestamp)) {
+    issues.push({ path: "timestamp", message: "must be a valid ISO-8601 timestamp" });
+  }
+  if (value.policy !== void 0) {
+    if (!isRecord(value.policy)) {
+      issues.push({ path: "policy", message: "must be an object when present" });
+    } else {
+      if (!isNonEmptyString(value.policy.action)) {
+        issues.push({ path: "policy.action", message: "must be a non-empty string" });
+      }
+      if (!isNonEmptyString(value.policy.rule)) {
+        issues.push({ path: "policy.rule", message: "must be a non-empty string" });
+      }
+      if (typeof value.policy.approved !== "boolean") {
+        issues.push({ path: "policy.approved", message: "must be a boolean" });
+      }
+      if (!isNonEmptyString(value.policy.reason)) {
+        issues.push({ path: "policy.reason", message: "must be a non-empty string" });
+      }
+      if (!isNonEmptyString(value.policy.agent_id)) {
+        issues.push({ path: "policy.agent_id", message: "must be a non-empty string" });
+      }
+    }
+  }
+  return { valid: issues.length === 0, issues };
+}
+function isValidAuditEvent(value) {
+  return validateAuditEvent(value).valid;
+}
+function assertAuditEvent(value) {
+  const result = validateAuditEvent(value);
+  if (!result.valid) {
+    const summary = result.issues.map((i) => `  ${i.path}: ${i.message}`).join("\n");
+    throw new Error(`Invalid AuditEvent:
+${summary}`);
+  }
+}
+function validateA2AError(value) {
+  const issues = [];
+  if (!isRecord(value)) {
+    return { valid: false, issues: [{ path: "$", message: "must be an object" }] };
+  }
+  if (!isNonEmptyString(value.code)) {
+    issues.push({ path: "code", message: "must be a non-empty string" });
+  } else if (!isA2AErrorCode(value.code)) {
+    issues.push({
+      path: "code",
+      message: "must be a recognized A2A error code"
+    });
+  }
+  if (!isNonEmptyString(value.category)) {
+    issues.push({ path: "category", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.message)) {
+    issues.push({ path: "message", message: "must be a non-empty string" });
+  }
+  if (!isNonEmptyString(value.severity) || !VALID_SEVERITIES.has(value.severity)) {
+    issues.push({
+      path: "severity",
+      message: `must be one of: ${[...VALID_SEVERITIES].join(", ")}`
+    });
+  }
+  if (typeof value.retryable !== "boolean") {
+    issues.push({ path: "retryable", message: "must be a boolean" });
+  }
+  return { valid: issues.length === 0, issues };
+}
+function isValidA2AError(value) {
+  return validateA2AError(value).valid;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AErrorCategoryEnum,
+  A2AErrorCodeEnum,
+  A2AErrorSeverityEnum,
+  A2AStructuredError,
+  A2A_ERROR_CODE_REGISTRY,
+  ALLOWED_STATE_TRANSITIONS,
+  AUDIT_EVENT_TYPES,
+  AUDIT_EVENT_VERSION,
+  AuditActorKindEnum,
+  AuditEventTypeEnum,
+  AuditSeverityEnum,
+  AuditTargetKindEnum,
+  TASK_ENVELOPE_VERSION,
+  TASK_STATES,
+  TERMINAL_TASK_STATES,
+  TaskStateEnum,
+  a2aErrorToTaskErrorInfo,
+  assertAuditEvent,
+  assertTaskEnvelope,
+  buildA2AError,
+  buildClaudeEnvelope,
+  buildCodexEnvelope,
+  cancelEnvelope,
+  canonicalToClaudeState,
+  canonicalToCodexState,
+  canonicalToConnectorState,
+  checkConnectorTransition,
+  completeEnvelope,
+  createAuditEvent,
+  createTaskEnvelope,
+  emitAuditForTransition,
+  emitConnectorAttached,
+  emitConnectorError,
+  emitConnectorHealth,
+  emitPolicyApproved,
+  emitPolicyChecked,
+  emitPolicyDenied,
+  emitTaskCancelled,
+  emitTaskCompleted,
+  emitTaskFailed,
+  emitTaskInputRequired,
+  emitTaskProgress,
+  emitTaskStarted,
+  emitTaskSubmitted,
+  failEnvelope,
+  getErrorCodeMeta,
+  isA2AErrorCode,
+  isConnectorTerminalState,
+  isTerminalState,
+  isValidA2AError,
+  isValidAuditEvent,
+  isValidTaskEnvelope,
+  isValidTransition,
+  mapClaudeError,
+  mapClaudeState,
+  mapClaudeStateStrict,
+  mapCodexError,
+  mapCodexState,
+  mapCodexStateStrict,
+  mapConnectorError,
+  mapConnectorState,
+  mapConnectorStateStrict,
+  mapHttpError,
+  startEnvelope,
+  transitionTaskEnvelope,
+  validateA2AError,
+  validateAuditEvent,
+  validateTaskEnvelope,
+  wrapUnknownError
+});
+//# sourceMappingURL=index.js.map