@copilotkitnext/runtime 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,245 @@
+import { MaybePromise, NonEmptyRecord } from '@copilotkitnext/shared';
+import { AbstractAgent, RunAgentInput, BaseEvent } from '@ag-ui/client';
+import { Observable } from 'rxjs';
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { Kysely, Generated } from 'kysely';
+import { Redis } from 'ioredis';
+
+/**
+ * Middleware support for CopilotKit Runtime.
+ *
+ * A middleware hook can be provided as either:
+ *   1. A **callback function** executed in-process.
+ *   2. A **webhook URL** (http/https).  The runtime will `POST` a JSON payload
+ *      to the URL and, for *before* hooks, accept an optional modified
+ *      `Request` object in the response body.
+ *
+ * Two lifecycle hooks are available:
+ *   • `BEFORE_REQUEST` – runs *before* the request handler.
+ *   • `AFTER_REQUEST`  – runs *after* the handler returns a `Response`.
+ */
+
+/** A string beginning with http:// or https:// that points to a webhook endpoint. */
+type MiddlewareURL = `${"http" | "https"}://${string}`;
+interface BeforeRequestMiddlewareParameters {
+    runtime: CopilotRuntime;
+    request: Request;
+    path: string;
+}
+interface AfterRequestMiddlewareParameters {
+    runtime: CopilotRuntime;
+    response: Response;
+    path: string;
+}
+type BeforeRequestMiddlewareFn = (params: BeforeRequestMiddlewareParameters) => MaybePromise<Request | void>;
+type AfterRequestMiddlewareFn = (params: AfterRequestMiddlewareParameters) => MaybePromise<void>;
+/**
+ * A middleware value can be either a callback function or a webhook URL.
+ */
+type BeforeRequestMiddleware = BeforeRequestMiddlewareFn | MiddlewareURL;
+type AfterRequestMiddleware = AfterRequestMiddlewareFn | MiddlewareURL;
+
+interface TranscribeFileOptions {
+    audioFile: File;
+    /** MIME type of the audio file */
+    mimeType?: string;
+    /** Size of the audio file in bytes */
+    size?: number;
+}
+declare abstract class TranscriptionService {
+    abstract transcribeFile(options: TranscribeFileOptions): Promise<string>;
+}
+
+interface AgentRunnerRunRequest {
+    threadId: string;
+    agent: AbstractAgent;
+    input: RunAgentInput;
+}
+interface AgentRunnerConnectRequest {
+    threadId: string;
+}
+interface AgentRunnerIsRunningRequest {
+    threadId: string;
+}
+interface AgentRunnerStopRequest {
+    threadId: string;
+}
+declare abstract class AgentRunner {
+    abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+}
+
+declare const VERSION: string;
+/**
+ * Options used to construct a `CopilotRuntime` instance.
+ */
+interface CopilotRuntimeOptions {
+    /** Map of available agents (loaded lazily is fine). */
+    agents: MaybePromise<NonEmptyRecord<Record<string, AbstractAgent>>>;
+    /** The runner to use for running agents. */
+    runner?: AgentRunner;
+    /** Optional transcription service for audio processing. */
+    transcriptionService?: TranscriptionService;
+    /** Optional *before* middleware – callback function or webhook URL. */
+    beforeRequestMiddleware?: BeforeRequestMiddleware;
+    /** Optional *after* middleware – callback function or webhook URL. */
+    afterRequestMiddleware?: AfterRequestMiddleware;
+}
+/**
+ * Central runtime object passed to all request handlers.
+ */
+declare class CopilotRuntime {
+    agents: CopilotRuntimeOptions["agents"];
+    transcriptionService: CopilotRuntimeOptions["transcriptionService"];
+    beforeRequestMiddleware: CopilotRuntimeOptions["beforeRequestMiddleware"];
+    afterRequestMiddleware: CopilotRuntimeOptions["afterRequestMiddleware"];
+    runner: AgentRunner;
+    constructor({ agents, transcriptionService, beforeRequestMiddleware, afterRequestMiddleware, runner, }: CopilotRuntimeOptions);
+}
+
+interface CopilotEndpointParams {
+    runtime: CopilotRuntime;
+    basePath: string;
+}
+type CopilotEndpointContext = {
+    Variables: {
+        modifiedRequest?: Request;
+    };
+};
+declare function createCopilotEndpoint({ runtime, basePath, }: CopilotEndpointParams): hono_hono_base.HonoBase<CopilotEndpointContext, {
+    [x: `${string}/*`]: {};
+} & {
+    [x: `${string}/agent/:agentId/run`]: {
+        $post: {
+            input: {
+                param: {
+                    agentId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    [x: `${string}/agent/:agentId/connect`]: {
+        $post: {
+            input: {
+                param: {
+                    agentId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    [x: `${string}/info`]: {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    [x: `${string}/transcribe`]: {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+}, string>;
+
+declare class InMemoryAgentRunner extends AgentRunner {
+    private convertMessageToEvents;
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(_request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+}
+
+interface SqliteAgentRunnerOptions {
+    dbPath?: string;
+}
+declare class SqliteAgentRunner extends AgentRunner {
+    private db;
+    constructor(options?: SqliteAgentRunnerOptions);
+    private convertMessageToEvents;
+    private initializeSchema;
+    private storeRun;
+    private getHistoricRuns;
+    private getLatestRunId;
+    private setRunState;
+    private getRunState;
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(_request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+    /**
+     * Close the database connection (for cleanup)
+     */
+    close(): void;
+}
+
+interface AgentDatabase {
+    agent_runs: {
+        id: Generated<number>;
+        thread_id: string;
+        run_id: string;
+        parent_run_id: string | null;
+        events: string;
+        input: string;
+        created_at: number;
+        version: number;
+    };
+    run_state: {
+        thread_id: string;
+        is_running: number;
+        current_run_id: string | null;
+        server_id: string | null;
+        updated_at: number;
+    };
+    schema_version: {
+        version: number;
+        applied_at: number;
+    };
+}
+interface EnterpriseAgentRunnerOptions {
+    kysely: Kysely<AgentDatabase>;
+    redis: Redis;
+    redisSub?: Redis;
+    streamRetentionMs?: number;
+    streamActiveTTLMs?: number;
+    lockTTLMs?: number;
+    serverId?: string;
+}
+declare class EnterpriseAgentRunner extends AgentRunner {
+    private db;
+    redis: Redis;
+    redisSub: Redis;
+    private serverId;
+    private streamRetentionMs;
+    private streamActiveTTLMs;
+    private lockTTLMs;
+    constructor(options: EnterpriseAgentRunnerOptions);
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(request: AgentRunnerStopRequest): Promise<boolean>;
+    private convertMessageToEvents;
+    private initializeSchema;
+    private storeRun;
+    private getHistoricRuns;
+    private setRunState;
+    close(): Promise<void>;
+    private generateServerId;
+}
+
+export { CopilotRuntime, type CopilotRuntimeOptions, EnterpriseAgentRunner, type EnterpriseAgentRunnerOptions, InMemoryAgentRunner, SqliteAgentRunner, VERSION, createCopilotEndpoint };

package/dist/index.d.ts

@@ -0,0 +1,245 @@
+import { MaybePromise, NonEmptyRecord } from '@copilotkitnext/shared';
+import { AbstractAgent, RunAgentInput, BaseEvent } from '@ag-ui/client';
+import { Observable } from 'rxjs';
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { Kysely, Generated } from 'kysely';
+import { Redis } from 'ioredis';
+
+/**
+ * Middleware support for CopilotKit Runtime.
+ *
+ * A middleware hook can be provided as either:
+ *   1. A **callback function** executed in-process.
+ *   2. A **webhook URL** (http/https).  The runtime will `POST` a JSON payload
+ *      to the URL and, for *before* hooks, accept an optional modified
+ *      `Request` object in the response body.
+ *
+ * Two lifecycle hooks are available:
+ *   • `BEFORE_REQUEST` – runs *before* the request handler.
+ *   • `AFTER_REQUEST`  – runs *after* the handler returns a `Response`.
+ */
+
+/** A string beginning with http:// or https:// that points to a webhook endpoint. */
+type MiddlewareURL = `${"http" | "https"}://${string}`;
+interface BeforeRequestMiddlewareParameters {
+    runtime: CopilotRuntime;
+    request: Request;
+    path: string;
+}
+interface AfterRequestMiddlewareParameters {
+    runtime: CopilotRuntime;
+    response: Response;
+    path: string;
+}
+type BeforeRequestMiddlewareFn = (params: BeforeRequestMiddlewareParameters) => MaybePromise<Request | void>;
+type AfterRequestMiddlewareFn = (params: AfterRequestMiddlewareParameters) => MaybePromise<void>;
+/**
+ * A middleware value can be either a callback function or a webhook URL.
+ */
+type BeforeRequestMiddleware = BeforeRequestMiddlewareFn | MiddlewareURL;
+type AfterRequestMiddleware = AfterRequestMiddlewareFn | MiddlewareURL;
+
+interface TranscribeFileOptions {
+    audioFile: File;
+    /** MIME type of the audio file */
+    mimeType?: string;
+    /** Size of the audio file in bytes */
+    size?: number;
+}
+declare abstract class TranscriptionService {
+    abstract transcribeFile(options: TranscribeFileOptions): Promise<string>;
+}
+
+interface AgentRunnerRunRequest {
+    threadId: string;
+    agent: AbstractAgent;
+    input: RunAgentInput;
+}
+interface AgentRunnerConnectRequest {
+    threadId: string;
+}
+interface AgentRunnerIsRunningRequest {
+    threadId: string;
+}
+interface AgentRunnerStopRequest {
+    threadId: string;
+}
+declare abstract class AgentRunner {
+    abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+}
+
+declare const VERSION: string;
+/**
+ * Options used to construct a `CopilotRuntime` instance.
+ */
+interface CopilotRuntimeOptions {
+    /** Map of available agents (loaded lazily is fine). */
+    agents: MaybePromise<NonEmptyRecord<Record<string, AbstractAgent>>>;
+    /** The runner to use for running agents. */
+    runner?: AgentRunner;
+    /** Optional transcription service for audio processing. */
+    transcriptionService?: TranscriptionService;
+    /** Optional *before* middleware – callback function or webhook URL. */
+    beforeRequestMiddleware?: BeforeRequestMiddleware;
+    /** Optional *after* middleware – callback function or webhook URL. */
+    afterRequestMiddleware?: AfterRequestMiddleware;
+}
+/**
+ * Central runtime object passed to all request handlers.
+ */
+declare class CopilotRuntime {
+    agents: CopilotRuntimeOptions["agents"];
+    transcriptionService: CopilotRuntimeOptions["transcriptionService"];
+    beforeRequestMiddleware: CopilotRuntimeOptions["beforeRequestMiddleware"];
+    afterRequestMiddleware: CopilotRuntimeOptions["afterRequestMiddleware"];
+    runner: AgentRunner;
+    constructor({ agents, transcriptionService, beforeRequestMiddleware, afterRequestMiddleware, runner, }: CopilotRuntimeOptions);
+}
+
+interface CopilotEndpointParams {
+    runtime: CopilotRuntime;
+    basePath: string;
+}
+type CopilotEndpointContext = {
+    Variables: {
+        modifiedRequest?: Request;
+    };
+};
+declare function createCopilotEndpoint({ runtime, basePath, }: CopilotEndpointParams): hono_hono_base.HonoBase<CopilotEndpointContext, {
+    [x: `${string}/*`]: {};
+} & {
+    [x: `${string}/agent/:agentId/run`]: {
+        $post: {
+            input: {
+                param: {
+                    agentId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    [x: `${string}/agent/:agentId/connect`]: {
+        $post: {
+            input: {
+                param: {
+                    agentId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    [x: `${string}/info`]: {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+} & {
+    [x: `${string}/transcribe`]: {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: hono_utils_http_status.StatusCode;
+        };
+    };
+}, string>;
+
+declare class InMemoryAgentRunner extends AgentRunner {
+    private convertMessageToEvents;
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(_request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+}
+
+interface SqliteAgentRunnerOptions {
+    dbPath?: string;
+}
+declare class SqliteAgentRunner extends AgentRunner {
+    private db;
+    constructor(options?: SqliteAgentRunnerOptions);
+    private convertMessageToEvents;
+    private initializeSchema;
+    private storeRun;
+    private getHistoricRuns;
+    private getLatestRunId;
+    private setRunState;
+    private getRunState;
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(_request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+    /**
+     * Close the database connection (for cleanup)
+     */
+    close(): void;
+}
+
+interface AgentDatabase {
+    agent_runs: {
+        id: Generated<number>;
+        thread_id: string;
+        run_id: string;
+        parent_run_id: string | null;
+        events: string;
+        input: string;
+        created_at: number;
+        version: number;
+    };
+    run_state: {
+        thread_id: string;
+        is_running: number;
+        current_run_id: string | null;
+        server_id: string | null;
+        updated_at: number;
+    };
+    schema_version: {
+        version: number;
+        applied_at: number;
+    };
+}
+interface EnterpriseAgentRunnerOptions {
+    kysely: Kysely<AgentDatabase>;
+    redis: Redis;
+    redisSub?: Redis;
+    streamRetentionMs?: number;
+    streamActiveTTLMs?: number;
+    lockTTLMs?: number;
+    serverId?: string;
+}
+declare class EnterpriseAgentRunner extends AgentRunner {
+    private db;
+    redis: Redis;
+    redisSub: Redis;
+    private serverId;
+    private streamRetentionMs;
+    private streamActiveTTLMs;
+    private lockTTLMs;
+    constructor(options: EnterpriseAgentRunnerOptions);
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(request: AgentRunnerStopRequest): Promise<boolean>;
+    private convertMessageToEvents;
+    private initializeSchema;
+    private storeRun;
+    private getHistoricRuns;
+    private setRunState;
+    close(): Promise<void>;
+    private generateServerId;
+}
+
+export { CopilotRuntime, type CopilotRuntimeOptions, EnterpriseAgentRunner, type EnterpriseAgentRunnerOptions, InMemoryAgentRunner, SqliteAgentRunner, VERSION, createCopilotEndpoint };