@rivetkit/cloudflare-workers/dist/mod.d.cts

Cloudflare Workers adapter for RivetKit actors

import { Client, Registry, RunConfig, ActorKey } from 'rivetkit';
export { Client } from 'rivetkit';
import { DurableObject } from 'cloudflare:workers';
import * as rivetkit_log from 'rivetkit/log';
import { z } from 'zod';

interface DriverContext {
    state: DurableObjectState;
}

declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
    maxIncomingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    maxOutgoingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    inspector: z.ZodDefault<z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
            actor: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
            manager: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        }, z.core.$strip>]>>>;
        token: z.ZodDefault<z.ZodOptional<z.ZodCustom<() => string, () => string>>>;
        defaultEndpoint: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    disableDefaultServer: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    defaultServerPort: z.ZodDefault<z.ZodNumber>;
    runEngine: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    runEngineVersion: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    overrideServerAddress: z.ZodOptional<z.ZodString>;
    disableActorDriver: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    runnerKind: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
        serverless: "serverless";
        normal: "normal";
    }>>>;
    basePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    noWelcome: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    logging: z.ZodDefault<z.ZodOptional<z.ZodObject<{
        baseLogger: z.ZodOptional<z.ZodCustom<rivetkit_log.Logger, rivetkit_log.Logger>>;
        level: z.ZodOptional<z.ZodEnum<{
            error: "error";
            trace: "trace";
            fatal: "fatal";
            warn: "warn";
            info: "info";
            debug: "debug";
            silent: "silent";
        }>>;
    }, z.core.$strip>>>;
    autoConfigureServerless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        url: z.ZodOptional<z.ZodString>;
        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        maxRunners: z.ZodOptional<z.ZodNumber>;
        minRunners: z.ZodOptional<z.ZodNumber>;
        requestLifespan: z.ZodOptional<z.ZodNumber>;
        runnersMargin: z.ZodOptional<z.ZodNumber>;
        slotsPerRunner: z.ZodOptional<z.ZodNumber>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>]>>;
    runnerKey: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
    totalSlots: z.ZodDefault<z.ZodNumber>;
    endpoint: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
    token: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
    namespace: z.ZodDefault<z.ZodString>;
    runnerName: z.ZodDefault<z.ZodString>;
    encoding: z.ZodDefault<z.ZodEnum<{
        json: "json";
        cbor: "cbor";
        bare: "bare";
    }>>;
    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
    disableMetadataLookup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    managerPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    fetch: z.ZodOptional<z.ZodCustom<ExportedHandlerFetchHandler<{
        RIVET: Client<any>;
    }, unknown>, ExportedHandlerFetchHandler<{
        RIVET: Client<any>;
    }, unknown>>>;
}, z.core.$strip>>;
type InputConfig = z.input<typeof ConfigSchema>;
type Config = z.infer<typeof ConfigSchema>;

/** Cloudflare Workers env */
interface Bindings {
    ACTOR_KV: KVNamespace;
    ACTOR_DO: DurableObjectNamespace<ActorHandlerInterface>;
}
interface InlineOutput<A extends Registry<any>> {
    /** Client to communicate with the actors. */
    client: Client<A>;
    /** Fetch handler to manually route requests to the Rivet manager API. */
    fetch: (request: Request, ...args: any) => Response | Promise<Response>;
    config: Config;
    ActorHandler: DurableObjectConstructor;
}
interface HandlerOutput {
    handler: ExportedHandler<Bindings>;
    ActorHandler: DurableObjectConstructor;
}
/**
 * Creates an inline client for accessing Rivet Actors privately without a public manager API.
 *
 * If you want to expose a public manager API, either:
 *
 * - Use `createHandler` to expose the Rivet API on `/rivet`
 * - Forward Rivet API requests to `InlineOutput::fetch`
 */
declare function createInlineClient<R extends Registry<any>>(registry: R, inputConfig?: InputConfig): InlineOutput<R>;
/**
 * Creates a handler to be exported from a Cloudflare Worker.
 *
 * This will automatically expose the Rivet manager API on `/rivet`.
 *
 * This includes a `fetch` handler and `ActorHandler` Durable Object.
 */
declare function createHandler<R extends Registry<any>>(registry: R, inputConfig?: InputConfig): HandlerOutput;

interface ActorHandlerInterface extends DurableObject {
    create(req: ActorInitRequest): Promise<ActorInitResponse>;
    getMetadata(): Promise<{
        actorId: string;
        name: string;
        key: ActorKey;
        destroying: boolean;
    } | undefined>;
}
interface ActorInitRequest {
    name: string;
    key: ActorKey;
    input?: unknown;
    allowExisting: boolean;
}
type ActorInitResponse = {
    success: {
        actorId: string;
        created: boolean;
    };
} | {
    error: {
        actorAlreadyExists: true;
    };
};
type DurableObjectConstructor = new (...args: ConstructorParameters<typeof DurableObject<Bindings>>) => DurableObject<Bindings>;
declare function createActorDurableObject(registry: Registry<any>, rootRunConfig: RunConfig): DurableObjectConstructor;

export { type Bindings, type InputConfig as Config, type DriverContext, type HandlerOutput, type InlineOutput, createActorDurableObject, createHandler, createInlineClient };