deepagentsdk 0.9.2 → 0.11.0

package/README.md

@@ -1,13 +1,13 @@
-# AI SDK Deep Agent
+# Deep Agent SDK
 
 <p align="center">
-  <img src="assets/www-hero.png" alt="AI SDK Deep Agent" width="100%" />
+  <img src="assets/www-hero.png" alt="Deep Agent SDK" width="100%" />
 </p>
 
 [![npm version](https://badge.fury.io/js/deepagentsdk.svg)](https://www.npmjs.com/package/deepagentsdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/chrispangg/ai-sdk-deepagent)
-[![Documentation](https://img.shields.io/badge/docs-ai--sdk--deepagent-blue)](https://deepagentsdk.vercel.app/docs)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/chrispangg/deepagentsdk)
+[![Documentation](https://img.shields.io/badge/docs-ai--sdk--deepagent-blue)](https://deepagentsdk.dev/docs)
 
 > **Note:** This package requires [Bun](https://bun.sh) runtime. It uses Bun-specific features and TypeScript imports.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepagentsdk",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Deep Agent implementation using Vercel AI SDK - build controllable AI agents with planning, filesystem, and subagent capabilities",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -16,6 +16,10 @@
     },
     "./cli": {
       "import": "./src/cli/index.ts"
+    },
+    "./elements": {
+      "import": "./src/adapters/elements/index.ts",
+      "types": "./src/adapters/elements/index.ts"
     }
   },
   "files": [
@@ -33,20 +37,20 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/chrispangg/ai-sdk-deepagent.git"
+    "url": "git+https://github.com/chrispangg/deepagentsdk.git"
   },
-  "homepage": "https://github.com/chrispangg/ai-sdk-deepagent#readme",
+  "homepage": "https://github.com/chrispangg/deepagentsdk#readme",
   "bugs": {
-    "url": "https://github.com/chrispangg/ai-sdk-deepagent/issues"
+    "url": "https://github.com/chrispangg/deepagentsdk/issues"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.0-beta.83",
-    "@ai-sdk/openai": "^3.0.0-beta.96",
-    "@ai-sdk/react": "^3.0.0-beta.153",
+    "@ai-sdk/anthropic": "^3.0.9",
+    "@ai-sdk/openai": "^3.0.7",
+    "@ai-sdk/react": "^3.0.9",
     "@inkjs/ui": "^1.0.0",
     "@mozilla/readability": "^0.6.0",
     "@tavily/core": "^0.6.1",
-    "ai": "^6.0.0-beta.150",
+    "ai": "^6.0.19",
     "fast-glob": "^3.3.3",
     "ink": "^5.1.0",
     "jsdom": "^25.0.1",
@@ -63,6 +67,7 @@
     "@opentelemetry/instrumentation": "^0.208.0",
     "@opentelemetry/sdk-logs": "^0.208.0",
     "@opentelemetry/sdk-node": "^0.208.0",
+    "@testing-library/react": "^16.3.1",
     "@types/bun": "latest",
     "@types/jsdom": "^21.1.7",
     "@types/micromatch": "^4.0.9",
@@ -71,6 +76,7 @@
     "@vercel/otel": "^2.1.0",
     "install": "^0.13.0",
     "langfuse-vercel": "^3.38.6",
+    "react-dom": "^18.2.0",
     "typescript": "^5.7.3"
   },
   "peerDependencies": {
@@ -92,4 +98,4 @@
     "bun": ">=1.0.0"
   },
   "license": "MIT"
-}
+}

package/src/adapters/elements/index.ts

@@ -0,0 +1,27 @@
+/**
+ * AI SDK Elements adapter for deepagentsdk
+ *
+ * This adapter enables deepagentsdk to work seamlessly with Vercel AI SDK Elements
+ * UI components by transforming agent events to the UIMessage format expected by Elements.
+ *
+ * @module adapters/elements
+ * @see https://ai-sdk.dev/elements
+ */
+
+export { useElementsAdapter } from "./useElementsAdapter.js";
+export type { UseElementsAdapterOptions } from "./useElementsAdapter.js";
+
+export { mapAgentStatusToUIStatus } from "./statusAdapter.js";
+export {
+  convertEventsToUIMessages,
+  extractToolParts,
+} from "./messageAdapter.js";
+
+export type {
+  UIMessage,
+  UIMessagePart,
+  UIStatus,
+  PromptInputMessage,
+  ToolUIPart,
+  UseElementsAdapterReturn,
+} from "./types.js";

package/src/adapters/elements/messageAdapter.ts

@@ -0,0 +1,165 @@
+/**
+ * Message transformation adapter for AI SDK Elements
+ *
+ * Converts deepagentsdk events to Elements UIMessage format
+ */
+
+import type { AgentEventLog } from "../../cli/hooks/useAgent.js";
+import type { UIMessage, UIMessagePart, UIStatus } from "./types.js";
+
+/**
+ * Converts agent event log to UIMessage format expected by Elements
+ *
+ * @param events - Array of agent events from useAgent hook
+ * @param streamingText - Current streaming text (if any)
+ * @param uiStatus - Current UI status
+ * @returns Array of UIMessage objects for Elements Message component
+ *
+ * Conversion logic:
+ * 1. Group events by role (user/assistant)
+ * 2. Convert each event type to appropriate UIMessagePart
+ * 3. Handle streaming text as in-progress message
+ * 4. Preserve event order and tool call/result pairing
+ */
+export function convertEventsToUIMessages(
+  events: AgentEventLog[],
+  streamingText: string,
+  uiStatus: UIStatus
+): UIMessage[] {
+  const messages: UIMessage[] = [];
+  let currentAssistantParts: UIMessagePart[] = [];
+  let messageIdCounter = 0;
+
+  const generateMessageId = (): string => {
+    return `msg-${Date.now()}-${++messageIdCounter}`;
+  };
+
+  for (const eventLog of events) {
+    const event = eventLog.event;
+
+    switch (event.type) {
+      case "user-message":
+        // Flush any pending assistant parts before user message
+        if (currentAssistantParts.length > 0) {
+          messages.push({
+            id: generateMessageId(),
+            role: "assistant",
+            parts: currentAssistantParts,
+            status: "ready",
+          });
+          currentAssistantParts = [];
+        }
+
+        // Add user message
+        messages.push({
+          id: eventLog.id,
+          role: "user",
+          parts: [{ type: "text", text: event.content }],
+          status: "ready",
+        });
+        break;
+
+      case "text-segment":
+        // Add text segment as separate text part
+        currentAssistantParts.push({
+          type: "text",
+          text: event.text,
+        });
+        break;
+
+      case "tool-call":
+        // Add tool call part
+        currentAssistantParts.push({
+          type: "tool-call",
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          args: event.args,
+        });
+        break;
+
+      case "tool-result":
+        // Add tool result part
+        currentAssistantParts.push({
+          type: "tool-result",
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          result: event.result,
+          isError: event.isError,
+        });
+        break;
+
+      // Ignore other event types for message rendering
+      // (they're handled separately by Elements components like Task, etc.)
+      default:
+        break;
+    }
+  }
+
+  // Add streaming text as in-progress assistant message
+  if (streamingText || currentAssistantParts.length > 0) {
+    if (streamingText) {
+      currentAssistantParts.push({ type: "text", text: streamingText });
+    }
+
+    // Determine status for current message
+    let messageStatus: UIStatus = "ready";
+    if (uiStatus === "streaming") {
+      messageStatus = "streaming";
+    } else if (uiStatus === "submitted") {
+      messageStatus = "submitted";
+    } else if (uiStatus === "error") {
+      messageStatus = "error";
+    }
+
+    messages.push({
+      id: generateMessageId(),
+      role: "assistant",
+      parts: currentAssistantParts,
+      status: messageStatus,
+    });
+  }
+
+  return messages;
+}
+
+/**
+ * Extracts tool parts from the most recent assistant message
+ *
+ * @param messages - UIMessage array
+ * @returns Array of tool parts (tool-call and tool-result)
+ */
+export function extractToolParts(messages: UIMessage[]) {
+  // Get last assistant message
+  const lastAssistantMessage = [...messages]
+    .reverse()
+    .find((m) => m.role === "assistant");
+
+  if (!lastAssistantMessage) {
+    return [];
+  }
+
+  // Extract only tool-related parts
+  return lastAssistantMessage.parts
+    .filter(
+      (part): part is Extract<UIMessagePart, { type: "tool-call" | "tool-result" }> =>
+        part.type === "tool-call" || part.type === "tool-result"
+    )
+    .map((part) => {
+      if (part.type === "tool-call") {
+        return {
+          type: "tool-call" as const,
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          args: part.args,
+        };
+      } else {
+        return {
+          type: "tool-result" as const,
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          result: part.result,
+          isError: part.isError,
+        };
+      }
+    });
+}

package/src/adapters/elements/statusAdapter.ts

@@ -0,0 +1,39 @@
+/**
+ * Status mapping adapter for AI SDK Elements
+ *
+ * Maps deepagentsdk AgentStatus to Elements UIStatus
+ */
+
+import type { AgentStatus } from "../../cli/hooks/useAgent.js";
+import type { UIStatus } from "./types.js";
+
+/**
+ * Maps deepagentsdk AgentStatus to Elements UIStatus
+ *
+ * @param agentStatus - The agent status from useAgent hook
+ * @returns The corresponding UI status for Elements components
+ *
+ * Mapping rules:
+ * - idle/done → ready (agent is waiting for input)
+ * - thinking/tool-call/subagent → submitted (agent is processing)
+ * - streaming → streaming (agent is generating text)
+ * - error → error (an error occurred)
+ */
+export function mapAgentStatusToUIStatus(
+  agentStatus: AgentStatus
+): UIStatus {
+  switch (agentStatus) {
+    case "thinking":
+    case "tool-call":
+    case "subagent":
+      return "submitted";
+    case "streaming":
+      return "streaming";
+    case "error":
+      return "error";
+    case "idle":
+    case "done":
+    default:
+      return "ready";
+  }
+}

package/src/adapters/elements/types.ts

@@ -0,0 +1,97 @@
+/**
+ * Types for AI SDK Elements adapter
+ *
+ * These types align with Vercel AI SDK Elements UI component expectations.
+ * @see https://ai-sdk.dev/elements
+ */
+
+/**
+ * UI message part types that Elements components expect
+ */
+export type UIMessagePart =
+  | {
+      type: "text";
+      text: string;
+    }
+  | {
+      type: "tool-call";
+      toolCallId: string;
+      toolName: string;
+      args: unknown;
+    }
+  | {
+      type: "tool-result";
+      toolCallId: string;
+      toolName: string;
+      result: unknown;
+      isError?: boolean;
+    };
+
+/**
+ * UI message format expected by Elements Message component
+ */
+export interface UIMessage {
+  id: string;
+  role: "user" | "assistant";
+  parts: UIMessagePart[];
+  status: "submitted" | "streaming" | "ready" | "error";
+}
+
+/**
+ * UI status that Elements components use
+ */
+export type UIStatus = "submitted" | "streaming" | "ready" | "error";
+
+/**
+ * PromptInput component message format
+ */
+export interface PromptInputMessage {
+  text: string;
+}
+
+/**
+ * Tool parts extracted from current message for Tool component
+ */
+export interface ToolUIPart {
+  type: "tool-call" | "tool-result";
+  toolCallId: string;
+  toolName: string;
+  args?: unknown;
+  result?: unknown;
+  isError?: boolean;
+}
+
+/**
+ * Return type for useElementsAdapter hook
+ */
+export interface UseElementsAdapterReturn {
+  /**
+   * Messages formatted for Elements Message component
+   */
+  uiMessages: UIMessage[];
+
+  /**
+   * Current UI status for Elements components
+   */
+  uiStatus: UIStatus;
+
+  /**
+   * Tool parts from current message for Tool component
+   */
+  toolParts: ToolUIPart[];
+
+  /**
+   * Send a message (compatible with PromptInput onSubmit)
+   */
+  sendMessage: (message: PromptInputMessage) => Promise<void>;
+
+  /**
+   * Abort current streaming
+   */
+  abort: () => void;
+
+  /**
+   * Clear all messages
+   */
+  clear: () => void;
+}

package/src/adapters/elements/useElementsAdapter.ts

@@ -0,0 +1,261 @@
+/**
+ * React hook adapter for AI SDK Elements
+ *
+ * Provides Elements-compatible interface for deepagentsdk
+ */
+
+import { useState, useCallback, useRef, useMemo } from "react";
+import { createDeepAgent } from "../../agent.js";
+import type { LanguageModel, ToolSet } from "ai";
+import type {
+  BackendProtocol,
+  DeepAgentState,
+  DeepAgentEvent,
+} from "../../types.js";
+import {
+  convertEventsToUIMessages,
+  extractToolParts,
+} from "./messageAdapter.js";
+import { mapAgentStatusToUIStatus } from "./statusAdapter.js";
+import type { UseElementsAdapterReturn, PromptInputMessage } from "./types.js";
+import type { AgentStatus, AgentEventLog } from "../../cli/hooks/useAgent.js";
+
+/**
+ * Options for useElementsAdapter hook
+ */
+export interface UseElementsAdapterOptions {
+  /**
+   * Language model instance from AI SDK provider
+   */
+  model: LanguageModel;
+
+  /**
+   * Backend for state management
+   */
+  backend: BackendProtocol;
+
+  /**
+   * Optional tools to provide to the agent
+   */
+  tools?: ToolSet;
+
+  /**
+   * Maximum number of tool loop iterations
+   * @default 10
+   */
+  maxSteps?: number;
+
+  /**
+   * System prompt for the agent
+   */
+  systemPrompt?: string;
+}
+
+let eventCounter = 0;
+
+function createEventId(): string {
+  return `event-${++eventCounter}`;
+}
+
+/**
+ * Hook that adapts deepagentsdk to work with AI SDK Elements UI components
+ *
+ * @param options - Configuration options
+ * @returns Elements-compatible interface
+ *
+ * @example
+ * ```tsx
+ * import { useElementsAdapter } from 'deepagentsdk/elements';
+ * import { Conversation, Message, PromptInput } from '@/components/ai-elements';
+ *
+ * function Chat() {
+ *   const { uiMessages, sendMessage } = useElementsAdapter({
+ *     model,
+ *     backend
+ *   });
+ *
+ *   return (
+ *     <Conversation>
+ *       {uiMessages.map(msg => <Message key={msg.id} from={msg.role} />)}
+ *       <PromptInput onSubmit={sendMessage} />
+ *     </Conversation>
+ *   );
+ * }
+ * ```
+ */
+export function useElementsAdapter(
+  options: UseElementsAdapterOptions
+): UseElementsAdapterReturn {
+  const { model, backend, tools, maxSteps = 10, systemPrompt } = options;
+
+  const [status, setStatus] = useState<AgentStatus>("idle");
+  const [streamingText, setStreamingText] = useState("");
+  const [events, setEvents] = useState<AgentEventLog[]>([]);
+  const [state, setState] = useState<DeepAgentState>({
+    todos: [],
+    files: {},
+  });
+
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const accumulatedTextRef = useRef("");
+
+  // Create agent instance
+  const agentRef = useRef(
+    createDeepAgent({
+      model,
+      maxSteps,
+      systemPrompt,
+      backend,
+      tools,
+    })
+  );
+
+  const addEvent = useCallback(
+    (event: DeepAgentEvent | { type: "text-segment"; text: string }) => {
+      setEvents((prev) => [
+        ...prev,
+        {
+          id: createEventId(),
+          type: event.type,
+          event,
+          timestamp: new Date(),
+        },
+      ]);
+    },
+    []
+  );
+
+  // Flush accumulated text as a text-segment event
+  const flushTextSegment = useCallback(() => {
+    if (accumulatedTextRef.current.trim()) {
+      addEvent({
+        type: "text-segment",
+        text: accumulatedTextRef.current,
+      });
+      accumulatedTextRef.current = "";
+      setStreamingText("");
+    }
+  }, [addEvent]);
+
+  const sendMessage = async (message: PromptInputMessage): Promise<void> => {
+    if (!message.text.trim()) {
+      return; // Ignore empty messages
+    }
+
+    // Reset for new generation
+    setStatus("thinking");
+    setStreamingText("");
+    accumulatedTextRef.current = "";
+
+    // Add user message to events
+    addEvent({ type: "user-message", content: message.text });
+
+    // Create new abort controller
+    abortControllerRef.current = new AbortController();
+
+    try {
+      for await (const event of agentRef.current.streamWithEvents({
+        messages: [{ role: "user", content: message.text }],
+        state,
+        abortSignal: abortControllerRef.current.signal,
+      })) {
+        switch (event.type) {
+          case "text":
+            setStatus("streaming");
+            accumulatedTextRef.current += event.text;
+            setStreamingText(accumulatedTextRef.current);
+            break;
+
+          case "step-start":
+            if (event.stepNumber > 1) {
+              addEvent(event);
+            }
+            break;
+
+          case "tool-call":
+            flushTextSegment();
+            setStatus("tool-call");
+            addEvent(event);
+            break;
+
+          case "tool-result":
+            addEvent(event);
+            break;
+
+          case "todos-changed":
+            flushTextSegment();
+            setStatus("tool-call");
+            setState((prev) => ({ ...prev, todos: event.todos }));
+            addEvent(event);
+            break;
+
+          case "done":
+            flushTextSegment();
+            setStatus("done");
+            setState(event.state);
+            addEvent(event);
+            break;
+
+          case "error":
+            flushTextSegment();
+            setStatus("error");
+            addEvent(event);
+            break;
+
+          default:
+            addEvent(event);
+            break;
+        }
+      }
+
+      setStatus("idle");
+    } catch (err) {
+      if ((err as Error).name === "AbortError") {
+        flushTextSegment();
+        setStatus("idle");
+      } else {
+        flushTextSegment();
+        setStatus("error");
+      }
+    } finally {
+      abortControllerRef.current = null;
+    }
+  };
+
+  const abort = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      setStatus("idle");
+    }
+  }, []);
+
+  const clear = useCallback(() => {
+    setEvents([]);
+    setStreamingText("");
+    setStatus("idle");
+  }, []);
+
+  // Convert agent status to UI status
+  const uiStatus = useMemo(
+    () => mapAgentStatusToUIStatus(status),
+    [status]
+  );
+
+  // Convert events to UI messages
+  const uiMessages = useMemo(
+    () => convertEventsToUIMessages(events, streamingText, uiStatus),
+    [events, streamingText, uiStatus]
+  );
+
+  // Extract tool parts from current message
+  const toolParts = useMemo(() => extractToolParts(uiMessages), [uiMessages]);
+
+  return {
+    uiMessages,
+    uiStatus,
+    toolParts,
+    sendMessage,
+    abort,
+    clear,
+  };
+}

package/src/agent.ts

@@ -961,22 +961,50 @@ export class DeepAgent {
       // Yield step start event
       yield { type: "step-start", stepNumber: 1 };
 
-      // Stream text chunks
-      for await (const chunk of result.textStream) {
+      // Stream all chunks (text, tool calls, etc.)
+      for await (const chunk of result.fullStream) {
         // First, yield any queued events from tool executions
         while (eventQueue.length > 0) {
           const event = eventQueue.shift()!;
           yield event;
-          
+
           // If a step finished, yield the next step start
           if (event.type === "step-finish") {
             yield { type: "step-start", stepNumber: event.stepNumber + 1 };
           }
         }
 
-        // Then yield the text chunk
-        if (chunk) {
-          yield { type: "text", text: chunk };
+        // Handle different chunk types from fullStream
+        if (chunk.type === "text-delta") {
+          yield { type: "text", text: chunk.text };
+        } else if (chunk.type === "tool-call") {
+          // Emit tool-call event for UI
+          // Note: chunk has input property (AI SDK v6), but we use args for our event type
+          yield {
+            type: "tool-call",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            args: chunk.input,
+          } as DeepAgentEvent;
+        } else if (chunk.type === "tool-result") {
+          // Emit tool-result event for UI
+          // Note: chunk has output property (AI SDK v6), but we use result for our event type
+          yield {
+            type: "tool-result",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            result: chunk.output,
+            isError: false,
+          } as DeepAgentEvent;
+        } else if (chunk.type === "tool-error") {
+          // Emit tool-result event with error flag for UI
+          yield {
+            type: "tool-result",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            result: chunk.error,
+            isError: true,
+          } as DeepAgentEvent;
         }
       }
 

package/src/types/events.ts

@@ -54,6 +54,7 @@ export interface ToolResultEvent {
   toolName: string;
   toolCallId: string;
   result: unknown;
+  isError?: boolean;
 }
 
 /**