/**
 * @agent-ops/sesh-channels-sdk — shared SDK for sesh-channels adapters.
 *
 * See: docs/plans/2026-05-24-v0.4-sdk-and-adapters.md
 */

import * as subjects from "./subjects.ts";
import * as headers from "./headers.ts";
import * as envelope from "./envelope.ts";
import * as taskstate from "./taskstate.ts";
import * as messages from "./messages.ts";
import * as objects from "./objects.ts";
import * as artifactsModule from "./artifacts.ts";
import * as streamModule from "./stream.ts";
import * as cardModule from "./card.ts";
import * as scope from "./scope.ts";
import * as taskModule from "./task.ts";
import * as requestModule from "./request.ts";
import * as replyModule from "./reply.ts";

export const SDK_VERSION = "0.0.0" as const;

export const v04 = {
  subjects,
  headers,
  envelope,
  taskstate,
  messages,
  objects,
  artifacts: artifactsModule,
  stream: streamModule,
  card: cardModule,
  scope,
  task: taskModule,
  request: requestModule,
  reply: replyModule,
} as const;

export type V04Namespace = typeof v04;

export {
  prompt,
  heartbeat,
  status,
  card,
  cardx,
  stream,
  PROMPT_QUEUE_GROUP,
  validateToken,
  InvalidSubjectTokenError,
  resolveProjectToken,
  InvalidProjectIdError,
  type Coord,
} from "./subjects.ts";

export {
  HEADER_PROTOCOL_VERSION,
  HEADER_CAPABILITIES,
  HEADER_WIRE,
  CURRENT_PROTOCOL_VERSION,
  DEFAULT_CAPABILITIES,
  WIRE_SYNADIA,
  WIRE_A2A,
  stampSeshHeaders,
  type SeshHeaders,
} from "./headers.ts";

export {
  parseV2Envelope,
  buildV2Envelope,
  validateV2Envelope,
  EnvelopeError,
  type V2Envelope,
} from "./envelope.ts";

export {
  serviceError,
  ensureEnvelope,
  requestEnveloped,
  HEADER_SERVICE_ERROR_CODE,
  HEADER_SERVICE_ERROR,
  type ServiceError,
  type ReadableHeaders,
  type ReplyMsg,
  type RequestCapable,
  type RequestEnvelopedOpts,
  type EnvelopedReply,
} from "./request.ts";

export {
  captureReplyTo,
  deliverDurableReply,
  HEADER_REPLY_TO,
  type PublishCapable,
  type DeliverDurableReplyOpts,
} from "./reply.ts";

export { isTerminal, type TaskStateWire } from "./taskstate.ts";

export type { Message, Part, Role } from "./types.ts";

export type {
  AgentCardPartial,
  AgentCardSkill,
  AgentCardExtension,
  AgentCardRegistrar,
} from "./card.ts";

export {
  appendMessage,
  idempotentAppend,
  readMessage,
  watchMessages,
  materializePart,
  messageKey,
  TextPart,
  DataPart,
  FilePartURL,
  FilePartRaw,
  PART_INLINE_MAX_BYTES,
  type AppendResult,
  type MaterializeOpts,
  type WatchMessagesOpts,
} from "./messages.ts";

export {
  putObject,
  getObject,
  objectURL,
  parseObjectURL,
  objectKey,
  OBJ_URI_SCHEME,
  type ObjectURLParts,
} from "./objects.ts";

export {
  SDKError,
  MessageIDConflict,
  ObjectURLError,
  MaterializePartError,
} from "./errors.ts";

export { canonicalJSON, canonicalBytes } from "./canonicalJson.ts";

export { sanitizeSubjectToken } from "./sanitize.ts";

export {
  publishStreamEvent,
  streamTask,
  streamMessage,
  streamStatusUpdate,
  streamArtifactUpdate,
  type StreamEvent,
  type TaskEvent,
  type MessageEvent,
  type StatusUpdateEvent,
  type ArtifactUpdateEvent,
  type ScopeKind,
  type ScopeRef,
} from "./stream.ts";

export {
  putArtifact,
  getArtifact,
  listArtifacts,
  artifactKey,
  type Artifact,
  type ArtifactDraft,
  type PutArtifactOpts,
} from "./artifacts.ts";

export {
  messagesBucket,
  tasksBucket,
  artifactsBucket,
  objectsBucket,
  InvalidScopeError,
} from "./scope.ts";

export {
  readTask,
  updateTaskStatus,
  appendTaskArtifact,
  completeTask,
  TaskNotFound,
  TaskCASConflict,
  type TaskRecord,
  type TaskStatus,
  type UpdateTaskStatusOpts,
  type CompleteTaskOpts,
} from "./task.ts";