@copilotkitnext/runtime 0.0.1

package/src/endpoint.ts

@@ -0,0 +1,150 @@
+import { Hono } from "hono";
+import { CopilotRuntime } from "./runtime";
+import { handleRunAgent } from "./handlers/handle-run";
+import { handleGetRuntimeInfo } from "./handlers/get-runtime-info";
+import { handleTranscribe } from "./handlers/handle-transcribe";
+import { logger } from "@copilotkitnext/shared";
+import {
+  callBeforeRequestMiddleware,
+  callAfterRequestMiddleware,
+} from "./middleware";
+import { handleConnectAgent } from "./handlers/handle-connect";
+
+interface CopilotEndpointParams {
+  runtime: CopilotRuntime;
+  basePath: string;
+}
+
+// Define the context variables type
+type CopilotEndpointContext = {
+  Variables: {
+    modifiedRequest?: Request;
+  };
+};
+
+export function createCopilotEndpoint({
+  runtime,
+  basePath,
+}: CopilotEndpointParams) {
+  const app = new Hono<CopilotEndpointContext>();
+
+  return app
+    .basePath(basePath)
+    .use("*", async (c, next) => {
+      const request = c.req.raw;
+      const path = c.req.path;
+
+      try {
+        const maybeModifiedRequest = await callBeforeRequestMiddleware({
+          runtime,
+          request,
+          path,
+        });
+        if (maybeModifiedRequest) {
+          c.set("modifiedRequest", maybeModifiedRequest);
+        }
+      } catch (error) {
+        logger.error(
+          { err: error, url: request.url, path },
+          "Error running before request middleware"
+        );
+        if (error instanceof Response) {
+          return error;
+        }
+        throw error;
+      }
+
+      await next();
+    })
+    .use("*", async (c, next) => {
+      await next();
+
+      const response = c.res;
+      const path = c.req.path;
+
+      // Non-blocking after middleware
+      callAfterRequestMiddleware({
+        runtime,
+        response,
+        path,
+      }).catch((error) => {
+        logger.error(
+          { err: error, url: c.req.url, path },
+          "Error running after request middleware"
+        );
+      });
+    })
+    .post("/agent/:agentId/run", async (c) => {
+      const agentId = c.req.param("agentId");
+      const request = c.get("modifiedRequest") || c.req.raw;
+
+      try {
+        return await handleRunAgent({
+          runtime,
+          request,
+          agentId,
+        });
+      } catch (error) {
+        logger.error(
+          { err: error, url: request.url, path: c.req.path },
+          "Error running request handler"
+        );
+        throw error;
+      }
+    })
+    .post("/agent/:agentId/connect", async (c) => {
+      const agentId = c.req.param("agentId");
+      const request = c.get("modifiedRequest") || c.req.raw;
+
+      try {
+        return await handleConnectAgent({
+          runtime,
+          request,
+          agentId,
+        });
+      } catch (error) {
+        logger.error(
+          { err: error, url: request.url, path: c.req.path },
+          "Error running request handler"
+        );
+        throw error;
+      }
+    })
+    .get("/info", async (c) => {
+      const request = c.get("modifiedRequest") || c.req.raw;
+
+      try {
+        return await handleGetRuntimeInfo({
+          runtime,
+          request,
+        });
+      } catch (error) {
+        logger.error(
+          { err: error, url: request.url, path: c.req.path },
+          "Error running request handler"
+        );
+        throw error;
+      }
+    })
+    .post("/transcribe", async (c) => {
+      const request = c.get("modifiedRequest") || c.req.raw;
+
+      try {
+        return await handleTranscribe({
+          runtime,
+          request,
+        });
+      } catch (error) {
+        logger.error(
+          { err: error, url: request.url, path: c.req.path },
+          "Error running request handler"
+        );
+        throw error;
+      }
+    })
+    .notFound((c) => {
+      return c.json({ error: "Not found" }, 404);
+    });
+
+  // return app;
+}

package/src/handler.ts

@@ -0,0 +1,3 @@
+export type CopilotKitRequestHandler = (params: {
+  request: Request;
+}) => Promise<Response>;

package/src/handlers/get-runtime-info.ts

@@ -0,0 +1,50 @@
+import { CopilotRuntime } from "../runtime";
+import { AgentDescription, RuntimeInfo } from "@copilotkitnext/shared";
+import { VERSION } from "../runtime";
+
+interface HandleGetRuntimeInfoParameters {
+  runtime: CopilotRuntime;
+  request: Request;
+}
+
+export async function handleGetRuntimeInfo({
+  runtime,
+}: HandleGetRuntimeInfoParameters) {
+  try {
+    const agents = await runtime.agents;
+
+    const agentsDict = Object.entries(agents).reduce(
+      (acc, [name, agent]) => {
+        acc[name] = {
+          name,
+          description: agent.description,
+          className: agent.constructor.name,
+        };
+        return acc;
+      },
+      {} as Record<string, AgentDescription>
+    );
+
+    const runtimeInfo: RuntimeInfo = {
+      version: VERSION,
+      agents: agentsDict,
+      audioFileTranscriptionEnabled: !!runtime.transcriptionService,
+    };
+
+    return new Response(JSON.stringify(runtimeInfo), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    return new Response(
+      JSON.stringify({
+        error: "Failed to retrieve runtime information",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+}

package/src/handlers/handle-connect.ts

@@ -0,0 +1,144 @@
+import { RunAgentInput, RunAgentInputSchema } from "@ag-ui/client";
+import { EventEncoder } from "@ag-ui/encoder";
+import { CopilotRuntime } from "../runtime";
+
+interface ConnectAgentParameters {
+  request: Request;
+  runtime: CopilotRuntime;
+  agentId: string;
+}
+
+export async function handleConnectAgent({
+  runtime,
+  request,
+  agentId,
+}: ConnectAgentParameters) {
+  try {
+    const agents = await runtime.agents;
+
+    // Check if the requested agent exists
+    if (!agents[agentId]) {
+      return new Response(
+        JSON.stringify({
+          error: "Agent not found",
+          message: `Agent '${agentId}' does not exist`,
+        }),
+        {
+          status: 404,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    const stream = new TransformStream();
+    const writer = stream.writable.getWriter();
+    const encoder = new EventEncoder();
+    let streamClosed = false;
+
+    // Process the request in the background
+    (async () => {
+      let input: RunAgentInput;
+      try {
+        const requestBody = await request.json();
+        input = RunAgentInputSchema.parse(requestBody);
+      } catch {
+        return new Response(
+          JSON.stringify({
+            error: "Invalid request body",
+          }),
+          { status: 400 }
+        );
+      }
+
+      runtime.runner
+        .connect({
+          threadId: input.threadId,
+        })
+        .subscribe({
+          next: async (event) => {
+            if (!request.signal.aborted && !streamClosed) {
+              try {
+                await writer.write(encoder.encode(event));
+              } catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                  streamClosed = true;
+                }
+              }
+            }
+          },
+          error: async (error) => {
+            console.error("Error running agent:", error);
+            if (!streamClosed) {
+              try {
+                await writer.close();
+                streamClosed = true;
+              } catch {
+                // Stream already closed
+              }
+            }
+          },
+          complete: async () => {
+            if (!streamClosed) {
+              try {
+                await writer.close();
+                streamClosed = true;
+              } catch {
+                // Stream already closed
+              }
+            }
+          },
+        });
+    })().catch((error) => {
+      console.error("Error running agent:", error);
+      console.error(
+        "Error stack:",
+        error instanceof Error ? error.stack : "No stack trace"
+      );
+      console.error("Error details:", {
+        name: error instanceof Error ? error.name : "Unknown",
+        message: error instanceof Error ? error.message : String(error),
+        cause: error instanceof Error ? error.cause : undefined,
+      });
+      if (!streamClosed) {
+        try {
+          writer.close();
+          streamClosed = true;
+        } catch {
+          // Stream already closed
+        }
+      }
+    });
+
+    // Return the SSE response
+    return new Response(stream.readable, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error) {
+    console.error("Error running agent:", error);
+    console.error(
+      "Error stack:",
+      error instanceof Error ? error.stack : "No stack trace"
+    );
+    console.error("Error details:", {
+      name: error instanceof Error ? error.name : "Unknown",
+      message: error instanceof Error ? error.message : String(error),
+      cause: error instanceof Error ? error.cause : undefined,
+    });
+
+    return new Response(
+      JSON.stringify({
+        error: "Failed to run agent",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+}

package/src/handlers/handle-run.ts

@@ -0,0 +1,156 @@
+import {
+  AbstractAgent,
+  RunAgentInput,
+  RunAgentInputSchema,
+} from "@ag-ui/client";
+import { EventEncoder } from "@ag-ui/encoder";
+import { CopilotRuntime } from "../runtime";
+
+interface RunAgentParameters {
+  request: Request;
+  runtime: CopilotRuntime;
+  agentId: string;
+}
+
+export async function handleRunAgent({
+  runtime,
+  request,
+  agentId,
+}: RunAgentParameters) {
+  try {
+    const agents = await runtime.agents;
+
+    // Check if the requested agent exists
+    if (!agents[agentId]) {
+      return new Response(
+        JSON.stringify({
+          error: "Agent not found",
+          message: `Agent '${agentId}' does not exist`,
+        }),
+        {
+          status: 404,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    const agent = agents[agentId].clone() as AbstractAgent;
+
+    const stream = new TransformStream();
+    const writer = stream.writable.getWriter();
+    const encoder = new EventEncoder();
+    let streamClosed = false;
+
+    // Process the request in the background
+    (async () => {
+      let input: RunAgentInput;
+      try {
+        const requestBody = await request.json();
+        input = RunAgentInputSchema.parse(requestBody);
+      } catch {
+        return new Response(
+          JSON.stringify({
+            error: "Invalid request body",
+          }),
+          { status: 400 }
+        );
+      }
+
+      agent.setMessages(input.messages);
+      agent.setState(input.state);
+      agent.threadId = input.threadId;
+
+      runtime.runner
+        .run({
+          threadId: input.threadId,
+          agent,
+          input,
+        })
+        .subscribe({
+          next: async (event) => {
+            if (!request.signal.aborted && !streamClosed) {
+              try {
+                await writer.write(encoder.encode(event));
+              } catch (error) {
+                if (error instanceof Error && error.name === 'AbortError') {
+                  streamClosed = true;
+                }
+              }
+            }
+          },
+          error: async (error) => {
+            console.error("Error running agent:", error);
+            if (!streamClosed) {
+              try {
+                await writer.close();
+                streamClosed = true;
+              } catch {
+                // Stream already closed
+              }
+            }
+          },
+          complete: async () => {
+            if (!streamClosed) {
+              try {
+                await writer.close();
+                streamClosed = true;
+              } catch {
+                // Stream already closed
+              }
+            }
+          },
+        });
+    })().catch((error) => {
+      console.error("Error running agent:", error);
+      console.error(
+        "Error stack:",
+        error instanceof Error ? error.stack : "No stack trace"
+      );
+      console.error("Error details:", {
+        name: error instanceof Error ? error.name : "Unknown",
+        message: error instanceof Error ? error.message : String(error),
+        cause: error instanceof Error ? error.cause : undefined,
+      });
+      if (!streamClosed) {
+        try {
+          writer.close();
+          streamClosed = true;
+        } catch {
+          // Stream already closed
+        }
+      }
+    });
+
+    // Return the SSE response
+    return new Response(stream.readable, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error) {
+    console.error("Error running agent:", error);
+    console.error(
+      "Error stack:",
+      error instanceof Error ? error.stack : "No stack trace"
+    );
+    console.error("Error details:", {
+      name: error instanceof Error ? error.name : "Unknown",
+      message: error instanceof Error ? error.message : String(error),
+      cause: error instanceof Error ? error.cause : undefined,
+    });
+
+    return new Response(
+      JSON.stringify({
+        error: "Failed to run agent",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+}

package/src/handlers/handle-transcribe.ts

@@ -0,0 +1,126 @@
+import { CopilotRuntime } from "../runtime";
+
+interface HandleTranscribeParameters {
+  runtime: CopilotRuntime;
+  request: Request;
+}
+
+export async function handleTranscribe({
+  runtime,
+  request,
+}: HandleTranscribeParameters) {
+  try {
+    // Check if transcription service is configured
+    if (!runtime.transcriptionService) {
+      return new Response(
+        JSON.stringify({
+          error: "Transcription service not configured",
+          message:
+            "No transcription service has been configured in the runtime",
+        }),
+        {
+          status: 503,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    // Check if request has form data
+    const contentType = request.headers.get("content-type");
+    if (!contentType || !contentType.includes("multipart/form-data")) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid content type",
+          message:
+            "Request must contain multipart/form-data with an audio file",
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    // Extract form data
+    const formData = await request.formData();
+    const audioFile = formData.get("audio") as File | null;
+
+    if (!audioFile || !(audioFile instanceof File)) {
+      return new Response(
+        JSON.stringify({
+          error: "Missing audio file",
+          message:
+            "No audio file found in form data. Please include an 'audio' field.",
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    // Validate file type (basic check)
+    const validAudioTypes = [
+      "audio/mpeg",
+      "audio/mp3",
+      "audio/mp4",
+      "audio/wav",
+      "audio/webm",
+      "audio/ogg",
+      "audio/flac",
+      "audio/aac",
+    ];
+
+    // Allow empty types and application/octet-stream (common fallback for unknown types)
+    const isValidType =
+      validAudioTypes.includes(audioFile.type) ||
+      audioFile.type === "" ||
+      audioFile.type === "application/octet-stream";
+
+    if (!isValidType) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid file type",
+          message: `Unsupported audio file type: ${audioFile.type}. Supported types: ${validAudioTypes.join(", ")}, or files with unknown/empty types`,
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    // Transcribe the audio file with options
+    const transcription = await runtime.transcriptionService.transcribeFile({
+      audioFile,
+      mimeType: audioFile.type,
+      size: audioFile.size,
+    });
+
+    return new Response(
+      JSON.stringify({
+        text: transcription,
+        size: audioFile.size,
+        type: audioFile.type,
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  } catch (error) {
+    return new Response(
+      JSON.stringify({
+        error: "Transcription failed",
+        message:
+          error instanceof Error
+            ? error.message
+            : "Unknown error occurred during transcription",
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from "./runtime";
+export * from "./endpoint";
+
+// Export agent runners
+export { InMemoryAgentRunner } from "./runner/in-memory";
+export { SqliteAgentRunner } from "./runner/sqlite";
+export { EnterpriseAgentRunner } from "./runner/enterprise";
+export type { EnterpriseAgentRunnerOptions } from "./runner/enterprise";