@cloudbase/agent-server 0.0.9 → 0.0.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @cloudbase/agent-server
 
+## 1.0.1-alpha.6
+
+### Patch Changes
+
+- alpha release 0.1.2-alpha.1
+  - Update all public packages to version 0.1.2-alpha.1
+  - Trigger automated alpha release workflow
+  - Includes latest features and improvements
+
+- Updated dependencies
+  - @cloudbase/agent-shared@1.0.1-alpha.6
+
 ## 1.0.1-alpha.5
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { CreateCopilotRuntimeServerOptions } from '@copilotkit/runtime';
 import { CopilotRuntimeOptions } from '@copilotkit/runtime/v2';
-import express, { Express } from 'express';
+import expressLib, { Express } from 'express';
 import * as _ag_ui_client from '@ag-ui/client';
 import { AbstractAgent, RunAgentInput } from '@ag-ui/client';
 import cors from 'cors';
@@ -9,13 +9,25 @@ import { Repeater } from '@repeaterjs/repeater';
 import * as _whatwg_node_server from '@whatwg-node/server';
 import { OpenAI } from 'openai';
 
+/**
+ * Context passed to the agent factory function.
+ * Contains request information for per-request agent configuration.
+ */
+interface AgentCreatorContext {
+    /** The incoming HTTP request (Web Standard Request) */
+    request: Request;
+}
 type AgentCreatorRet = {
     agent: AbstractAgent | {
         toAGUIAgent(): AbstractAgent;
     };
     cleanup?: () => void;
 };
-type AgentCreator = () => AgentCreatorRet | Promise<AgentCreatorRet>;
+/**
+ * Factory function to create an agent.
+ * Can optionally receive request context for per-request configuration.
+ */
+type AgentCreator = ((context: AgentCreatorContext) => AgentCreatorRet | Promise<AgentCreatorRet>) | (() => AgentCreatorRet | Promise<AgentCreatorRet>);
 interface ICreateServer {
     createAgent: AgentCreator;
     basePath?: `/${string}/`;
@@ -31,7 +43,7 @@ interface ICreateExpressRoutes extends Omit<ICreateServer, "cors"> {
 }
 declare function run(props: IRun): void;
 declare function createExpressServer(props: ICreateServer): Express;
-declare function createExpressRoutes({ createAgent, basePath: _basePath, express, useAGUI: _useAGUI, aguiOptions, }: ICreateExpressRoutes): express.Express;
+declare function createExpressRoutes({ createAgent, basePath: _basePath, express, useAGUI: _useAGUI, aguiOptions, }: ICreateExpressRoutes): expressLib.Express;
 interface AGUIOptions {
     runtimeOptions?: Partial<CopilotRuntimeOptions>;
     endpointOptions?: Partial<CreateCopilotRuntimeServerOptions>;
@@ -107,4 +119,4 @@ declare namespace index {
   export { index$2 as healthz, index$1 as openai, index$4 as sendMessage, index$3 as sendMessageAGUI };
 }
 
-export { type AgentCreator, index as agui, createExpressRoutes, createExpressServer, run };
+export { type AgentCreator, type AgentCreatorContext, index as agui, createExpressRoutes, createExpressServer, run };

package/dist/index.js

@@ -166,7 +166,9 @@ var import_agent_shared = require("@cloudbase/agent-shared");
 function createServerAdapter(createAgent) {
   return (0, import_server.createServerAdapter)(async (request) => {
     const input = import_agent_shared.sendMessageInputSchema.parse(await request.json());
-    const { agent: unknownAgent, cleanup } = await Promise.resolve(createAgent());
+    const { agent: unknownAgent, cleanup } = await Promise.resolve(
+      createAgent({ request })
+    );
     const agent = "toAGUIAgent" in unknownAgent ? unknownAgent.toAGUIAgent() : unknownAgent;
     const events = handler(input, agent);
     let heartbeat;
@@ -229,13 +231,68 @@ function handler2(input, agent) {
 // src/agui/sendMessageAGUI/server.ts
 var import_server3 = require("@whatwg-node/server");
 var import_client2 = require("@ag-ui/client");
+var import_uuid2 = require("uuid");
 function createServerAdapter2(createAgent) {
   return (0, import_server3.createServerAdapter)(async (request) => {
-    const input = import_client2.RunAgentInputSchema.parse(await request.json());
-    const { agent: unknownAgent, cleanup } = await Promise.resolve(createAgent());
-    const agent = "toAGUIAgent" in unknownAgent ? unknownAgent.toAGUIAgent() : unknownAgent;
-    const events = handler2(input, agent);
+    const inputRes = await safeAsync(async () => {
+      const rawInput = await request.json();
+      const inputWithDefaults = {
+        tools: [],
+        context: [],
+        state: {},
+        forwardedProps: {},
+        ...rawInput,
+        runId: typeof rawInput.runId === "string" && rawInput.runId ? rawInput.runId : (0, import_uuid2.v4)()
+      };
+      return import_client2.RunAgentInputSchema.parse(inputWithDefaults);
+    });
+    if ("error" in inputRes) {
+      const { error } = inputRes;
+      console.error("[AGUI Server] Pre-stream error:", error);
+      return new Response(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const createAgentRes = await safeAsync(async () => {
+      const res = await Promise.resolve(createAgent({ request }));
+      return {
+        cleanup: res.cleanup,
+        agent: "toAGUIAgent" in res.agent ? res.agent.toAGUIAgent() : res.agent
+      };
+    });
+    if ("error" in createAgentRes) {
+      const { error } = createAgentRes;
+      console.error("[AGUI Server] Pre-stream error:", error);
+      return new Response(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const events = handler2(inputRes.result, createAgentRes.result.agent);
     let heartbeat;
+    let cleanupCalled = false;
+    const safeCleanup = () => {
+      var _a, _b;
+      if (!cleanupCalled) {
+        cleanupCalled = true;
+        try {
+          (_b = (_a = createAgentRes.result).cleanup) == null ? void 0 : _b.call(_a);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    };
     const stream = new ReadableStream({
       async start(controller) {
         const encoder = new TextEncoder();
@@ -249,14 +306,26 @@ function createServerAdapter2(createAgent) {
 `;
             controller.enqueue(encoder.encode(sseChunk));
           }
+        } catch (error) {
+          console.error("[AGUI Server] Stream error:", error);
+          const errorEvent = {
+            type: import_client2.EventType.RUN_ERROR,
+            message: error instanceof Error ? error.message : String(error)
+          };
+          controller.enqueue(
+            encoder.encode(`data: ${JSON.stringify(errorEvent)}
+
+`)
+          );
         } finally {
           if (heartbeat) clearInterval(heartbeat);
           controller.close();
-          cleanup == null ? void 0 : cleanup();
+          safeCleanup();
         }
       },
       cancel() {
         if (heartbeat) clearInterval(heartbeat);
+        safeCleanup();
       }
     });
     const headers = new Headers({
@@ -267,6 +336,15 @@ function createServerAdapter2(createAgent) {
     return new Response(stream, { status: 200, headers });
   });
 }
+async function safeAsync(fn) {
+  try {
+    return {
+      result: await fn()
+    };
+  } catch (error) {
+    return { error };
+  }
+}
 
 // src/agui/healthz/index.ts
 var healthz_exports = {};
@@ -284,7 +362,7 @@ __export(openai_exports, {
 });
 
 // src/agui/openai/handler.ts
-var import_uuid2 = require("uuid");
+var import_uuid3 = require("uuid");
 var import_repeater3 = require("@repeaterjs/repeater");
 function handler3(input, agent) {
   var _a;
@@ -296,12 +374,12 @@ function handler3(input, agent) {
         description: tool.function.description,
         parameters: tool.function.parameters
       })),
-      conversationId: (0, import_uuid2.v4)()
+      conversationId: (0, import_uuid3.v4)()
     },
     agent
   );
   return new import_repeater3.Repeater(async (push, stop) => {
-    const id = (0, import_uuid2.v4)();
+    const id = (0, import_uuid3.v4)();
     let tools = [];
     let lastWithToolCall = false;
     let maxIndex = 0;
@@ -430,7 +508,9 @@ var import_server6 = require("@whatwg-node/server");
 function createServerAdapter3(createAgent) {
   return (0, import_server6.createServerAdapter)(async (request) => {
     const input = await request.json();
-    const { agent: unknownAgent, cleanup } = await Promise.resolve(createAgent());
+    const { agent: unknownAgent, cleanup } = await Promise.resolve(
+      createAgent({ request })
+    );
     const agent = "toAGUIAgent" in unknownAgent ? unknownAgent.toAGUIAgent() : unknownAgent;
     const events = handler3(input, agent);
     const stream = new ReadableStream({
@@ -460,6 +540,19 @@ function createServerAdapter3(createAgent) {
 var import_runtime = require("@copilotkit/runtime");
 var import_express = __toESM(require("express"));
 var import_cors = __toESM(require("cors"));
+var import_async_hooks = require("async_hooks");
+var import_server8 = require("@whatwg-node/server");
+var DefaultFetchAPI = __toESM(require("@whatwg-node/fetch"));
+var preparedAgentStorage = new import_async_hooks.AsyncLocalStorage();
+function agentCloneFn() {
+  const preparedAgent = preparedAgentStorage.getStore();
+  if (preparedAgent) {
+    return preparedAgent;
+  }
+  throw new Error(
+    "agent.clone() called outside of request context. This should not happen in normal operation."
+  );
+}
 function run(props) {
   const { port, ...rest } = props;
   createExpressServer(rest).listen(
@@ -481,7 +574,7 @@ function createExpressServer(props) {
 function createExpressRoutes({
   createAgent,
   basePath: _basePath,
-  express: express2,
+  express,
   useAGUI: _useAGUI,
   aguiOptions
 }) {
@@ -491,32 +584,34 @@ function createExpressRoutes({
   if (useAGUI) {
     createAGUIRoute({
       basePath,
-      express: express2,
+      express,
       createAgent,
       ...aguiOptions || {}
     });
   }
   const openaiServerAdapter = openai_exports.createServerAdapter(createAgent);
   const healthzServerAdapter = healthz_exports.serverAdapter;
-  express2.use(`${basePath}send-message`, sendMessageServerAdapter);
-  express2.use(`${basePath}healthz`, healthzServerAdapter);
-  express2.use(`${basePath}chat/completions`, openaiServerAdapter);
-  return express2;
+  express.use(`${basePath}send-message`, sendMessageServerAdapter);
+  express.use(`${basePath}healthz`, healthzServerAdapter);
+  express.use(`${basePath}chat/completions`, openaiServerAdapter);
+  return express;
 }
 var AGUIRpcHandlerPromise = null;
 function getAGUIRpcHandler({
   createAgent,
   runtimeOptions,
   basePath,
-  endpointOptions
+  endpointOptions,
+  request
 }) {
   if (AGUIRpcHandlerPromise) return AGUIRpcHandlerPromise;
   AGUIRpcHandlerPromise = (async () => {
-    const agent = (await createAgent()).agent;
-    const aguiAgent = "toAGUIAgent" in agent ? agent.toAGUIAgent() : agent;
+    const { agent } = await createAgent({ request });
+    const templateAgent = "toAGUIAgent" in agent ? agent.toAGUIAgent() : agent;
+    templateAgent.clone = agentCloneFn;
     const runtime = new import_runtime.CopilotRuntime({
       agents: {
-        default: aguiAgent
+        default: templateAgent
       },
       ...runtimeOptions || {}
     });
@@ -530,20 +625,32 @@ function getAGUIRpcHandler({
   return AGUIRpcHandlerPromise;
 }
 function createAGUIRoute({
-  express: express2,
+  express,
   basePath,
   createAgent,
   runtimeOptions,
   endpointOptions
 }) {
-  express2.post(`${basePath}agui`, async (req, res) => {
+  express.post(`${basePath}agui`, import_express.default.json(), async (req, res) => {
+    const webRequest = (0, import_server8.normalizeNodeRequest)(req, DefaultFetchAPI);
+    const { agent: rawAgent, cleanup } = await createAgent({
+      request: webRequest
+    });
+    const preparedAgent = "toAGUIAgent" in rawAgent ? rawAgent.toAGUIAgent() : rawAgent;
+    preparedAgent.clone = agentCloneFn;
     const rpcHandler = await getAGUIRpcHandler({
       createAgent,
       basePath,
       runtimeOptions,
-      endpointOptions
+      endpointOptions,
+      request: webRequest
+    });
+    preparedAgentStorage.run(preparedAgent, () => {
+      rpcHandler(req, res);
     });
-    rpcHandler(req, res);
+    if (cleanup) {
+      res.on("close", cleanup);
+    }
   });
 }
 function isCorsOptions(cors2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/agent-server",
-  "version": "0.0.9",
+  "version": "0.0.12",
   "main": "dist/index.js",
   "files": [
     "dist/",
@@ -14,13 +14,14 @@
     "@ag-ui/client": "0.0.42",
     "@copilotkit/runtime": "^1.50.1",
     "@repeaterjs/repeater": "^3.0.6",
+    "@whatwg-node/fetch": "^0.10.13",
     "@whatwg-node/server": "^0.10.12",
     "cors": "^2.8.5",
     "express": "^5.1.0",
     "openai": "6.3.0",
     "uuid": "^10.0.0",
     "zod": "^4.1.12",
-    "@cloudbase/agent-shared": "^0.0.9"
+    "@cloudbase/agent-shared": "^0.0.12"
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",