agents 0.0.0-bcae0ba → 0.0.0-c3e8618

package/dist/index.d.ts

@@ -1,221 +1,202 @@
-import { Server, Connection, PartyServerOptions } from "partyserver";
-export { Connection, ConnectionContext, WSMessage } from "partyserver";
-import { WorkflowEntrypoint as WorkflowEntrypoint$1 } from "cloudflare:workers";
+import { Server, Connection, PartyServerOptions } from 'partyserver';
+export { Connection, ConnectionContext, WSMessage } from 'partyserver';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { WorkflowEntrypoint as WorkflowEntrypoint$1 } from 'cloudflare:workers';
 
 /**
  * RPC request message from client
  */
 type RPCRequest = {
-  type: "rpc";
-  id: string;
-  method: string;
-  args: unknown[];
+    type: "rpc";
+    id: string;
+    method: string;
+    args: unknown[];
 };
 /**
  * State update message from client
  */
 type StateUpdateMessage = {
-  type: "cf_agent_state";
-  state: unknown;
+    type: "cf_agent_state";
+    state: unknown;
 };
 /**
  * RPC response message to client
  */
 type RPCResponse = {
-  type: "rpc";
-  id: string;
-} & (
-  | {
-      success: true;
-      result: unknown;
-      done?: false;
-    }
-  | {
-      success: true;
-      result: unknown;
-      done: true;
-    }
-  | {
-      success: false;
-      error: string;
-    }
-);
+    type: "rpc";
+    id: string;
+} & ({
+    success: true;
+    result: unknown;
+    done?: false;
+} | {
+    success: true;
+    result: unknown;
+    done: true;
+} | {
+    success: false;
+    error: string;
+});
 /**
  * Metadata for a callable method
  */
 type CallableMetadata = {
-  /** Optional description of what the method does */
-  description?: string;
-  /** Whether the method supports streaming responses */
-  streaming?: boolean;
+    /** Optional description of what the method does */
+    description?: string;
+    /** Whether the method supports streaming responses */
+    streaming?: boolean;
 };
 /**
  * Decorator that marks a method as callable by clients
  * @param metadata Optional metadata about the callable method
  */
-declare function unstable_callable(
-  metadata?: CallableMetadata
-): <This, Args extends unknown[], Return>(
-  target: (this: This, ...args: Args) => Return,
-  context: ClassMethodDecoratorContext
-) => (this: This, ...args: Args) => Return;
+declare function unstable_callable(metadata?: CallableMetadata): <This, Args extends unknown[], Return>(target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext) => (this: This, ...args: Args) => Return;
 /**
  * A class for creating workflow entry points that can be used with Cloudflare Workers
  */
-declare class WorkflowEntrypoint extends WorkflowEntrypoint$1 {}
+declare class WorkflowEntrypoint extends WorkflowEntrypoint$1 {
+}
 /**
  * Represents a scheduled task within an Agent
  * @template T Type of the payload data
  */
 type Schedule<T = string> = {
-  /** Unique identifier for the schedule */
-  id: string;
-  /** Name of the method to be called */
-  callback: string;
-  /** Data to be passed to the callback */
-  payload: T;
-} & (
-  | {
-      /** Type of schedule for one-time execution at a specific time */
-      type: "scheduled";
-      /** Timestamp when the task should execute */
-      time: number;
-    }
-  | {
-      /** Type of schedule for delayed execution */
-      type: "delayed";
-      /** Timestamp when the task should execute */
-      time: number;
-      /** Number of seconds to delay execution */
-      delayInSeconds: number;
-    }
-  | {
-      /** Type of schedule for recurring execution based on cron expression */
-      type: "cron";
-      /** Timestamp for the next execution */
-      time: number;
-      /** Cron expression defining the schedule */
-      cron: string;
-    }
-);
+    /** Unique identifier for the schedule */
+    id: string;
+    /** Name of the method to be called */
+    callback: string;
+    /** Data to be passed to the callback */
+    payload: T;
+} & ({
+    /** Type of schedule for one-time execution at a specific time */
+    type: "scheduled";
+    /** Timestamp when the task should execute */
+    time: number;
+} | {
+    /** Type of schedule for delayed execution */
+    type: "delayed";
+    /** Timestamp when the task should execute */
+    time: number;
+    /** Number of seconds to delay execution */
+    delayInSeconds: number;
+} | {
+    /** Type of schedule for recurring execution based on cron expression */
+    type: "cron";
+    /** Timestamp for the next execution */
+    time: number;
+    /** Cron expression defining the schedule */
+    cron: string;
+});
+declare const unstable_context: AsyncLocalStorage<{
+    agent: Agent<unknown>;
+    connection: Connection | undefined;
+    request: Request | undefined;
+}>;
 /**
  * Base class for creating Agent implementations
  * @template Env Environment type containing bindings
  * @template State State type to store within the Agent
  */
 declare class Agent<Env, State = unknown> extends Server<Env> {
-  #private;
-  /**
-   * Initial state for the Agent
-   * Override to provide default state values
-   */
-  initialState: State;
-  /**
-   * Current state of the Agent
-   */
-  get state(): State;
-  /**
-   * Agent configuration options
-   */
-  static options: {
-    /** Whether the Agent should hibernate when inactive */
-    hibernate: boolean;
-  };
-  /**
-   * Execute SQL queries against the Agent's database
-   * @template T Type of the returned rows
-   * @param strings SQL query template strings
-   * @param values Values to be inserted into the query
-   * @returns Array of query results
-   */
-  sql<T = Record<string, string | number | boolean | null>>(
-    strings: TemplateStringsArray,
-    ...values: (string | number | boolean | null)[]
-  ): T[];
-  constructor(ctx: AgentContext, env: Env);
-  /**
-   * Update the Agent's state
-   * @param state New state to set
-   */
-  setState(state: State): void;
-  /**
-   * Called when the Agent's state is updated
-   * @param state Updated state
-   * @param source Source of the state update ("server" or a client connection)
-   */
-  onStateUpdate(state: State | undefined, source: Connection | "server"): void;
-  /**
-   * Called when the Agent receives an email
-   * @param email Email message to process
-   */
-  onEmail(email: ForwardableEmailMessage): void;
-  /**
-   * Render content (not implemented in base class)
-   */
-  render(): void;
-  /**
-   * Schedule a task to be executed in the future
-   * @template T Type of the payload data
-   * @param when When to execute the task (Date, seconds delay, or cron expression)
-   * @param callback Name of the method to call
-   * @param payload Data to pass to the callback
-   * @returns Schedule object representing the scheduled task
-   */
-  schedule<T = string>(
-    when: Date | string | number,
-    callback: keyof this,
-    payload?: T
-  ): Promise<Schedule<T>>;
-  /**
-   * Get a scheduled task by ID
-   * @template T Type of the payload data
-   * @param id ID of the scheduled task
-   * @returns The Schedule object or undefined if not found
-   */
-  getSchedule<T = string>(id: string): Promise<Schedule<T> | undefined>;
-  /**
-   * Get scheduled tasks matching the given criteria
-   * @template T Type of the payload data
-   * @param criteria Criteria to filter schedules
-   * @returns Array of matching Schedule objects
-   */
-  getSchedules<T = string>(criteria?: {
-    description?: string;
-    id?: string;
-    type?: "scheduled" | "delayed" | "cron";
-    timeRange?: {
-      start?: Date;
-      end?: Date;
+    #private;
+    /**
+     * Initial state for the Agent
+     * Override to provide default state values
+     */
+    initialState: State;
+    /**
+     * Current state of the Agent
+     */
+    get state(): State;
+    /**
+     * Agent configuration options
+     */
+    static options: {
+        /** Whether the Agent should hibernate when inactive */
+        hibernate: boolean;
     };
-  }): Schedule<T>[];
-  /**
-   * Cancel a scheduled task
-   * @param id ID of the task to cancel
-   * @returns true if the task was cancelled, false otherwise
-   */
-  cancelSchedule(id: string): Promise<boolean>;
-  private scheduleNextAlarm;
-  /**
-   * Method called when an alarm fires
-   * Executes any scheduled tasks that are due
-   */
-  alarm(): Promise<void>;
-  /**
-   * Destroy the Agent, removing all state and scheduled tasks
-   */
-  destroy(): Promise<void>;
-  /**
-   * Get all methods marked as callable on this Agent
-   * @returns A map of method names to their metadata
-   */
-  private isCallable;
+    /**
+     * Execute SQL queries against the Agent's database
+     * @template T Type of the returned rows
+     * @param strings SQL query template strings
+     * @param values Values to be inserted into the query
+     * @returns Array of query results
+     */
+    sql<T = Record<string, string | number | boolean | null>>(strings: TemplateStringsArray, ...values: (string | number | boolean | null)[]): T[];
+    constructor(ctx: AgentContext, env: Env);
+    /**
+     * Update the Agent's state
+     * @param state New state to set
+     */
+    setState(state: State): void;
+    /**
+     * Called when the Agent's state is updated
+     * @param state Updated state
+     * @param source Source of the state update ("server" or a client connection)
+     */
+    onStateUpdate(state: State | undefined, source: Connection | "server"): void;
+    /**
+     * Called when the Agent receives an email
+     * @param email Email message to process
+     */
+    onEmail(email: ForwardableEmailMessage): Promise<void>;
+    onError(connection: Connection, error: unknown): void | Promise<void>;
+    onError(error: unknown): void | Promise<void>;
+    /**
+     * Render content (not implemented in base class)
+     */
+    render(): void;
+    /**
+     * Schedule a task to be executed in the future
+     * @template T Type of the payload data
+     * @param when When to execute the task (Date, seconds delay, or cron expression)
+     * @param callback Name of the method to call
+     * @param payload Data to pass to the callback
+     * @returns Schedule object representing the scheduled task
+     */
+    schedule<T = string>(when: Date | string | number, callback: keyof this, payload?: T): Promise<Schedule<T>>;
+    /**
+     * Get a scheduled task by ID
+     * @template T Type of the payload data
+     * @param id ID of the scheduled task
+     * @returns The Schedule object or undefined if not found
+     */
+    getSchedule<T = string>(id: string): Promise<Schedule<T> | undefined>;
+    /**
+     * Get scheduled tasks matching the given criteria
+     * @template T Type of the payload data
+     * @param criteria Criteria to filter schedules
+     * @returns Array of matching Schedule objects
+     */
+    getSchedules<T = string>(criteria?: {
+        id?: string;
+        type?: "scheduled" | "delayed" | "cron";
+        timeRange?: {
+            start?: Date;
+            end?: Date;
+        };
+    }): Schedule<T>[];
+    /**
+     * Cancel a scheduled task
+     * @param id ID of the task to cancel
+     * @returns true if the task was cancelled, false otherwise
+     */
+    cancelSchedule(id: string): Promise<boolean>;
+    /**
+     * Method called when an alarm fires
+     * Executes any scheduled tasks that are due
+     */
+    alarm(): Promise<void>;
+    /**
+     * Destroy the Agent, removing all state and scheduled tasks
+     */
+    destroy(): Promise<void>;
 }
 /**
  * Namespace for creating Agent instances
  * @template Agentic Type of the Agent class
  */
-type AgentNamespace<Agentic extends Agent<unknown>> =
-  DurableObjectNamespace<Agentic>;
+type AgentNamespace<Agentic extends Agent<unknown>> = DurableObjectNamespace<Agentic>;
 /**
  * Agent's durable context
  */
@@ -224,10 +205,10 @@ type AgentContext = DurableObjectState;
  * Configuration options for Agent routing
  */
 type AgentOptions<Env> = PartyServerOptions<Env> & {
-  /**
-   * Whether to enable CORS for the Agent
-   */
-  cors?: boolean | HeadersInit | undefined;
+    /**
+     * Whether to enable CORS for the Agent
+     */
+    cors?: boolean | HeadersInit | undefined;
 };
 /**
  * Route a request to the appropriate Agent
@@ -236,22 +217,14 @@ type AgentOptions<Env> = PartyServerOptions<Env> & {
  * @param options Routing options
  * @returns Response from the Agent or undefined if no route matched
  */
-declare function routeAgentRequest<Env>(
-  request: Request,
-  env: Env,
-  options?: AgentOptions<Env>
-): Promise<Response | null>;
+declare function routeAgentRequest<Env>(request: Request, env: Env, options?: AgentOptions<Env>): Promise<Response | null>;
 /**
  * Route an email to the appropriate Agent
  * @param email Email message to route
  * @param env Environment containing Agent bindings
  * @param options Routing options
  */
-declare function routeAgentEmail<Env>(
-  email: ForwardableEmailMessage,
-  env: Env,
-  options?: AgentOptions<Env>
-): Promise<void>;
+declare function routeAgentEmail<Env>(email: ForwardableEmailMessage, env: Env, options?: AgentOptions<Env>): Promise<void>;
 /**
  * Get or create an Agent by name
  * @template Env Environment type containing bindings
@@ -261,46 +234,26 @@ declare function routeAgentEmail<Env>(
  * @param options Options for Agent creation
  * @returns Promise resolving to an Agent instance stub
  */
-declare function getAgentByName<Env, T extends Agent<Env>>(
-  namespace: AgentNamespace<T>,
-  name: string,
-  options?: {
+declare function getAgentByName<Env, T extends Agent<Env>>(namespace: AgentNamespace<T>, name: string, options?: {
     jurisdiction?: DurableObjectJurisdiction;
     locationHint?: DurableObjectLocationHint;
-  }
-): Promise<DurableObjectStub<T>>;
+}): Promise<DurableObjectStub<T>>;
 /**
  * A wrapper for streaming responses in callable methods
  */
 declare class StreamingResponse {
-  #private;
-  constructor(connection: Connection, id: string);
-  /**
-   * Send a chunk of data to the client
-   * @param chunk The data to send
-   */
-  send(chunk: unknown): void;
-  /**
-   * End the stream and send the final chunk (if any)
-   * @param finalChunk Optional final chunk of data to send
-   */
-  end(finalChunk?: unknown): void;
+    #private;
+    constructor(connection: Connection, id: string);
+    /**
+     * Send a chunk of data to the client
+     * @param chunk The data to send
+     */
+    send(chunk: unknown): void;
+    /**
+     * End the stream and send the final chunk (if any)
+     * @param finalChunk Optional final chunk of data to send
+     */
+    end(finalChunk?: unknown): void;
 }
 
-export {
-  Agent,
-  type AgentContext,
-  type AgentNamespace,
-  type AgentOptions,
-  type CallableMetadata,
-  type RPCRequest,
-  type RPCResponse,
-  type Schedule,
-  type StateUpdateMessage,
-  StreamingResponse,
-  WorkflowEntrypoint,
-  getAgentByName,
-  routeAgentEmail,
-  routeAgentRequest,
-  unstable_callable,
-};
+export { Agent, type AgentContext, type AgentNamespace, type AgentOptions, type CallableMetadata, type RPCRequest, type RPCResponse, type Schedule, type StateUpdateMessage, StreamingResponse, WorkflowEntrypoint, getAgentByName, routeAgentEmail, routeAgentRequest, unstable_callable, unstable_context };