dewee-webchat 0.0.0-stage → 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,125 @@
+import { A as AgentInfo, H as HistoryMessage, C as ChatStreamEvent } from './protocol-CS8_4zC0.js';
+export { P as PublicConfig, S as SessionResponse } from './protocol-CS8_4zC0.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+interface VisitorClaims {
+    /** Visitor id (random, 22 chars). */
+    v: string;
+    /** Expiry, epoch ms. */
+    exp: number;
+}
+declare function signVisitorToken(secret: string, claims: VisitorClaims): Promise<string>;
+declare function verifyVisitorToken(secret: string, token: string): Promise<VisitorClaims | null>;
+/** Returns true when the key may proceed. Implementations may be async (KV, DO, Redis…). */
+type RateLimiter = (key: string, bucket: "session" | "chat") => boolean | Promise<boolean>;
+/**
+ * Fixed-window in-memory limiter. Good enough for a single Node process; on serverless
+ * runtimes each isolate keeps its own counters, so pass a shared limiter for hard limits.
+ */
+declare function memoryRateLimiter(limits: {
+    chat: [number, number];
+    session: [number, number];
+}): RateLimiter;
+
+interface DeweeHandlerOptions {
+    /** Gateway runtime origin. Required unless every request brings its own credentials. */
+    gatewayUrl?: string;
+    /** Gateway token or operator API key (server-side only). */
+    token?: string;
+    tenantId?: string;
+    /** HMAC secret for visitor tokens (>= 32 random chars). */
+    secret?: string;
+    /** Agents visitors may talk to. The first is the default. `"*"` = every active agent. */
+    agents?: Array<string | AgentInfo> | "*";
+    defaultAgent?: string;
+    /** Let the widget switch between allowed agents. Default: true when more than one agent. */
+    allowAgentSwitch?: boolean;
+    /** Cross-origin sites allowed to call this backend. Same-origin is always allowed. */
+    allowedOrigins?: string[] | "*";
+    /**
+     * Let visitors bring their own gateway URL + token (sent per request, never stored).
+     * Meant for playgrounds. `allowedHosts` restricts which gateways may be targeted.
+     */
+    allowClientCredentials?: boolean | {
+        allowedHosts?: string[];
+    };
+    /** Cloudflare Turnstile. When set, issuing a visitor session requires a valid challenge. */
+    turnstile?: {
+        siteKey: string;
+        secretKey: string;
+    };
+    /** Custom limiter, or false to disable. Default: in-memory 20 msgs/min, 10 sessions/10 min per IP. */
+    rateLimit?: RateLimiter | false;
+    maxMessageLength?: number;
+    /** Prefix for the per-visitor gateway user id. */
+    userIdPrefix?: string;
+    sessionTtlMs?: number;
+    /** Max duration of one agent run. */
+    timeoutMs?: number;
+    /** Observe traffic (logging/analytics). Errors thrown here are ignored. */
+    onChat?: (info: {
+        visitorId: string;
+        agent: string;
+        message: string;
+        reply?: string;
+        error?: string;
+    }) => void;
+}
+type Handler = (request: Request) => Promise<Response>;
+declare function createDeweeHandler(options: DeweeHandlerOptions): Handler;
+/** Reads options from environment variables (process.env, Workers env, import.meta.env…). */
+declare function optionsFromEnv(env: Record<string, string | undefined>, overrides?: Partial<DeweeHandlerOptions>): DeweeHandlerOptions;
+
+type FetchHandler = (request: Request) => Promise<Response>;
+/** Wraps a fetch-style handler for `http.createServer`, Express (`app.all("/api/dewee/*", ...)`), etc. */
+declare function toNodeHandler(handler: FetchHandler): (req: IncomingMessage & {
+    body?: unknown;
+    originalUrl?: string;
+}, res: ServerResponse) => Promise<void>;
+
+interface GatewayCredentials {
+    /** Gateway runtime origin, e.g. https://gateway.example.com */
+    url: string;
+    /** Gateway token or operator API key. Never sent to browsers. */
+    token: string;
+    /** Optional tenant id/slug for multi-tenant gateways. */
+    tenantId?: string;
+}
+declare class GatewayError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/** One authenticated gateway connection. Short-lived: one per chat turn or lookup. */
+declare class GatewayConnection {
+    private ws;
+    private seq;
+    private pending;
+    private listeners;
+    private closed;
+    private constructor();
+    static connect(creds: GatewayCredentials, userId: string, timeoutMs?: number): Promise<GatewayConnection>;
+    call<T = any>(method: string, params: unknown, timeoutMs?: number): Promise<T>;
+    onEvent(cb: (event: string, payload: any) => void): () => void;
+    close(): void;
+    private onMessage;
+    private fail;
+}
+declare function buildSessionKey(agent: string, conversationId: string): string;
+interface StreamChatOptions {
+    creds: GatewayCredentials;
+    userId: string;
+    agent: string;
+    sessionKey: string;
+    message: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Runs one chat turn and yields normalized stream events until the run ends. */
+declare function streamChat(opts: StreamChatOptions): AsyncGenerator<ChatStreamEvent>;
+/** Fetches a session transcript and folds tool calls/results into assistant turns. */
+declare function fetchHistory(creds: GatewayCredentials, userId: string, agent: string, sessionKey: string): Promise<HistoryMessage[]>;
+declare function foldHistory(raw: any[]): HistoryMessage[];
+/** Lists agents via the gateway REST API. */
+declare function listAgents(creds: GatewayCredentials): Promise<AgentInfo[]>;
+
+export { AgentInfo, ChatStreamEvent, type DeweeHandlerOptions, GatewayConnection, type GatewayCredentials, GatewayError, HistoryMessage, type RateLimiter, type StreamChatOptions, buildSessionKey, createDeweeHandler, fetchHistory, foldHistory, listAgents, memoryRateLimiter, optionsFromEnv, signVisitorToken, streamChat, toNodeHandler, verifyVisitorToken };