@copilotkitnext/runtime 0.0.19 → 0.0.21-alpha.0

package/dist/index.mjs

@@ -1,836 +1,24 @@
-// package.json
-var package_default = {
-  name: "@copilotkitnext/runtime",
-  version: "0.0.19",
-  description: "Server-side runtime package for CopilotKit2",
-  main: "dist/index.js",
-  types: "dist/index.d.ts",
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.mjs",
-      require: "./dist/index.js"
-    }
-  },
-  publishConfig: {
-    access: "public"
-  },
-  scripts: {
-    build: "tsup",
-    prepublishOnly: "pnpm run build",
-    dev: "tsup --watch",
-    lint: "eslint . --max-warnings 0",
-    "check-types": "tsc --noEmit",
-    clean: "rm -rf dist",
-    test: "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
-  },
-  devDependencies: {
-    "@copilotkitnext/eslint-config": "workspace:*",
-    "@copilotkitnext/typescript-config": "workspace:*",
-    "@types/node": "^22.15.3",
-    eslint: "^9.30.0",
-    openai: "^5.9.0",
-    tsup: "^8.5.0",
-    typescript: "5.8.2",
-    vitest: "^3.0.5"
-  },
-  dependencies: {
-    "@ag-ui/client": "0.0.40-alpha.6",
-    "@ag-ui/core": "0.0.40-alpha.6",
-    "@ag-ui/encoder": "0.0.40-alpha.6",
-    "@copilotkitnext/shared": "workspace:*",
-    hono: "^4.6.13",
-    rxjs: "7.8.1"
-  },
-  peerDependencies: {
-    openai: "^5.9.0"
-  },
-  peerDependenciesMeta: {},
-  engines: {
-    node: ">=18"
-  }
-};
-
-// src/runner/agent-runner.ts
-var AgentRunner = class {
-};
-
-// src/runner/in-memory.ts
-import { ReplaySubject } from "rxjs";
 import {
-  EventType,
-  compactEvents
-} from "@ag-ui/client";
-import { finalizeRunEvents } from "@copilotkitnext/shared";
-var InMemoryEventStore = class {
-  constructor(threadId) {
-    this.threadId = threadId;
-  }
-  /** The subject that current consumers subscribe to. */
-  subject = null;
-  /** True while a run is actively producing events. */
-  isRunning = false;
-  /** Current run ID */
-  currentRunId = null;
-  /** Historic completed runs */
-  historicRuns = [];
-  /** Currently running agent instance (if any). */
-  agent = null;
-  /** Subject returned from run() while the run is active. */
-  runSubject = null;
-  /** True once stop() has been requested but the run has not yet finalized. */
-  stopRequested = false;
-  /** Reference to the events emitted in the current run. */
-  currentEvents = null;
-};
-var GLOBAL_STORE = /* @__PURE__ */ new Map();
-var InMemoryAgentRunner = class extends AgentRunner {
-  run(request) {
-    let existingStore = GLOBAL_STORE.get(request.threadId);
-    if (!existingStore) {
-      existingStore = new InMemoryEventStore(request.threadId);
-      GLOBAL_STORE.set(request.threadId, existingStore);
-    }
-    const store = existingStore;
-    if (store.isRunning) {
-      throw new Error("Thread already running");
-    }
-    store.isRunning = true;
-    store.currentRunId = request.input.runId;
-    store.agent = request.agent;
-    store.stopRequested = false;
-    const seenMessageIds = /* @__PURE__ */ new Set();
-    const currentRunEvents = [];
-    store.currentEvents = currentRunEvents;
-    const historicMessageIds = /* @__PURE__ */ new Set();
-    for (const run of store.historicRuns) {
-      for (const event of run.events) {
-        if ("messageId" in event && typeof event.messageId === "string") {
-          historicMessageIds.add(event.messageId);
-        }
-        if (event.type === EventType.RUN_STARTED) {
-          const runStarted = event;
-          const messages = runStarted.input?.messages ?? [];
-          for (const message of messages) {
-            historicMessageIds.add(message.id);
-          }
-        }
-      }
-    }
-    const nextSubject = new ReplaySubject(Infinity);
-    const prevSubject = store.subject;
-    store.subject = nextSubject;
-    const runSubject = new ReplaySubject(Infinity);
-    store.runSubject = runSubject;
-    const runAgent = async () => {
-      const lastRun = store.historicRuns[store.historicRuns.length - 1];
-      const parentRunId = lastRun?.runId ?? null;
-      try {
-        await request.agent.runAgent(request.input, {
-          onEvent: ({ event }) => {
-            let processedEvent = event;
-            if (event.type === EventType.RUN_STARTED) {
-              const runStartedEvent = event;
-              if (!runStartedEvent.input) {
-                const sanitizedMessages = request.input.messages ? request.input.messages.filter(
-                  (message) => !historicMessageIds.has(message.id)
-                ) : void 0;
-                const updatedInput = {
-                  ...request.input,
-                  ...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
-                };
-                processedEvent = {
-                  ...runStartedEvent,
-                  input: updatedInput
-                };
-              }
-            }
-            runSubject.next(processedEvent);
-            nextSubject.next(processedEvent);
-            currentRunEvents.push(processedEvent);
-          },
-          onNewMessage: ({ message }) => {
-            if (!seenMessageIds.has(message.id)) {
-              seenMessageIds.add(message.id);
-            }
-          },
-          onRunStartedEvent: () => {
-            if (request.input.messages) {
-              for (const message of request.input.messages) {
-                if (!seenMessageIds.has(message.id)) {
-                  seenMessageIds.add(message.id);
-                }
-              }
-            }
-          }
-        });
-        const appendedEvents = finalizeRunEvents(currentRunEvents, {
-          stopRequested: store.stopRequested
-        });
-        for (const event of appendedEvents) {
-          runSubject.next(event);
-          nextSubject.next(event);
-        }
-        if (store.currentRunId) {
-          const compactedEvents = compactEvents(currentRunEvents);
-          store.historicRuns.push({
-            threadId: request.threadId,
-            runId: store.currentRunId,
-            parentRunId,
-            events: compactedEvents,
-            createdAt: Date.now()
-          });
-        }
-        store.currentEvents = null;
-        store.currentRunId = null;
-        store.agent = null;
-        store.runSubject = null;
-        store.stopRequested = false;
-        store.isRunning = false;
-        runSubject.complete();
-        nextSubject.complete();
-      } catch {
-        const appendedEvents = finalizeRunEvents(currentRunEvents, {
-          stopRequested: store.stopRequested
-        });
-        for (const event of appendedEvents) {
-          runSubject.next(event);
-          nextSubject.next(event);
-        }
-        if (store.currentRunId && currentRunEvents.length > 0) {
-          const compactedEvents = compactEvents(currentRunEvents);
-          store.historicRuns.push({
-            threadId: request.threadId,
-            runId: store.currentRunId,
-            parentRunId,
-            events: compactedEvents,
-            createdAt: Date.now()
-          });
-        }
-        store.currentEvents = null;
-        store.currentRunId = null;
-        store.agent = null;
-        store.runSubject = null;
-        store.stopRequested = false;
-        store.isRunning = false;
-        runSubject.complete();
-        nextSubject.complete();
-      }
-    };
-    if (prevSubject) {
-      prevSubject.subscribe({
-        next: (e) => nextSubject.next(e),
-        error: (err) => nextSubject.error(err),
-        complete: () => {
-        }
-      });
-    }
-    runAgent();
-    return runSubject.asObservable();
-  }
-  connect(request) {
-    const store = GLOBAL_STORE.get(request.threadId);
-    const connectionSubject = new ReplaySubject(Infinity);
-    if (!store) {
-      connectionSubject.complete();
-      return connectionSubject.asObservable();
-    }
-    const allHistoricEvents = [];
-    for (const run of store.historicRuns) {
-      allHistoricEvents.push(...run.events);
-    }
-    const compactedEvents = compactEvents(allHistoricEvents);
-    const emittedMessageIds = /* @__PURE__ */ new Set();
-    for (const event of compactedEvents) {
-      connectionSubject.next(event);
-      if ("messageId" in event && typeof event.messageId === "string") {
-        emittedMessageIds.add(event.messageId);
-      }
-    }
-    if (store.subject && (store.isRunning || store.stopRequested)) {
-      store.subject.subscribe({
-        next: (event) => {
-          if ("messageId" in event && typeof event.messageId === "string" && emittedMessageIds.has(event.messageId)) {
-            return;
-          }
-          connectionSubject.next(event);
-        },
-        complete: () => connectionSubject.complete(),
-        error: (err) => connectionSubject.error(err)
-      });
-    } else {
-      connectionSubject.complete();
-    }
-    return connectionSubject.asObservable();
-  }
-  isRunning(request) {
-    const store = GLOBAL_STORE.get(request.threadId);
-    return Promise.resolve(store?.isRunning ?? false);
-  }
-  stop(request) {
-    const store = GLOBAL_STORE.get(request.threadId);
-    if (!store || !store.isRunning) {
-      return Promise.resolve(false);
-    }
-    if (store.stopRequested) {
-      return Promise.resolve(false);
-    }
-    store.stopRequested = true;
-    store.isRunning = false;
-    const agent = store.agent;
-    if (!agent) {
-      store.stopRequested = false;
-      store.isRunning = false;
-      return Promise.resolve(false);
-    }
-    try {
-      agent.abortRun();
-      return Promise.resolve(true);
-    } catch (error) {
-      console.error("Failed to abort agent run", error);
-      store.stopRequested = false;
-      store.isRunning = true;
-      return Promise.resolve(false);
-    }
-  }
-};
-
-// src/runtime.ts
-var VERSION = package_default.version;
-var CopilotRuntime = class {
-  agents;
-  transcriptionService;
-  beforeRequestMiddleware;
-  afterRequestMiddleware;
-  runner;
-  constructor({
-    agents,
-    transcriptionService,
-    beforeRequestMiddleware,
-    afterRequestMiddleware,
-    runner
-  }) {
-    this.agents = agents;
-    this.transcriptionService = transcriptionService;
-    this.beforeRequestMiddleware = beforeRequestMiddleware;
-    this.afterRequestMiddleware = afterRequestMiddleware;
-    this.runner = runner ?? new InMemoryAgentRunner();
-  }
-};
+  AgentRunner,
+  CopilotRuntime,
+  InMemoryAgentRunner,
+  VERSION,
+  callAfterRequestMiddleware,
+  callBeforeRequestMiddleware,
+  createJsonRequest,
+  expectString,
+  handleConnectAgent,
+  handleGetRuntimeInfo,
+  handleRunAgent,
+  handleStopAgent,
+  handleTranscribe,
+  parseMethodCall
+} from "./chunk-PBMAFLPB.mjs";
 
-// src/endpoint.ts
+// src/endpoints/hono.ts
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-
-// src/handlers/handle-run.ts
-import {
-  RunAgentInputSchema
-} from "@ag-ui/client";
-import { EventEncoder } from "@ag-ui/encoder";
-async function handleRunAgent({
-  runtime,
-  request,
-  agentId
-}) {
-  try {
-    const agents = await runtime.agents;
-    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 registeredAgent = agents[agentId];
-    const agent = registeredAgent.clone();
-    if (agent && "headers" in agent) {
-      const shouldForward = (headerName) => {
-        const lower = headerName.toLowerCase();
-        return lower === "authorization" || lower.startsWith("x-");
-      };
-      const forwardableHeaders = {};
-      request.headers.forEach((value, key) => {
-        if (shouldForward(key)) {
-          forwardableHeaders[key] = value;
-        }
-      });
-      agent.headers = {
-        ...agent.headers,
-        ...forwardableHeaders
-      };
-    }
-    const stream = new TransformStream();
-    const writer = stream.writable.getWriter();
-    const encoder = new EventEncoder();
-    let streamClosed = false;
-    (async () => {
-      let input;
-      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 {
-            }
-          }
-        },
-        complete: async () => {
-          if (!streamClosed) {
-            try {
-              await writer.close();
-              streamClosed = true;
-            } catch {
-            }
-          }
-        }
-      });
-    })().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 : void 0
-      });
-      if (!streamClosed) {
-        try {
-          writer.close();
-          streamClosed = true;
-        } catch {
-        }
-      }
-    });
-    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 : void 0
-    });
-    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" }
-      }
-    );
-  }
-}
-
-// src/handlers/get-runtime-info.ts
-async function handleGetRuntimeInfo({
-  runtime
-}) {
-  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;
-      },
-      {}
-    );
-    const 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" }
-      }
-    );
-  }
-}
-
-// src/handlers/handle-transcribe.ts
-async function handleTranscribe({
-  runtime,
-  request
-}) {
-  try {
-    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" }
-        }
-      );
-    }
-    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" }
-        }
-      );
-    }
-    const formData = await request.formData();
-    const audioFile = formData.get("audio");
-    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" }
-        }
-      );
-    }
-    const validAudioTypes = [
-      "audio/mpeg",
-      "audio/mp3",
-      "audio/mp4",
-      "audio/wav",
-      "audio/webm",
-      "audio/ogg",
-      "audio/flac",
-      "audio/aac"
-    ];
-    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" }
-        }
-      );
-    }
-    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" }
-      }
-    );
-  }
-}
-
-// src/endpoint.ts
-import { logger as logger2 } from "@copilotkitnext/shared";
-
-// src/middleware.ts
 import { logger } from "@copilotkitnext/shared";
-async function callBeforeRequestMiddleware({
-  runtime,
-  request,
-  path
-}) {
-  const mw = runtime.beforeRequestMiddleware;
-  if (!mw) return;
-  if (typeof mw === "function") {
-    return mw({ runtime, request, path });
-  }
-  logger.warn({ mw }, "Unsupported beforeRequestMiddleware value \u2013 skipped");
-  return;
-}
-async function callAfterRequestMiddleware({
-  runtime,
-  response,
-  path
-}) {
-  const mw = runtime.afterRequestMiddleware;
-  if (!mw) return;
-  if (typeof mw === "function") {
-    return mw({ runtime, response, path });
-  }
-  logger.warn({ mw }, "Unsupported afterRequestMiddleware value \u2013 skipped");
-}
-
-// src/handlers/handle-connect.ts
-import { RunAgentInputSchema as RunAgentInputSchema2 } from "@ag-ui/client";
-import { EventEncoder as EventEncoder2 } from "@ag-ui/encoder";
-async function handleConnectAgent({
-  runtime,
-  request,
-  agentId
-}) {
-  try {
-    const agents = await runtime.agents;
-    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 EventEncoder2();
-    let streamClosed = false;
-    (async () => {
-      let input;
-      try {
-        const requestBody = await request.json();
-        input = RunAgentInputSchema2.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 {
-            }
-          }
-        },
-        complete: async () => {
-          if (!streamClosed) {
-            try {
-              await writer.close();
-              streamClosed = true;
-            } catch {
-            }
-          }
-        }
-      });
-    })().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 : void 0
-      });
-      if (!streamClosed) {
-        try {
-          writer.close();
-          streamClosed = true;
-        } catch {
-        }
-      }
-    });
-    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 : void 0
-    });
-    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" }
-      }
-    );
-  }
-}
-
-// src/handlers/handle-stop.ts
-import { EventType as EventType2 } from "@ag-ui/client";
-async function handleStopAgent({
-  runtime,
-  request,
-  agentId,
-  threadId
-}) {
-  try {
-    const agents = await runtime.agents;
-    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 stopped = await runtime.runner.stop({ threadId });
-    if (!stopped) {
-      return new Response(
-        JSON.stringify({
-          stopped: false,
-          message: `No active run for thread '${threadId}'.`
-        }),
-        {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        }
-      );
-    }
-    return new Response(
-      JSON.stringify({
-        stopped: true,
-        interrupt: {
-          type: EventType2.RUN_ERROR,
-          message: "Run stopped by user",
-          code: "STOPPED"
-        }
-      }),
-      {
-        status: 200,
-        headers: { "Content-Type": "application/json" }
-      }
-    );
-  } catch (error) {
-    console.error("Error stopping agent run:", error);
-    return new Response(
-      JSON.stringify({
-        error: "Failed to stop agent",
-        message: error instanceof Error ? error.message : "Unknown error"
-      }),
-      {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      }
-    );
-  }
-}
-
-// src/endpoint.ts
 function createCopilotEndpoint({ runtime, basePath }) {
   const app = new Hono();
   return app.basePath(basePath).use(
@@ -853,7 +41,7 @@ function createCopilotEndpoint({ runtime, basePath }) {
         c.set("modifiedRequest", maybeModifiedRequest);
       }
     } catch (error) {
-      logger2.error({ err: error, url: request.url, path }, "Error running before request middleware");
+      logger.error({ err: error, url: request.url, path }, "Error running before request middleware");
       if (error instanceof Response) {
         return error;
       }
@@ -869,7 +57,7 @@ function createCopilotEndpoint({ runtime, basePath }) {
       response,
       path
     }).catch((error) => {
-      logger2.error({ err: error, url: c.req.url, path }, "Error running after request middleware");
+      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");
@@ -881,7 +69,7 @@ function createCopilotEndpoint({ runtime, basePath }) {
         agentId
       });
     } catch (error) {
-      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
+      logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/agent/:agentId/connect", async (c) => {
@@ -894,7 +82,7 @@ function createCopilotEndpoint({ runtime, basePath }) {
         agentId
       });
     } catch (error) {
-      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
+      logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/agent/:agentId/stop/:threadId", async (c) => {
@@ -909,7 +97,7 @@ function createCopilotEndpoint({ runtime, basePath }) {
         threadId
       });
     } catch (error) {
-      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
+      logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).get("/info", async (c) => {
@@ -920,7 +108,7 @@ function createCopilotEndpoint({ runtime, basePath }) {
         request
       });
     } catch (error) {
-      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
+      logger.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
       throw error;
     }
   }).post("/transcribe", async (c) => {
@@ -931,22 +119,139 @@ function createCopilotEndpoint({ runtime, basePath }) {
         request
       });
     } catch (error) {
-      logger2.error({ err: error, url: request.url, path: c.req.path }, "Error running request handler");
+      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);
+  });
+}
+
+// src/endpoints/hono-single.ts
+import { Hono as Hono2 } from "hono";
+import { cors as cors2 } from "hono/cors";
+import { logger as logger2 } from "@copilotkitnext/shared";
+function createCopilotEndpointSingleRoute({ runtime, basePath }) {
+  const app = new Hono2();
+  const routePath = normalizePath(basePath);
+  return app.basePath(routePath).use(
+    "*",
+    cors2({
+      origin: "*",
+      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "OPTIONS"],
+      allowHeaders: ["*"]
+    })
+  ).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) {
+      logger2.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;
+    callAfterRequestMiddleware({
+      runtime,
+      response,
+      path
+    }).catch((error) => {
+      logger2.error({ err: error, url: c.req.url, path }, "Error running after request middleware");
+    });
+  }).post("/", async (c) => {
+    const request = c.get("modifiedRequest") || c.req.raw;
+    let methodCall;
+    try {
+      methodCall = await parseMethodCall(request);
+    } catch (error) {
+      if (error instanceof Response) {
+        logger2.warn({ url: request.url }, "Invalid single-route payload");
+        return error;
+      }
+      logger2.warn({ err: error, url: request.url }, "Invalid single-route payload");
+      return c.json(
+        {
+          error: "invalid_request",
+          message: error instanceof Error ? error.message : "Invalid request payload"
+        },
+        400
+      );
+    }
+    try {
+      switch (methodCall.method) {
+        case "agent/run": {
+          const agentId = expectString(methodCall.params, "agentId");
+          const handlerRequest = createJsonRequest(request, methodCall.body);
+          return await handleRunAgent({ runtime, request: handlerRequest, agentId });
+        }
+        case "agent/connect": {
+          const agentId = expectString(methodCall.params, "agentId");
+          const handlerRequest = createJsonRequest(request, methodCall.body);
+          return await handleConnectAgent({ runtime, request: handlerRequest, agentId });
+        }
+        case "agent/stop": {
+          const agentId = expectString(methodCall.params, "agentId");
+          const threadId = expectString(methodCall.params, "threadId");
+          return await handleStopAgent({ runtime, request, agentId, threadId });
+        }
+        case "info": {
+          return await handleGetRuntimeInfo({ runtime, request });
+        }
+        case "transcribe": {
+          return await handleTranscribe({ runtime, request });
+        }
+        default: {
+          const exhaustiveCheck = methodCall.method;
+          return exhaustiveCheck;
+        }
+      }
+    } catch (error) {
+      if (error instanceof Response) {
+        return error;
+      }
+      logger2.error({ err: error, url: request.url, method: methodCall.method }, "Error running single-route handler");
       throw error;
     }
   }).notFound((c) => {
     return c.json({ error: "Not found" }, 404);
   });
 }
+function normalizePath(path) {
+  if (!path) {
+    throw new Error("basePath must be provided for single-route endpoint");
+  }
+  if (!path.startsWith("/")) {
+    return `/${path}`;
+  }
+  if (path.length > 1 && path.endsWith("/")) {
+    return path.slice(0, -1);
+  }
+  return path;
+}
 
 // src/runner/index.ts
-import { finalizeRunEvents as finalizeRunEvents2 } from "@copilotkitnext/shared";
+import { finalizeRunEvents } from "@copilotkitnext/shared";
 export {
   AgentRunner,
   CopilotRuntime,
   InMemoryAgentRunner,
   VERSION,
   createCopilotEndpoint,
-  finalizeRunEvents2 as finalizeRunEvents
+  createCopilotEndpointSingleRoute,
+  finalizeRunEvents
 };
 //# sourceMappingURL=index.mjs.map