@cuylabs/agent-http 0.1.0

package/README.md

@@ -0,0 +1,104 @@
+# @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()`.
+
+## Installation
+
+```bash
+npm install @cuylabs/agent-http @cuylabs/agent-core
+# or
+pnpm add @cuylabs/agent-http @cuylabs/agent-core
+```
+
+You'll also need at least one AI SDK provider:
+
+```bash
+npm install @ai-sdk/openai
+# or @ai-sdk/anthropic, @ai-sdk/google
+```
+
+## Quick Start
+
+```typescript
+// app/api/chat/route.ts (Next.js)
+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,
+  });
+}
+```
+
+Then use with AI SDK's `useChat()`:
+
+```tsx
+"use client";
+import { useChat } from "@ai-sdk/react";
+
+export function Chat() {
+  const { messages, input, handleInputChange, handleSubmit } = useChat({
+    api: "/api/chat",
+  });
+
+  return (
+    <div>
+      {messages.map((m) => (
+        <div key={m.id}>
+          {m.role}: {m.content}
+        </div>
+      ))}
+      <form onSubmit={handleSubmit}>
+        <input value={input} onChange={handleInputChange} />
+        <button type="submit">Send</button>
+      </form>
+    </div>
+  );
+}
+```
+
+## API
+
+### createAgentStreamResponse
+
+Creates an HTTP Response with streaming agent events.
+
+```typescript
+function createAgentStreamResponse(
+  agent: Agent,
+  options: AgentStreamOptions
+): Response;
+
+interface AgentStreamOptions {
+  sessionId: string;
+  message: string;
+  abortSignal?: AbortSignal;
+  system?: string;
+}
+```
+
+### createAgentStream
+
+Lower-level API that returns a ReadableStream.
+
+```typescript
+function createAgentStream(
+  agent: Agent,
+  options: AgentStreamOptions
+): ReturnType<typeof createUIMessageStream>;
+```
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import { Agent } from '@cuylabs/agent-core';
+export { AgentEvent } from '@cuylabs/agent-core';
+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().
+ *
+ * @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,
+ *   });
+ * }
+ * ```
+ *
+ * @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>;
+
+export { type AgentStreamOptions, createAgentStream, createAgentStreamResponse };

package/dist/index.js

@@ -0,0 +1,167 @@
+// src/index.ts
+import {
+  createUIMessageStream,
+  createUIMessageStreamResponse
+} from "ai";
+var idCounter = 0;
+function generatePartId() {
+  return `part-${Date.now()}-${++idCounter}`;
+}
+async function writeAgentEventsToStream(agent, options, writer) {
+  let currentTextId = null;
+  let currentReasoningId = null;
+  let fullResponse = "";
+  for await (const event of agent.chat(options.sessionId, options.message, {
+    abort: options.abortSignal,
+    system: options.system
+  })) {
+    switch (event.type) {
+      // Text streaming
+      case "text-start":
+        currentTextId = generatePartId();
+        writer.write({
+          type: "text-start",
+          id: currentTextId
+        });
+        break;
+      case "text-delta":
+        if (currentTextId) {
+          fullResponse += event.text;
+          writer.write({
+            type: "text-delta",
+            id: currentTextId,
+            delta: event.text
+          });
+        }
+        break;
+      case "text-end":
+        if (currentTextId) {
+          writer.write({
+            type: "text-end",
+            id: currentTextId
+          });
+          currentTextId = null;
+        }
+        break;
+      // Reasoning/thinking streaming
+      case "reasoning-start":
+        currentReasoningId = generatePartId();
+        writer.write({
+          type: "reasoning-start",
+          id: currentReasoningId
+        });
+        break;
+      case "reasoning-delta":
+        if (currentReasoningId) {
+          writer.write({
+            type: "reasoning-delta",
+            id: currentReasoningId,
+            delta: event.text
+          });
+        }
+        break;
+      case "reasoning-end":
+        if (currentReasoningId) {
+          writer.write({
+            type: "reasoning-end",
+            id: currentReasoningId
+          });
+          currentReasoningId = null;
+        }
+        break;
+      // Tool invocations
+      case "tool-start":
+        writer.write({
+          type: "tool-input-available",
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          input: event.input
+        });
+        break;
+      case "tool-result":
+        writer.write({
+          type: "tool-output-available",
+          toolCallId: event.toolCallId,
+          output: event.result
+        });
+        break;
+      case "tool-error":
+        writer.write({
+          type: "tool-output-available",
+          toolCallId: event.toolCallId,
+          output: { error: event.error, isError: true }
+        });
+        break;
+      // Error handling
+      case "error":
+        writer.write({
+          type: "error",
+          errorText: event.error.message
+        });
+        break;
+      // Step and message lifecycle events - no direct mapping in AI SDK v6
+      // These can be exposed via custom data parts if needed
+      case "step-start":
+      case "step-finish":
+      case "message":
+      case "complete":
+        break;
+      // Events we don't need to stream
+      case "status":
+      case "retry":
+      case "doom-loop":
+      case "context-overflow":
+      case "computer-call":
+      case "computer-result":
+      case "approval-request":
+      case "approval-resolved":
+        break;
+    }
+  }
+  return fullResponse;
+}
+function createAgentStreamResponse(agent, options) {
+  let fullResponse = "";
+  const stream = 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";
+    }
+  });
+  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";
+    }
+  });
+}
+export {
+  createAgentStream,
+  createAgentStreamResponse,
+  createUIMessageStream,
+  createUIMessageStreamResponse
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@cuylabs/agent-http",
+  "version": "0.1.0",
+  "description": "HTTP streaming adapter for @cuylabs/agent-core - bridges agent events to AI SDK compatible streams",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@cuylabs/agent-core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0"
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "http",
+    "streaming",
+    "vercel-ai-sdk"
+  ],
+  "author": "cuylabs",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cuylabs-ai/agents-ts.git",
+    "directory": "packages/agent-http"
+  }
+}