recoder-a2a-sdk 1.0.0 → 1.0.1

package/dist/index.mjs

@@ -13,7 +13,7 @@ import {
   emitTaskProgress,
   emitTaskStarted,
   emitTaskSubmitted
-} from "./chunk-JOZQDX7A.mjs";
+} from "./chunk-MJ45255C.mjs";
 import {
   a2aErrorToTaskErrorInfo,
   buildClaudeEnvelope,
@@ -22,14 +22,14 @@ import {
   completeEnvelope,
   failEnvelope,
   startEnvelope
-} from "./chunk-7GY5FFBI.mjs";
+} from "./chunk-AWHOY6CI.mjs";
 import {
   mapClaudeError,
   mapCodexError,
   mapConnectorError,
   mapHttpError,
   wrapUnknownError
-} from "./chunk-AGD6G5N6.mjs";
+} from "./chunk-FSPAU2U3.mjs";
 import {
   canonicalToClaudeState,
   canonicalToCodexState,
@@ -42,7 +42,7 @@ import {
   mapCodexStateStrict,
   mapConnectorState,
   mapConnectorStateStrict
-} from "./chunk-MAA7JZ2Q.mjs";
+} from "./chunk-6EHW6C4A.mjs";
 import {
   assertAuditEvent,
   assertTaskEnvelope,
@@ -52,7 +52,7 @@ import {
   validateA2AError,
   validateAuditEvent,
   validateTaskEnvelope
-} from "./chunk-BWCRJDUB.mjs";
+} from "./chunk-V4EHWWUR.mjs";
 import {
   A2AErrorCategoryEnum,
   A2AErrorCodeEnum,
@@ -78,7 +78,7 @@ import {
   isTerminalState,
   isValidTransition,
   transitionTaskEnvelope
-} from "./chunk-WLNW7Y2H.mjs";
+} from "./chunk-KTGZQV57.mjs";
 export {
   A2AErrorCategoryEnum,
   A2AErrorCodeEnum,

package/dist/schemas/index.d.mts

@@ -0,0 +1,4 @@
+export { A as A2AProtocolKind, R as RecoderAgentPlatform, a as RecoderArtifactPayload, b as RecoderCommandPayload, c as RecoderJsonPayload, d as RecoderPayload, e as RecoderTextPayload } from '../types-Bt96SgOS.mjs';
+export { A as ALLOWED_STATE_TRANSITIONS, C as CreateTaskEnvelopeInput, T as TASK_ENVELOPE_VERSION, a as TASK_STATES, b as TERMINAL_TASK_STATES, c as TaskAgentRef, d as TaskArtifact, e as TaskConnectorInfo, f as TaskEnvelope, g as TaskErrorInfo, h as TaskPolicySnapshot, i as TaskResult, j as TaskState, k as TaskStateEnum, l as TaskStateTransition, m as createTaskEnvelope, n as isTerminalState, o as isValidTransition, t as transitionTaskEnvelope } from '../task-envelope-QkecqlWq.mjs';
+export { A as AUDIT_EVENT_TYPES, a as AUDIT_EVENT_VERSION, b as AuditActor, c as AuditActorKind, d as AuditActorKindEnum, e as AuditEvent, f as AuditEventType, g as AuditEventTypeEnum, h as AuditPolicyContext, i as AuditSeverity, j as AuditSeverityEnum, k as AuditTarget, l as AuditTargetKind, m as AuditTargetKindEnum, C as CreateAuditEventInput, n as createAuditEvent } from '../audit-event-Bhf9-AJV.mjs';
+export { A as A2AError, a as A2AErrorCategory, b as A2AErrorCategoryEnum, c as A2AErrorCode, d as A2AErrorCodeEnum, e as A2AErrorCodeMeta, f as A2AErrorSeverity, g as A2AErrorSeverityEnum, h as A2AStructuredError, i as A2A_ERROR_CODE_REGISTRY, j as buildA2AError, k as getErrorCodeMeta, l as isA2AErrorCode } from '../error-taxonomy-CQgrKp9z.mjs';

package/dist/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export { A as A2AProtocolKind, R as RecoderAgentPlatform, a as RecoderArtifactPayload, b as RecoderCommandPayload, c as RecoderJsonPayload, d as RecoderPayload, e as RecoderTextPayload } from '../types-Bt96SgOS.js';
+export { A as ALLOWED_STATE_TRANSITIONS, C as CreateTaskEnvelopeInput, T as TASK_ENVELOPE_VERSION, a as TASK_STATES, b as TERMINAL_TASK_STATES, c as TaskAgentRef, d as TaskArtifact, e as TaskConnectorInfo, f as TaskEnvelope, g as TaskErrorInfo, h as TaskPolicySnapshot, i as TaskResult, j as TaskState, k as TaskStateEnum, l as TaskStateTransition, m as createTaskEnvelope, n as isTerminalState, o as isValidTransition, t as transitionTaskEnvelope } from '../task-envelope-B3X3seKp.js';
+export { A as AUDIT_EVENT_TYPES, a as AUDIT_EVENT_VERSION, b as AuditActor, c as AuditActorKind, d as AuditActorKindEnum, e as AuditEvent, f as AuditEventType, g as AuditEventTypeEnum, h as AuditPolicyContext, i as AuditSeverity, j as AuditSeverityEnum, k as AuditTarget, l as AuditTargetKind, m as AuditTargetKindEnum, C as CreateAuditEventInput, n as createAuditEvent } from '../audit-event-D8PTRp8M.js';
+export { A as A2AError, a as A2AErrorCategory, b as A2AErrorCategoryEnum, c as A2AErrorCode, d as A2AErrorCodeEnum, e as A2AErrorCodeMeta, f as A2AErrorSeverity, g as A2AErrorSeverityEnum, h as A2AStructuredError, i as A2A_ERROR_CODE_REGISTRY, j as buildA2AError, k as getErrorCodeMeta, l as isA2AErrorCode } from '../error-taxonomy-CQgrKp9z.js';

package/dist/schemas/index.js

@@ -0,0 +1,601 @@
+"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/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_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,
+  buildA2AError: () => buildA2AError,
+  createAuditEvent: () => createAuditEvent,
+  createTaskEnvelope: () => createTaskEnvelope,
+  getErrorCodeMeta: () => getErrorCodeMeta,
+  isA2AErrorCode: () => isA2AErrorCode,
+  isTerminalState: () => isTerminalState,
+  isValidTransition: () => isValidTransition,
+  transitionTaskEnvelope: () => transitionTaskEnvelope
+});
+module.exports = __toCommonJS(schemas_exports);
+
+// src/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]
+  };
+}
+
+// src/schemas/audit-event.ts
+var AUDIT_EVENT_VERSION = "1.0.0";
+var AuditEventTypeEnum = {
+  // -- task lifecycle ---------------------------------------------------------
+  TaskSubmitted: "task.submitted",
+  TaskStarted: "task.started",
+  TaskProgress: "task.progress",
+  TaskInputRequired: "task.input_required",
+  TaskCompleted: "task.completed",
+  TaskFailed: "task.failed",
+  TaskCancelled: "task.cancelled",
+  // -- policy decisions -------------------------------------------------------
+  PolicyChecked: "policy.checked",
+  PolicyApproved: "policy.approved",
+  PolicyDenied: "policy.denied",
+  // -- connector events -------------------------------------------------------
+  ConnectorAttached: "connector.attached",
+  ConnectorDetached: "connector.detached",
+  ConnectorHealth: "connector.health",
+  ConnectorError: "connector.error",
+  // -- agent registry ---------------------------------------------------------
+  AgentRegistered: "agent.registered",
+  AgentUnregistered: "agent.unregistered",
+  AgentUpdated: "agent.updated",
+  // -- collaboration ----------------------------------------------------------
+  ChannelCreated: "collaboration.channel_created",
+  ThreadCreated: "collaboration.thread_created",
+  MessageSent: "collaboration.message_sent",
+  // -- system -----------------------------------------------------------------
+  SystemConfig: "system.config",
+  SystemError: "system.error"
+};
+var AUDIT_EVENT_TYPES = Object.values(AuditEventTypeEnum);
+var AuditActorKindEnum = {
+  Agent: "agent",
+  User: "user",
+  System: "system",
+  Connector: "connector"
+};
+var AuditTargetKindEnum = {
+  Task: "task",
+  Agent: "agent",
+  Connector: "connector",
+  Channel: "channel",
+  Thread: "thread",
+  Message: "message",
+  Policy: "policy",
+  Workspace: "workspace",
+  System: "system"
+};
+var AuditSeverityEnum = {
+  Info: "info",
+  Warning: "warning",
+  Error: "error",
+  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
+  };
+}
+
+// src/schemas/error-taxonomy.ts
+var A2AErrorSeverityEnum = {
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+  Critical: "critical"
+};
+var A2AErrorCategoryEnum = {
+  Envelope: "envelope",
+  Connector: "connector",
+  Policy: "policy",
+  Task: "task",
+  Registry: "registry",
+  Collaboration: "collaboration",
+  Transport: "transport",
+  Auth: "auth",
+  RateLimit: "rate_limit",
+  Internal: "internal"
+};
+var A2AErrorCodeEnum = {
+  // -- envelope ---------------------------------------------------------------
+  InvalidEnvelope: "INVALID_ENVELOPE",
+  UnsupportedEnvelopeVersion: "UNSUPPORTED_ENVELOPE_VERSION",
+  MissingEnvelopeField: "MISSING_ENVELOPE_FIELD",
+  InvalidPayload: "INVALID_PAYLOAD",
+  InvalidParams: "INVALID_ENVELOPE",
+  // -- connector --------------------------------------------------------------
+  ConnectorNotFound: "CONNECTOR_NOT_FOUND",
+  ConnectorTimeout: "CONNECTOR_TIMEOUT",
+  ConnectorError: "CONNECTOR_ERROR",
+  ConnectorUnavailable: "CONNECTOR_UNAVAILABLE",
+  ProtocolMismatch: "PROTOCOL_MISMATCH",
+  // -- policy -----------------------------------------------------------------
+  PolicyDenied: "POLICY_DENIED",
+  PolicyHandlerMissing: "POLICY_HANDLER_MISSING",
+  PolicyTimeout: "POLICY_TIMEOUT",
+  // -- task -------------------------------------------------------------------
+  TaskNotFound: "TASK_NOT_FOUND",
+  InvalidStateTransition: "INVALID_STATE_TRANSITION",
+  TaskAlreadyTerminal: "TASK_ALREADY_TERMINAL",
+  TaskExecutionFailed: "TASK_EXECUTION_FAILED",
+  TaskCancelled: "TASK_CANCELLED",
+  // -- registry ---------------------------------------------------------------
+  AgentNotFound: "AGENT_NOT_FOUND",
+  AgentAlreadyRegistered: "AGENT_ALREADY_REGISTERED",
+  CapabilityNotFound: "CAPABILITY_NOT_FOUND",
+  // -- collaboration ----------------------------------------------------------
+  ChannelNotFound: "CHANNEL_NOT_FOUND",
+  ThreadNotFound: "THREAD_NOT_FOUND",
+  MessageNotFound: "MESSAGE_NOT_FOUND",
+  NotChannelMember: "NOT_CHANNEL_MEMBER",
+  // -- transport --------------------------------------------------------------
+  NetworkError: "NETWORK_ERROR",
+  UnexpectedStatus: "UNEXPECTED_STATUS",
+  SerializationError: "SERIALIZATION_ERROR",
+  // -- auth -------------------------------------------------------------------
+  AuthenticationFailed: "AUTHENTICATION_FAILED",
+  AuthorizationDenied: "AUTHORIZATION_DENIED",
+  TokenExpired: "TOKEN_EXPIRED",
+  // -- rate limit -------------------------------------------------------------
+  RateLimitExceeded: "RATE_LIMIT_EXCEEDED",
+  QuotaExceeded: "QUOTA_EXCEEDED",
+  // -- internal ---------------------------------------------------------------
+  InternalError: "INTERNAL_ERROR",
+  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 {
+  a2aError;
+  constructor(a2aError) {
+    super(`[${a2aError.code}] ${a2aError.message}`);
+    this.name = "A2AStructuredError";
+    this.a2aError = a2aError;
+    Object.setPrototypeOf(this, _A2AStructuredError.prototype);
+  }
+  get code() {
+    return this.a2aError.code;
+  }
+  get category() {
+    return this.a2aError.category;
+  }
+  get severity() {
+    return this.a2aError.severity;
+  }
+  get retryable() {
+    return this.a2aError.retryable;
+  }
+};
+// 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,
+  buildA2AError,
+  createAuditEvent,
+  createTaskEnvelope,
+  getErrorCodeMeta,
+  isA2AErrorCode,
+  isTerminalState,
+  isValidTransition,
+  transitionTaskEnvelope
+});
+//# sourceMappingURL=index.js.map