@cuylabs/agent-http 0.9.0 → 0.10.0

package/README.md

@@ -1,6 +1,6 @@
 # @cuylabs/agent-http
 
-HTTP streaming adapter for [@cuylabs/agent-core](https://github.com/cuylabs-ai/agents-ts/tree/main/packages/agent-core). Bridges agent events to AI SDK v6 `UIMessageStream` for use with `useChat()`.
+HTTP streaming adapter for the CuyLabs agent stack.
 
 It maps the UI-facing streaming events (`text-*`, `reasoning-*`, `tool-*`, `error`) and intentionally skips advanced agent-core events that do not have a direct `UIMessageStream` equivalent (`turn-boundary`, `turn-summary`, approvals, interventions, retries, etc.).
 
@@ -8,7 +8,8 @@ This package is intentionally narrow:
 
 - It is a good way to expose an agent over HTTP when your client already speaks the AI SDK v6 chat stream protocol.
 - It is not a full generic agent hosting layer, REST API surface, or control plane.
-- For broader host/runtime concerns, keep those in your app or use the runtime packages.
+- For broader host/runtime concerns, keep those in your app, use
+  `@cuylabs/agent-server`, or use the runtime packages.
 
 ## Installation
 

package/dist/index.d.ts

@@ -1,91 +1,31 @@
 import { Agent } from '@cuylabs/agent-core';
 export { AgentEvent } from '@cuylabs/agent-core';
+import { AgentServerAdapter, AgentServer, AgentServerClient } from '@cuylabs/agent-server';
 import { createUIMessageStream } from 'ai';
 export { createUIMessageStream, createUIMessageStreamResponse } from 'ai';
 
 /**
  * @cuylabs/agent-http
  *
- * HTTP streaming adapter for @cuylabs/agent-core.
- * Bridges agent events to AI SDK v6 compatible UIMessageStream for use with useChat().
- * Advanced agent-core events without a direct UIMessageStream equivalent are
- * intentionally skipped here.
- *
- * @example
- * ```typescript
- * // In a Next.js API route
- * import { createAgent } from "@cuylabs/agent-core";
- * import { createAgentStreamResponse } from "@cuylabs/agent-http";
- * import { anthropic } from "@ai-sdk/anthropic";
- *
- * const agent = createAgent({
- *   model: anthropic("claude-sonnet-4-20250514"),
- *   systemPrompt: "You are a helpful assistant.",
- * });
- *
- * export async function POST(req: Request) {
- *   const { messages, id } = await req.json();
- *   const lastMessage = messages[messages.length - 1];
- *
- *   return createAgentStreamResponse(agent, {
- *     sessionId: id,
- *     message: lastMessage.content,
- *   });
- * }
- * ```
+ * HTTP streaming adapter for the CuyLabs agent stack.
+ * Bridges direct agents and agent-server-backed runtimes to AI SDK v6
+ * `UIMessageStream` for use with `useChat()`.
  *
  * @packageDocumentation
  */
 
-/**
- * Options for creating an agent stream response
- */
 interface AgentStreamOptions {
-    /** Session ID for conversation history */
     sessionId: string;
-    /** User message to send */
     message: string;
-    /** Optional abort signal */
     abortSignal?: AbortSignal;
-    /** Optional system prompt override for this message */
     system?: string;
-    /** Callback when streaming completes - use for persistence */
     onFinish?: (result: {
         response: string;
         messageId?: string;
     }) => void | Promise<void>;
 }
-/**
- * Create an HTTP streaming response from an agent.
- *
- * This bridges @cuylabs/agent-core's event-based streaming to the
- * AI SDK v6 UIMessageStream format that useChat() understands.
- *
- * @example
- * ```typescript
- * // Next.js API route
- * export async function POST(req: Request) {
- *   const { messages, id } = await req.json();
- *   const lastMessage = messages[messages.length - 1];
- *
- *   return createAgentStreamResponse(agent, {
- *     sessionId: id,
- *     message: lastMessage.content,
- *     onFinish: async ({ response }) => {
- *       // Persist the response to database
- *       await saveMessage({ chatId: id, content: response, role: "assistant" });
- *     },
- *   });
- * }
- * ```
- */
-declare function createAgentStreamResponse(agent: Agent, options: AgentStreamOptions): Response;
-/**
- * Create a ReadableStream of UIMessageChunks from agent events.
- *
- * Lower-level than createAgentStreamResponse - useful when you need
- * to compose streams or add custom middleware.
- */
-declare function createAgentStream(agent: Agent, options: AgentStreamOptions): ReturnType<typeof createUIMessageStream>;
+type AgentStreamSource = Agent | AgentServerAdapter | AgentServer | AgentServerClient;
+declare function createAgentStream(source: AgentStreamSource, options: AgentStreamOptions): ReturnType<typeof createUIMessageStream>;
+declare function createAgentStreamResponse(source: AgentStreamSource, options: AgentStreamOptions): Response;
 
-export { type AgentStreamOptions, createAgentStream, createAgentStreamResponse };
+export { type AgentStreamOptions, type AgentStreamSource, createAgentStream, createAgentStreamResponse };

package/dist/index.js

@@ -1,4 +1,7 @@
 // src/index.ts
+import {
+  createAgentServerAdapter
+} from "@cuylabs/agent-server";
 import {
   createUIMessageStream,
   createUIMessageStreamResponse
@@ -7,15 +10,122 @@ var idCounter = 0;
 function generatePartId() {
   return `part-${Date.now()}-${++idCounter}`;
 }
-async function writeAgentEventsToStream(agent, options, writer) {
+function isServerSource(source) {
+  return typeof source.startTurn === "function" && typeof source.subscribe === "function";
+}
+function isAdapterSource(source) {
+  return typeof source.chat === "function" && typeof source.listSessions === "function" && typeof source.getSessionStorage === "function";
+}
+async function* iterateAgentEvents(source, options) {
+  if (isServerSource(source)) {
+    yield* streamServerAgentEvents(source, options);
+    return;
+  }
+  const adapter = isAdapterSource(source) ? source : createAgentServerAdapter(source);
+  for await (const event of adapter.chat(options.sessionId, options.message, {
+    ...options.abortSignal ? { abort: options.abortSignal } : {},
+    ...options.system ? { system: options.system } : {}
+  })) {
+    yield event;
+  }
+}
+async function* streamServerAgentEvents(server, options) {
+  for await (const notification of streamServerTurn(server, options)) {
+    if (notification.type === "turn/event") {
+      yield notification.event;
+    }
+  }
+}
+async function* streamServerTurn(server, options) {
+  const queue = [];
+  let waiter = null;
+  let turnId = null;
+  const unsubscribe = server.subscribe(
+    (notification) => {
+      if (waiter) {
+        const resolve = waiter;
+        waiter = null;
+        resolve(notification);
+        return;
+      }
+      queue.push(notification);
+    },
+    { sessionId: options.sessionId }
+  );
+  const abortListener = () => {
+    if (turnId !== null) {
+      server.interruptTurn(turnId);
+    }
+  };
+  try {
+    const turn = await server.startTurn(options.sessionId, options.message, {
+      ...options.system ? { system: options.system } : {}
+    });
+    turnId = turn.id;
+    if (options.abortSignal) {
+      if (options.abortSignal.aborted) {
+        server.interruptTurn(turnId);
+      } else {
+        options.abortSignal.addEventListener("abort", abortListener, {
+          once: true
+        });
+      }
+    }
+    while (true) {
+      const notification = queue.shift() ?? await new Promise((resolve) => {
+        waiter = resolve;
+      });
+      if (!matchesTurnStreamNotification(notification, options.sessionId, turnId)) {
+        continue;
+      }
+      if (notification.type === "turn/started") {
+        turnId = notification.turn.id;
+        if (options.abortSignal?.aborted) {
+          server.interruptTurn(turnId);
+        }
+      }
+      yield notification;
+      if (notification.type === "turn/completed" && notification.turn.id === turnId) {
+        break;
+      }
+    }
+  } finally {
+    unsubscribe();
+    options.abortSignal?.removeEventListener("abort", abortListener);
+  }
+}
+function matchesTurnStreamNotification(notification, sessionId, turnId) {
+  switch (notification.type) {
+    case "session/created":
+      return notification.session.id === sessionId;
+    case "session/deleted":
+      return notification.sessionId === sessionId;
+    case "session/branched":
+    case "session/runtime":
+      return notification.sessionId === sessionId;
+    case "turn/started":
+    case "input/request":
+    case "input/resolved":
+    case "turn/completed":
+      if (notification.type === "turn/started" || notification.type === "turn/completed") {
+        return turnId !== null && notification.turn.id === turnId;
+      }
+      return turnId !== null && (notification.type === "input/request" ? notification.request.turnId === turnId : notification.turnId === turnId);
+    case "turn/event":
+      return turnId !== null && notification.turnId === turnId;
+    case "team/notification":
+      return false;
+    default: {
+      const _exhaustive = notification;
+      return false;
+    }
+  }
+}
+async function writeAgentEventsToStream(source, options, writer) {
   let currentTextId = null;
   let fullResponse = "";
-  for await (const event of agent.chat(options.sessionId, options.message, {
-    abort: options.abortSignal,
-    system: options.system
-  })) {
+  for await (const event of iterateAgentEvents(source, options)) {
     switch (event.type) {
-      // Text streaming
       case "text-start":
         currentTextId = generatePartId();
         writer.write({
@@ -42,7 +152,6 @@ async function writeAgentEventsToStream(agent, options, writer) {
           currentTextId = null;
         }
         break;
-      // Reasoning/thinking streaming
       case "reasoning-start":
         writer.write({
           type: "reasoning-start",
@@ -62,7 +171,6 @@ async function writeAgentEventsToStream(agent, options, writer) {
           id: event.id
         });
         break;
-      // Tool invocations
       case "tool-start":
         writer.write({
           type: "tool-input-available",
@@ -85,15 +193,12 @@ async function writeAgentEventsToStream(agent, options, writer) {
           output: { error: event.error, isError: true }
         });
         break;
-      // Error handling
       case "error":
         writer.write({
           type: "error",
           errorText: event.error.message
         });
         break;
-      // Step/message/runtime lifecycle events - no direct mapping in AI SDK v6.
-      // These can be exposed later via custom data parts if the UI needs them.
       case "step-start":
       case "step-finish":
       case "turn-boundary":
@@ -101,8 +206,6 @@ async function writeAgentEventsToStream(agent, options, writer) {
       case "intervention-applied":
       case "turn-summary":
       case "complete":
-        break;
-      // Events we don't need to stream
       case "status":
       case "retry":
       case "doom-loop":
@@ -111,18 +214,22 @@ async function writeAgentEventsToStream(agent, options, writer) {
       case "computer-result":
       case "approval-request":
       case "approval-resolved":
+      case "human-input-request":
+      case "human-input-resolved":
         break;
     }
   }
   return fullResponse;
 }
-function createAgentStreamResponse(agent, options) {
+function createAgentStream(source, options) {
   let fullResponse = "";
-  const stream = createUIMessageStream({
+  return createUIMessageStream({
     execute: async ({ writer }) => {
-      fullResponse = await writeAgentEventsToStream(agent, options, writer);
+      fullResponse = await writeAgentEventsToStream(source, options, writer);
     },
-    onFinish: async ({ responseMessage }) => {
+    onFinish: async ({
+      responseMessage
+    }) => {
       if (options.onFinish) {
         await options.onFinish({
           response: fullResponse,
@@ -130,29 +237,12 @@ function createAgentStreamResponse(agent, options) {
         });
       }
     },
-    onError: (error) => {
-      return error instanceof Error ? error.message : "Unknown error";
-    }
+    onError: (error) => error instanceof Error ? error.message : "Unknown error"
   });
-  return createUIMessageStreamResponse({ stream });
 }
-function createAgentStream(agent, options) {
-  let fullResponse = "";
-  return createUIMessageStream({
-    execute: async ({ writer }) => {
-      fullResponse = await writeAgentEventsToStream(agent, options, writer);
-    },
-    onFinish: async ({ responseMessage }) => {
-      if (options.onFinish) {
-        await options.onFinish({
-          response: fullResponse,
-          messageId: responseMessage?.id
-        });
-      }
-    },
-    onError: (error) => {
-      return error instanceof Error ? error.message : "Unknown error";
-    }
+function createAgentStreamResponse(source, options) {
+  return createUIMessageStreamResponse({
+    stream: createAgentStream(source, options)
   });
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/agent-http",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "HTTP streaming adapter for @cuylabs/agent-core - bridges agent events to AI SDK compatible streams",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,7 +17,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@cuylabs/agent-core": "^0.9.0"
+    "@cuylabs/agent-core": "^0.10.0",
+    "@cuylabs/agent-server": "^0.10.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",