@tangle-network/agent-core 0.2.0

package/dist/index-CtebBodu.d.ts

@@ -0,0 +1,108 @@
+import { n as SDKError } from "./index-DiQX9bjq.js";
+
+//#region src/resilience/circuit-breaker.d.ts
+type CircuitState = "closed" | "open" | "half-open";
+interface CircuitBreakerConfig {
+  /** Number of failures before opening circuit */
+  failureThreshold: number;
+  /** Time in ms to wait before testing recovery (half-open) */
+  resetTimeoutMs: number;
+  /** Number of successes in half-open state to close circuit */
+  successThreshold: number;
+  /** Optional: Only count these error types as failures */
+  failureFilter?: (error: unknown) => boolean;
+}
+interface CircuitBreakerStats {
+  state: CircuitState;
+  failures: number;
+  successes: number;
+  lastFailureTime: number | null;
+  totalFailures: number;
+  totalSuccesses: number;
+  totalRejected: number;
+}
+declare class CircuitOpenError extends SDKError {
+  readonly circuitName: string;
+  readonly resetAfterMs: number;
+  constructor(name: string, resetAfterMs: number);
+}
+declare class CircuitBreaker {
+  private readonly name;
+  private readonly config;
+  private state;
+  private failures;
+  private successes;
+  private lastFailureTime;
+  private totalFailures;
+  private totalSuccesses;
+  private totalRejected;
+  constructor(name: string, config: CircuitBreakerConfig);
+  /**
+   * Execute a function through the circuit breaker.
+   * Throws CircuitOpenError if circuit is open.
+   */
+  execute<T>(fn: () => Promise<T>): Promise<T>;
+  private onSuccess;
+  private onFailure;
+  /** Get current circuit state */
+  getState(): CircuitState;
+  /** Get circuit statistics */
+  getStats(): CircuitBreakerStats;
+  /** Check if circuit is allowing requests */
+  isAllowingRequests(): boolean;
+  /** Manually reset the circuit to closed state */
+  reset(): void;
+  /** Manually open the circuit */
+  open(): void;
+}
+//#endregion
+//#region src/resilience/protection.d.ts
+interface ProtectionOptions {
+  /** Timeout in milliseconds (0 or undefined = no timeout) */
+  timeoutMs?: number;
+  /** Circuit breaker instance (optional) */
+  breaker?: CircuitBreaker;
+  /** Operation name for error messages */
+  operationName?: string;
+}
+/**
+ * Execute a function with timeout and circuit breaker protection.
+ *
+ * Order of execution:
+ * 1. Circuit breaker check (fail fast if open)
+ * 2. Timeout wrapper
+ * 3. Execute function
+ * 4. Update circuit breaker state
+ */
+declare function withProtection<T>(fn: () => Promise<T>, options?: ProtectionOptions): Promise<T>;
+/**
+ * Create a protected function that always applies the same protection options.
+ */
+declare function createProtectedFn<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: ProtectionOptions): (...args: TArgs) => Promise<TResult>;
+//#endregion
+//#region src/resilience/timeout.d.ts
+declare class TimeoutError extends SDKError {
+  readonly timeoutMs: number;
+  constructor(message: string, timeoutMs: number);
+}
+/**
+ * Wrap a promise with a timeout.
+ * Rejects with TimeoutError if the promise doesn't resolve in time.
+ */
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message?: string): Promise<T>;
+/**
+ * Create an AbortController that auto-aborts after a timeout.
+ * Returns the controller and a cleanup function.
+ */
+declare function createTimeoutController(timeoutMs: number): {
+  controller: AbortController;
+  cleanup: () => void;
+};
+/**
+ * Sleep for a specified duration.
+ * Optionally accepts an AbortSignal for cancellation.
+ */
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+//#endregion
+export { ProtectionOptions as a, CircuitBreaker as c, CircuitOpenError as d, CircuitState as f, withTimeout as i, CircuitBreakerConfig as l, createTimeoutController as n, createProtectedFn as o, sleep as r, withProtection as s, TimeoutError as t, CircuitBreakerStats as u };
+//# sourceMappingURL=index-CtebBodu.d.ts.map

package/dist/index-CtebBodu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CtebBodu.d.ts","names":[],"sources":["../src/resilience/circuit-breaker.ts","../src/resilience/protection.ts","../src/resilience/timeout.ts"],"mappings":";;;KAeY,YAAA;AAAA,UAEK,oBAAA;EAQf;EANA,gBAAA;EAM+B;EAJ/B,cAAA;EAOe;EALf,gBAAA;;EAEA,aAAA,IAAiB,KAAA;AAAA;AAAA,UAGF,mBAAA;EACf,KAAA,EAAO,YAAA;EACP,QAAA;EACA,SAAA;EACA,eAAA;EACA,aAAA;EACA,cAAA;EACA,aAAA;AAAA;AAAA,cAGW,gBAAA,SAAyB,QAAA;EAAA,SAC3B,WAAA;EAAA,SACA,YAAA;cAEG,IAAA,UAAc,YAAA;AAAA;AAAA,cAaf,cAAA;EAAA,iBAYQ,IAAA;EAAA,iBACA,MAAA;EAAA,QAZX,KAAA;EAAA,QACA,QAAA;EAAA,QACA,SAAA;EAAA,QACA,eAAA;EAAA,QAGA,aAAA;EAAA,QACA,cAAA;EAAA,QACA,aAAA;cAGW,IAAA,UACA,MAAA,EAAQ,oBAAA;EAiBQ;;;;EAA7B,OAAA,GAAA,CAAW,EAAA,QAAU,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,CAAA;EAAA,QA6BxC,SAAA;EAAA,QAiBA,SAAA;EA6BuB;EAL/B,QAAA,CAAA,GAAY,YAAA;EAvFO;EA4FnB,QAAA,CAAA,GAAY,mBAAA;EAvGJ;EAoHR,kBAAA,CAAA;EAlHQ;EAgIR,KAAA,CAAA;EA5HQ;EAoIR,IAAA,CAAA;AAAA;;;UC5Le,iBAAA;;EAEf,SAAA;EDMsB;ECJtB,OAAA,GAAU,cAAA;EDMyB;ECJnC,aAAA;AAAA;;;;;;;;ADeF;;iBCHsB,cAAA,GAAA,CACpB,EAAA,QAAU,OAAA,CAAQ,CAAA,GAClB,OAAA,GAAS,iBAAA,GACR,OAAA,CAAQ,CAAA;;;;iBAoBK,iBAAA,kCAAA,CACd,EAAA,MAAQ,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,GAChC,OAAA,EAAS,iBAAA,OACJ,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA;;;cC3ClB,YAAA,SAAqB,QAAA;EAAA,SACvB,SAAA;cAEG,OAAA,UAAiB,SAAA;AAAA;;;;;iBAef,WAAA,GAAA,CACd,OAAA,EAAS,OAAA,CAAQ,CAAA,GACjB,SAAA,UACA,OAAA,YACC,OAAA,CAAQ,CAAA;;;;;iBA2BK,uBAAA,CAAwB,SAAA;EACtC,UAAA,EAAY,eAAA;EACZ,OAAA;AAAA;;;;;iBAyBc,KAAA,CAAM,EAAA,UAAY,MAAA,GAAS,WAAA,GAAc,OAAA"}

package/dist/index-DiQX9bjq.d.ts

@@ -0,0 +1,55 @@
+//#region src/errors/index.d.ts
+/**
+ * SDK Error Types
+ *
+ * Structured errors with codes, retry hints, and context.
+ */
+/** Error categories for routing and handling */
+type ErrorCode = "NETWORK" | "TIMEOUT" | "AUTH" | "AUTH_EXPIRED" | "VALIDATION" | "NOT_FOUND" | "RATE_LIMITED" | "SERVER" | "CANCELLED" | "UNKNOWN";
+/** SDK error with structured metadata */
+declare class SDKError extends Error {
+  readonly code: ErrorCode;
+  readonly status?: number;
+  readonly retryable: boolean;
+  readonly retryAfterMs?: number;
+  readonly context?: Record<string, unknown>;
+  constructor(message: string, options: {
+    code: ErrorCode;
+    status?: number;
+    retryable?: boolean;
+    retryAfterMs?: number;
+    context?: Record<string, unknown>;
+    cause?: Error;
+  });
+  private inferRetryable;
+  /** Create from HTTP response */
+  static fromResponse(status: number, body?: unknown): SDKError;
+  /** Create from caught error */
+  static fromError(error: unknown): SDKError;
+  /**
+   * Extract a human-readable message from a parsed error response body.
+   *
+   * Probes shapes seen across our upstreams:
+   *   - `{ message: "..." }`           — most internal services
+   *   - `{ error: "..." }`             — flat-error shape
+   *   - `{ error: { message: "..." } }` — Hetzner Cloud API
+   *   - `{ error: { details: "..." } }` — Hetzner field-level details
+   *   - `string`                       — non-JSON text/plain errors
+   *
+   * Returns null if no message-like field is present so callers can
+   * fall back to "HTTP <status>". Without this, Hetzner 422s logged
+   * as opaque "HTTP 422" because the message lives at
+   * `body.error.message`, blocking diagnosis of every autoscaler
+   * failure (issue #785).
+   */
+  private static extractMessageFromBody;
+  /** Check if error is retryable after token refresh */
+  isAuthExpired(): boolean;
+}
+/** Type guard for SDKError */
+declare function isSDKError(error: unknown): error is SDKError;
+/** Type guard for retryable errors */
+declare function isRetryable(error: unknown): boolean;
+//#endregion
+export { isSDKError as i, SDKError as n, isRetryable as r, ErrorCode as t };
+//# sourceMappingURL=index-DiQX9bjq.d.ts.map

package/dist/index-DiQX9bjq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DiQX9bjq.d.ts","names":[],"sources":["../src/errors/index.ts"],"mappings":";;AAOA;;;;;KAAY,SAAA;;cAaC,QAAA,SAAiB,KAAA;EAAA,SACnB,IAAA,EAAM,SAAA;EAAA,SACN,MAAA;EAAA,SACA,SAAA;EAAA,SACA,YAAA;EAAA,SACA,OAAA,GAAU,MAAA;cAGjB,OAAA,UACA,OAAA;IACE,IAAA,EAAM,SAAA;IACN,MAAA;IACA,SAAA;IACA,YAAA;IACA,OAAA,GAAU,MAAA;IACV,KAAA,GAAQ,KAAA;EAAA;EAAA,QAaJ,cAAA;EAzBC;EAAA,OAqCF,YAAA,CAAa,MAAA,UAAgB,IAAA,aAAiB,QAAA;EAnC5C;EAAA,OAmGF,SAAA,CAAU,KAAA,YAAiB,QAAA;;;;;;;;;;;;;;;;;iBA8CnB,sBAAA;EA9CR;EAsFP,aAAA,CAAA;AAAA;;iBASc,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,QAAA;;iBAKrC,WAAA,CAAY,KAAA"}

package/dist/index-DlPznmKA.d.ts

@@ -0,0 +1,158 @@
+//#region src/events/buffer.d.ts
+/**
+ * Event Buffer
+ *
+ * Buffers events during disconnections for replay on reconnect.
+ * Implements overflow handling with configurable strategies.
+ */
+interface EventBufferConfig {
+  /** Maximum number of events to buffer (default: 1000) */
+  maxSize: number;
+  /** Time-to-live in milliseconds for buffered events (default: 300000 = 5min) */
+  ttlMs: number;
+  /** Strategy when buffer is full: "drop-oldest" or "drop-newest" */
+  overflowStrategy: "drop-oldest" | "drop-newest";
+}
+interface BufferedEvent<T = unknown> {
+  id: string;
+  data: T;
+  timestamp: number;
+  eventType?: string;
+}
+declare class EventBuffer<T = unknown> {
+  private readonly config;
+  private events;
+  private seenIds;
+  private cleanupTimer?;
+  constructor(config?: Partial<EventBufferConfig>);
+  /** Add an event to the buffer (deduplicates by ID) */
+  push(id: string, data: T, eventType?: string): void;
+  /** Get all buffered events */
+  getAll(): BufferedEvent<T>[];
+  /** Get events since a specific event ID */
+  getSince(lastEventId: string): BufferedEvent<T>[];
+  /** Get events after a timestamp */
+  getSinceTimestamp(timestamp: number): BufferedEvent<T>[];
+  /** Clear all buffered events */
+  clear(): void;
+  /** Get current buffer size */
+  size(): number;
+  /** Check if buffer is empty */
+  isEmpty(): boolean;
+  /** Check if buffer is full */
+  isFull(): boolean;
+  /** Dispose of the buffer and cleanup resources */
+  dispose(): void;
+  private pruneExpired;
+  private startCleanup;
+}
+//#endregion
+//#region src/events/channel.d.ts
+/**
+ * Channel Pub/Sub
+ *
+ * Topic-based event distribution with wildcard pattern matching.
+ * Supports patterns like "message.*", "**", and exact matches.
+ */
+type ChannelHandler<T = unknown> = (message: T, topic: string) => void;
+interface ChannelConfig {
+  /** Maximum number of subscribers per topic (default: 100) */
+  maxSubscribersPerTopic: number;
+  /** Enable wildcard patterns (default: true) */
+  enableWildcards: boolean;
+}
+declare class EventChannel<T = unknown> {
+  private readonly config;
+  private readonly subscribers;
+  constructor(config?: Partial<ChannelConfig>);
+  /**
+   * Subscribe to a topic or pattern.
+   *
+   * Patterns:
+   * - "exact.topic" - matches only "exact.topic"
+   * - "prefix.*" - matches "prefix.foo", "prefix.bar", etc.
+   * - "prefix.**" - matches "prefix.foo", "prefix.foo.bar", etc.
+   * - "**" - matches all topics
+   *
+   * Returns an unsubscribe function.
+   */
+  subscribe(pattern: string, handler: ChannelHandler<T>): () => void;
+  /**
+   * Publish a message to a topic.
+   * Delivers to all matching subscribers.
+   */
+  publish(topic: string, message: T): number;
+  /**
+   * Check if any subscribers are listening to a topic.
+   */
+  hasSubscribers(topic: string): boolean;
+  /**
+   * Get the number of subscribers for a topic.
+   */
+  subscriberCount(topic: string): number;
+  /**
+   * Get all unique patterns being subscribed to.
+   */
+  getPatterns(): string[];
+  /**
+   * Clear all subscribers.
+   */
+  clear(): void;
+  /**
+   * Get total subscriber count.
+   */
+  size(): number;
+  private matches;
+  private patternToRegex;
+}
+//#endregion
+//#region src/events/deduplication.d.ts
+/**
+ * Event Deduplication
+ *
+ * LRU-bounded set for tracking seen event IDs.
+ * Prevents duplicate event processing during reconnections.
+ */
+interface DeduplicatorConfig {
+  /** Maximum number of event IDs to track (default: 10000) */
+  maxSize: number;
+  /** Time window in milliseconds for deduplication (default: 60000 = 1min) */
+  windowMs: number;
+}
+declare class EventDeduplicator {
+  private readonly config;
+  private readonly seen;
+  private cleanupTimer?;
+  constructor(config?: Partial<DeduplicatorConfig>);
+  /**
+   * Check if an event has been seen and mark it as seen.
+   * Returns true if this is a duplicate, false if it's new.
+   */
+  isDuplicate(eventId: string): boolean;
+  /**
+   * Mark an event as seen without checking for duplicates.
+   */
+  markSeen(eventId: string): void;
+  /**
+   * Check if an event has been seen (without marking).
+   */
+  hasSeen(eventId: string): boolean;
+  /**
+   * Clear all tracked events.
+   */
+  clear(): void;
+  /**
+   * Get the number of tracked events.
+   */
+  size(): number;
+  /**
+   * Dispose of the deduplicator and cleanup resources.
+   */
+  dispose(): void;
+  private evictOldest;
+  private pruneExpired;
+  private startCleanup;
+}
+//#endregion
+export { EventChannel as a, EventBufferConfig as c, ChannelHandler as i, EventDeduplicator as n, BufferedEvent as o, ChannelConfig as r, EventBuffer as s, DeduplicatorConfig as t };
+//# sourceMappingURL=index-DlPznmKA.d.ts.map

package/dist/index-DlPznmKA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DlPznmKA.d.ts","names":[],"sources":["../src/events/buffer.ts","../src/events/channel.ts","../src/events/deduplication.ts"],"mappings":";;AAOA;;;;;UAAiB,iBAAA;EAMf;EAJA,OAAA;EAIgB;EAFhB,KAAA;EAK4B;EAH5B,gBAAA;AAAA;AAAA,UAGe,aAAA;EACf,EAAA;EACA,IAAA,EAAM,CAAA;EACN,SAAA;EACA,SAAA;AAAA;AAAA,cASW,WAAA;EAAA,iBACM,MAAA;EAAA,QACT,MAAA;EAAA,QACA,OAAA;EAAA,QACA,YAAA;cAEI,MAAA,GAAQ,OAAA,CAAQ,iBAAA;EAAR;EAMpB,IAAA,CAAK,EAAA,UAAY,IAAA,EAAM,CAAA,EAAG,SAAA;EA6BF;EAAxB,MAAA,CAAA,GAAU,aAAA,CAAc,CAAA;EAMqB;EAA7C,QAAA,CAAS,WAAA,WAAsB,aAAA,CAAc,CAAA;EAUO;EAApD,iBAAA,CAAkB,SAAA,WAAoB,aAAA,CAAc,CAAA;EAAD;EAMnD,KAAA,CAAA;EA/DuB;EAqEvB,IAAA,CAAA;EAnEQ;EAwER,OAAA,CAAA;EAtEQ;EA2ER,MAAA,CAAA;EAzEoB;EA8EpB,OAAA,CAAA;EAAA,QAQQ,YAAA;EAAA,QASA,YAAA;AAAA;;;;AA3HV;;;;;KCAY,cAAA,iBAA+B,OAAA,EAAS,CAAA,EAAG,KAAA;AAAA,UAEtC,aAAA;EDIC;ECFhB,sBAAA;EDKe;ECHf,eAAA;AAAA;AAAA,cAcW,YAAA;EAAA,iBACM,MAAA;EAAA,iBACA,WAAA;cAEL,MAAA,GAAQ,OAAA,CAAQ,aAAA;EDbtB;;;;;AAWR;;;;;;ECiBE,SAAA,CAAU,OAAA,UAAiB,OAAA,EAAS,cAAA,CAAe,CAAA;EDwBzC;;;;ECDV,OAAA,CAAQ,KAAA,UAAe,OAAA,EAAS,CAAA;EDiBmB;;;ECGnD,cAAA,CAAe,KAAA;ED1DP;;;ECiER,eAAA,CAAgB,KAAA;ED7DI;;;ECoEpB,WAAA,CAAA;ED9DK;;;ECqEL,KAAA,CAAA;EDxCA;;;EC+CA,IAAA,CAAA;EAAA,QAIQ,OAAA;EAAA,QAOA,cAAA;AAAA;;;;ADzHV;;;;;UEAiB,kBAAA;EFMf;EEJA,OAAA;EFIgB;EEFhB,QAAA;AAAA;AAAA,cAYW,iBAAA;EAAA,iBACM,MAAA;EAAA,iBACA,IAAA;EAAA,QACT,YAAA;cAEI,MAAA,GAAQ,OAAA,CAAQ,kBAAA;EFVtB;;;;EEmBN,WAAA,CAAY,OAAA;EFRD;;;EE4BX,QAAA,CAAS,OAAA;EFtBW;;;EEgCpB,OAAA,CAAQ,OAAA;EFSqC;;;EEA7C,KAAA,CAAA;EFUmD;;;EEHnD,IAAA,CAAA;EFpDQ;;;EE2DR,OAAA,CAAA;EAAA,QAQQ,WAAA;EAAA,QAQA,YAAA;EAAA,QASA,YAAA;AAAA"}

package/dist/index-z2wPdzFb.d.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { FilePart, Part, Part as Part$1, PartBase, ReasoningPart, SubtaskPart, TextPart, ToolPart, ToolState, ToolStateCompleted, ToolStateError, ToolStatePending, ToolStateRunning, isFilePart, isReasoningPart, isSubtaskPart, isTextPart, isToolPart } from "@tangle-network/agent-interface";
+
+//#region src/types/events.d.ts
+declare const AgentEventTypeSchema: z.ZodEnum<{
+  error: "error";
+  heartbeat: "heartbeat";
+  "message.part.updated": "message.part.updated";
+  status: "status";
+  "connection.init": "connection.init";
+  "history.replay.start": "history.replay.start";
+  "history.replay.end": "history.replay.end";
+  "execution.started": "execution.started";
+  "execution.completed": "execution.completed";
+  "execution.failed": "execution.failed";
+  "session.updated": "session.updated";
+  result: "result";
+  done: "done";
+}>;
+type AgentEventType = z.infer<typeof AgentEventTypeSchema>;
+interface EventMetadata {
+  serverInstanceId: string;
+  seq: number;
+  prevSeq: number | null;
+  sentAt: number;
+}
+interface MessagePartUpdatedEvent {
+  type: "message.part.updated";
+  part: Part;
+  delta?: string;
+  _meta?: EventMetadata;
+}
+interface StatusEvent {
+  type: "status";
+  status: "started" | "processing" | "completed" | "failed";
+  detail?: string;
+  _meta?: EventMetadata;
+}
+interface ErrorEvent {
+  type: "error";
+  code?: string;
+  message: string;
+  details?: unknown;
+  _meta?: EventMetadata;
+}
+interface HeartbeatEvent {
+  type: "heartbeat";
+  timestamp?: number;
+  _meta?: EventMetadata;
+}
+interface ConnectionInitEvent {
+  type: "connection.init";
+  serverInstanceId?: string;
+  streamId?: string;
+  initialSeq?: number;
+  timestamp?: number;
+  _meta?: EventMetadata;
+}
+interface ReplayStartEvent {
+  type: "history.replay.start";
+  executionId?: string;
+  sessionId?: string;
+  totalEvents?: number;
+  status?: string;
+}
+interface ReplayEndEvent {
+  type: "history.replay.end";
+  executionId?: string;
+  totalEventsReplayed?: number;
+  status?: string;
+  continuing?: boolean;
+}
+interface ExecutionStartedEvent {
+  type: "execution.started";
+  executionId?: string;
+  sessionId?: string;
+  timestamp?: number;
+}
+interface ExecutionCompletedEvent {
+  type: "execution.completed";
+  executionId?: string;
+  sessionId?: string;
+  timestamp?: number;
+}
+interface ExecutionFailedEvent {
+  type: "execution.failed";
+  executionId?: string;
+  sessionId?: string;
+  error?: string;
+  timestamp?: number;
+}
+interface SessionUpdatedEvent {
+  type: "session.updated";
+  sessionId: string;
+  title?: string;
+  time?: {
+    created?: number;
+    updated?: number;
+  };
+}
+interface ResultEvent {
+  type: "result";
+  finalText?: string;
+  toolInvocations?: unknown[];
+  tokenUsage?: Record<string, unknown>;
+  timing?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+}
+interface DoneEvent {
+  type: "done";
+  requestId?: string;
+}
+type AgentEvent = MessagePartUpdatedEvent | StatusEvent | ErrorEvent | HeartbeatEvent | ConnectionInitEvent | ReplayStartEvent | ReplayEndEvent | ExecutionStartedEvent | ExecutionCompletedEvent | ExecutionFailedEvent | SessionUpdatedEvent | ResultEvent | DoneEvent;
+interface TerminalDataEvent {
+  type: "terminal.data";
+  data: string;
+  terminalId: string;
+}
+interface TerminalResizeEvent {
+  type: "terminal.resize";
+  cols: number;
+  rows: number;
+  terminalId: string;
+}
+interface TerminalExitEvent {
+  type: "terminal.exit";
+  exitCode: number;
+  terminalId: string;
+}
+type TerminalEvent = TerminalDataEvent | TerminalResizeEvent | TerminalExitEvent;
+//#endregion
+export { ToolStateCompleted as A, TerminalDataEvent as C, TextPart as D, TerminalResizeEvent as E, isReasoningPart as F, isSubtaskPart as I, isTextPart as L, ToolStatePending as M, ToolStateRunning as N, ToolPart as O, isFilePart as P, isToolPart as R, SubtaskPart as S, TerminalExitEvent as T, ReplayEndEvent as _, DoneEvent as a, SessionUpdatedEvent as b, ExecutionCompletedEvent as c, FilePart as d, HeartbeatEvent as f, ReasoningPart as g, PartBase as h, ConnectionInitEvent as i, ToolStateError as j, ToolState as k, ExecutionFailedEvent as l, Part$1 as m, AgentEventType as n, ErrorEvent as o, MessagePartUpdatedEvent as p, AgentEventTypeSchema as r, EventMetadata as s, AgentEvent as t, ExecutionStartedEvent as u, ReplayStartEvent as v, TerminalEvent as w, StatusEvent as x, ResultEvent as y };
+//# sourceMappingURL=index-z2wPdzFb.d.ts.map

package/dist/index-z2wPdzFb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-z2wPdzFb.d.ts","names":[],"sources":["../src/types/events.ts"],"mappings":";;;;cAsCa,oBAAA,EAAoB,CAAA,CAAA,OAAA;;;;;;;;;;;;;;;KAgBrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,UAG3B,aAAA;EACf,gBAAA;EACA,GAAA;EACA,OAAA;EACA,MAAA;AAAA;AAAA,UAOe,uBAAA;EACf,IAAA;EACA,IAAA,EAAM,IAAA;EACN,KAAA;EACA,KAAA,GAAQ,aAAA;AAAA;AAAA,UAIO,WAAA;EACf,IAAA;EACA,MAAA;EACA,MAAA;EACA,KAAA,GAAQ,aAAA;AAAA;AAAA,UAIO,UAAA;EACf,IAAA;EACA,IAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA,GAAQ,aAAA;AAAA;AAAA,UAIO,cAAA;EACf,IAAA;EACA,SAAA;EACA,KAAA,GAAQ,aAAA;AAAA;AAAA,UAIO,mBAAA;EACf,IAAA;EACA,gBAAA;EACA,QAAA;EACA,UAAA;EACA,SAAA;EACA,KAAA,GAAQ,aAAA;AAAA;AAAA,UAIO,gBAAA;EACf,IAAA;EACA,WAAA;EACA,SAAA;EACA,WAAA;EACA,MAAA;AAAA;AAAA,UAGe,cAAA;EACf,IAAA;EACA,WAAA;EACA,mBAAA;EACA,MAAA;EACA,UAAA;AAAA;AAAA,UAIe,qBAAA;EACf,IAAA;EACA,WAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,UAGe,uBAAA;EACf,IAAA;EACA,WAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,UAGe,oBAAA;EACf,IAAA;EACA,WAAA;EACA,SAAA;EACA,KAAA;EACA,SAAA;AAAA;AAAA,UAIe,mBAAA;EACf,IAAA;EACA,SAAA;EACA,KAAA;EACA,IAAA;IAAS,OAAA;IAAkB,OAAA;EAAA;AAAA;AAAA,UAIZ,WAAA;EACf,IAAA;EACA,SAAA;EACA,eAAA;EACA,UAAA,GAAa,MAAA;EACb,MAAA,GAAS,MAAA;EACT,QAAA,GAAW,MAAA;AAAA;AAAA,UAII,SAAA;EACf,IAAA;EACA,SAAA;AAAA;AAAA,KAIU,UAAA,GACR,uBAAA,GACA,WAAA,GACA,UAAA,GACA,cAAA,GACA,mBAAA,GACA,gBAAA,GACA,cAAA,GACA,qBAAA,GACA,uBAAA,GACA,oBAAA,GACA,mBAAA,GACA,WAAA,GACA,SAAA;AAAA,UAGa,iBAAA;EACf,IAAA;EACA,IAAA;EACA,UAAA;AAAA;AAAA,UAGe,mBAAA;EACf,IAAA;EACA,IAAA;EACA,IAAA;EACA,UAAA;AAAA;AAAA,UAGe,iBAAA;EACf,IAAA;EACA,QAAA;EACA,UAAA;AAAA;AAAA,KAGU,aAAA,GACR,iBAAA,GACA,mBAAA,GACA,iBAAA"}