deepagentsdk 0.10.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepagentsdk",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "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": [
@@ -40,13 +44,13 @@
     "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": {

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";
+export type { UseElementsAdapterOptions } from "./useElementsAdapter";
+
+export { mapAgentStatusToUIStatus } from "./statusAdapter";
+export {
+  convertEventsToUIMessages,
+  extractToolParts,
+} from "./messageAdapter";
+
+export type {
+  UIMessage,
+  UIMessagePart,
+  UIStatus,
+  PromptInputMessage,
+  ToolUIPart,
+  UseElementsAdapterReturn,
+} from "./types";

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";
+import type { UIMessage, UIMessagePart, UIStatus } from "./types";
+
+/**
+ * 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";
+import type { UIStatus } from "./types";
+
+/**
+ * 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";
+import type { LanguageModel, ToolSet } from "ai";
+import type {
+  BackendProtocol,
+  DeepAgentState,
+  DeepAgentEvent,
+} from "../../types";
+import {
+  convertEventsToUIMessages,
+  extractToolParts,
+} from "./messageAdapter";
+import { mapAgentStatusToUIStatus } from "./statusAdapter";
+import type { UseElementsAdapterReturn, PromptInputMessage } from "./types";
+import type { AgentStatus, AgentEventLog } from "../../cli/hooks/useAgent";
+
+/**
+ * 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/backends/persistent.ts

@@ -13,7 +13,7 @@ import type {
   FileInfo,
   GrepMatch,
   WriteResult,
-} from "../types.js";
+} from "../types";
 import {
   createFileData,
   fileDataToString,
@@ -22,11 +22,11 @@ import {
   grepMatchesFromFiles,
   performStringReplacement,
   updateFileData,
-} from "./utils.js";
+} from "./utils";
 import {
   FILE_NOT_FOUND,
   FILE_ALREADY_EXISTS,
-} from "../constants/errors.js";
+} from "../constants/errors";
 
 /**
  * Generic key-value store interface for persistent storage.

package/src/cli/components/ApiKeyInput.tsx

@@ -5,7 +5,7 @@
 
 import React, { useState } from "react";
 import { Box, Text, useInput } from "ink";
-import { colors, emoji } from "../theme.js";
+import { colors, emoji } from "../theme";
 
 type Provider = "anthropic" | "openai";
 

package/src/cli/components/FilePreview.tsx

@@ -3,8 +3,8 @@
  */
 import React from "react";
 import { Box, Text } from "ink";
-import { emoji, colors } from "../theme.js";
-import type { FileInfo } from "../../types.js";
+import { emoji, colors } from "../theme";
+import type { FileInfo } from "../../types";
 
 interface FilePreviewProps {
   /** File path */

package/src/cli/components/Input.tsx

@@ -4,8 +4,8 @@
  */
 import React, { useState, useRef } from "react";
 import { Box, Text, useInput } from "ink";
-import { colors } from "../theme.js";
-import { SlashMenu } from "./SlashMenu.js";
+import { colors } from "../theme";
+import { SlashMenu } from "./SlashMenu";
 
 interface InputProps {
   /** Called when user submits input */

package/src/cli/components/Message.tsx

@@ -4,8 +4,8 @@
  */
 import React from "react";
 import { Box, Text } from "ink";
-import { colors } from "../theme.js";
-import { ToolCallSummary } from "./ToolCallSummary.js";
+import { colors } from "../theme";
+import { ToolCallSummary } from "./ToolCallSummary";
 
 export type MessageRole = "user" | "assistant";
 

package/src/cli/components/ModelSelection.tsx

@@ -5,12 +5,12 @@
 import React, { useState, useEffect, useMemo } from "react";
 import { Box, Text, useInput } from "ink";
 import { Spinner } from "@inkjs/ui";
-import { colors, emoji } from "../theme.js";
+import { colors, emoji } from "../theme";
 import {
   getModelsByProvider,
   detectAvailableProviders,
   type AvailableModel,
-} from "../utils/model-list.js";
+} from "../utils/model-list";
 
 interface ModelSelectionPanelProps {
   currentModel?: string;

package/src/cli/components/SlashMenu.tsx

@@ -3,7 +3,7 @@
  */
 import React from "react";
 import { Box, Text } from "ink";
-import { colors, filterCommands, type SlashCommand } from "../theme.js";
+import { colors, filterCommands, type SlashCommand } from "../theme";
 
 interface SlashMenuProps {
   /** Current input value to filter commands */

package/src/cli/components/StatusBar.tsx

@@ -4,7 +4,7 @@
  */
 import React from "react";
 import { Box, Text } from "ink";
-import { colors } from "../theme.js";
+import { colors } from "../theme";
 
 interface FeatureFlags {
   promptCaching: boolean;

package/src/cli/components/Subagent.tsx

@@ -4,7 +4,7 @@
 import React from "react";
 import { Box, Text } from "ink";
 import { Spinner, StatusMessage } from "@inkjs/ui";
-import { emoji, colors } from "../theme.js";
+import { emoji, colors } from "../theme";
 
 interface SubagentStartProps {
   /** Subagent name */

package/src/cli/components/TodoList.tsx

@@ -4,8 +4,8 @@
 import React from "react";
 import { Box, Text } from "ink";
 import { Badge } from "@inkjs/ui";
-import { emoji, colors } from "../theme.js";
-import type { TodoItem } from "../../types.js";
+import { emoji, colors } from "../theme";
+import type { TodoItem } from "../../types";
 
 interface TodoListProps {
   todos: TodoItem[];

package/src/cli/components/ToolCall.tsx

@@ -5,7 +5,7 @@
 import React from "react";
 import { Box, Text } from "ink";
 import { Spinner, StatusMessage } from "@inkjs/ui";
-import { colors } from "../theme.js";
+import { colors } from "../theme";
 
 interface ToolCallProps {
   /** Tool name being called */

package/src/cli/components/ToolCallSummary.tsx

@@ -4,8 +4,8 @@
  */
 import React, { useState } from "react";
 import { Box, Text, useInput } from "ink";
-import { colors, emoji } from "../theme.js";
-import type { ToolCallData } from "./Message.js";
+import { colors, emoji } from "../theme";
+import type { ToolCallData } from "./Message";
 
 interface ToolCallSummaryProps {
   /** Array of tool calls to display */

package/src/cli/components/Welcome.tsx

@@ -4,7 +4,7 @@
  */
 import React from "react";
 import { Box, Text } from "ink";
-import { colors } from "../theme.js";
+import { colors } from "../theme";
 
 interface WelcomeProps {
   /** Model name to display */

package/src/cli/components/index.ts

@@ -1,12 +1,12 @@
 /**
  * Export all CLI components.
  */
-export { Welcome, WelcomeHint } from "./Welcome.js";
-export { Input } from "./Input.js";
-export { SlashMenu, SlashMenuPanel } from "./SlashMenu.js";
-export { Message, StreamingMessage, type MessageData, type MessageRole, type ToolCallData } from "./Message.js";
-export { TodoList, TodosChanged } from "./TodoList.js";
-export { FilePreview, FileWritten, FileEdited, FileRead, LsResult, GlobResult, GrepResult, FileList } from "./FilePreview.js";
+export { Welcome, WelcomeHint } from "./Welcome";
+export { Input } from "./Input";
+export { SlashMenu, SlashMenuPanel } from "./SlashMenu";
+export { Message, StreamingMessage, type MessageData, type MessageRole, type ToolCallData } from "./Message";
+export { TodoList, TodosChanged } from "./TodoList";
+export { FilePreview, FileWritten, FileEdited, FileRead, LsResult, GlobResult, GrepResult, FileList } from "./FilePreview";
 export {
   ToolCall,
   ToolResult,
@@ -14,11 +14,11 @@ export {
   ThinkingIndicator,
   DoneIndicator,
   ErrorDisplay,
-} from "./ToolCall.js";
-export { SubagentStart, SubagentFinish, SubagentRunning } from "./Subagent.js";
-export { StatusBar } from "./StatusBar.js";
-export { ToolCallSummary, InlineToolCall } from "./ToolCallSummary.js";
-export { ModelSelectionPanel } from "./ModelSelection.js";
-export { ApiKeyInputPanel, ApiKeyStatus } from "./ApiKeyInput.js";
-export { ToolApproval } from "./ToolApproval.js";
+} from "./ToolCall";
+export { SubagentStart, SubagentFinish, SubagentRunning } from "./Subagent";
+export { StatusBar } from "./StatusBar";
+export { ToolCallSummary, InlineToolCall } from "./ToolCallSummary";
+export { ModelSelectionPanel } from "./ModelSelection";
+export { ApiKeyInputPanel, ApiKeyStatus } from "./ApiKeyInput";
+export { ToolApproval } from "./ToolApproval";
 

package/src/cli/hooks/index.ts

@@ -7,6 +7,6 @@ export {
   type UseAgentReturn,
   type AgentStatus,
   type AgentEventLog,
-} from "./useAgent.js";
+} from "./useAgent";
 
 

package/src/cli/hooks/useAgent.ts

@@ -9,12 +9,12 @@ import type {
   ModelMessage,
   SummarizationConfig,
   InterruptOnConfig,
-} from "../../types.js";
-import type { BaseCheckpointSaver } from "../../checkpointer/types.js";
-import { createDeepAgent } from "../../agent.js";
-import { parseModelString } from "../../utils/model-parser.js";
-import type { SandboxBackendProtocol } from "../../types.js";
-import type { ToolCallData } from "../components/Message.js";
+} from "../../types";
+import type { BaseCheckpointSaver } from "../../checkpointer/types";
+import { createDeepAgent } from "../../agent";
+import { parseModelString } from "../../utils/model-parser";
+import type { SandboxBackendProtocol } from "../../types";
+import type { ToolCallData } from "../components/Message";
 import { useEffect } from "react";
 
 export type AgentStatus =

package/src/cli/index.tsx

@@ -12,15 +12,15 @@
 
 import React, { useState, useEffect, useCallback } from "react";
 import { render, useApp, useInput, Box, Text, Static } from "ink";
-import { LocalSandbox } from "../backends/local-sandbox.js";
+import { LocalSandbox } from "../backends/local-sandbox";
 import {
   DEFAULT_EVICTION_TOKEN_LIMIT,
   DEFAULT_SUMMARIZATION_THRESHOLD,
   DEFAULT_KEEP_MESSAGES,
   CONTEXT_WINDOW,
 } from "../constants/limits";
-import { FileSaver } from "../checkpointer/file-saver.js";
-import { useAgent, type AgentEventLog } from "./hooks/useAgent.js";
+import { FileSaver } from "../checkpointer/file-saver";
+import { useAgent, type AgentEventLog } from "./hooks/useAgent";
 import {
   Welcome,
   WelcomeHint,
@@ -49,10 +49,10 @@ import {
   ApiKeyInputPanel,
   ToolApproval,
   type MessageData,
-} from "./components/index.js";
-import { parseCommand, colors, SLASH_COMMANDS } from "./theme.js";
-import type { FileInfo } from "../types.js";
-import { estimateMessagesTokens } from "../utils/summarization.js";
+} from "./components/index";
+import { parseCommand, colors, SLASH_COMMANDS } from "./theme";
+import type { FileInfo } from "../types";
+import { estimateMessagesTokens } from "../utils/summarization";
 
 // ============================================================================
 // CLI Arguments

package/src/middleware/agent-memory.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import os from 'node:os';
 import type { LanguageModelMiddleware } from 'ai';
-import { findGitRoot } from '../utils/project-detection.js';
+import { findGitRoot } from '../utils/project-detection';
 
 /**
  * Configuration options for agent memory middleware.

package/src/skills/load.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import os from "node:os";
 import type { SkillMetadata, SkillLoadOptions } from "./types";
-import { findGitRoot } from "../utils/project-detection.js";
+import { findGitRoot } from "../utils/project-detection";
 
 /**
  * Parse YAML frontmatter from a SKILL.md file.

package/src/types/backend.ts

@@ -2,7 +2,7 @@
  * Backend protocol and filesystem types.
  */
 
-import type { TodoItem } from "./core.js";
+import type { TodoItem } from "./core";
 
 /**
  * File data structure used by backends.

package/src/types/core.ts

@@ -10,9 +10,9 @@ import type {
   ToolLoopAgentSettings,
 } from "ai";
 import type { z } from "zod";
-import type { BaseCheckpointSaver } from "../checkpointer/types.js";
-import type { BackendProtocol, BackendFactory } from "./backend.js";
-import type { SubAgent, InterruptOnConfig } from "./subagent.js";
+import type { BaseCheckpointSaver } from "../checkpointer/types";
+import type { BackendProtocol, BackendFactory } from "./backend";
+import type { SubAgent, InterruptOnConfig } from "./subagent";
 
 // Re-export LanguageModel for convenience
 export type { LanguageModel };

package/src/types/events.ts

@@ -1,7 +1,7 @@
-import type { TodoItem } from "./core.js";
-import type { DeepAgentState } from "./backend.js";
+import type { TodoItem } from "./core";
+import type { DeepAgentState } from "./backend";
 import type { ModelMessage } from "ai";
-import type { ResumeOptions } from "../checkpointer/types.js";
+import type { ResumeOptions } from "../checkpointer/types";
 
 // ============================================================================
 // Event Types for Streaming
@@ -54,6 +54,7 @@ export interface ToolResultEvent {
   toolName: string;
   toolCallId: string;
   result: unknown;
+  isError?: boolean;
 }
 
 /**

package/src/types/index.ts

@@ -14,7 +14,7 @@ export type {
   AdvancedAgentOptions,
   SummarizationConfig,
   CreateDeepAgentParams,
-} from "./core.js";
+} from "./core";
 
 // Backend types
 export type {
@@ -28,9 +28,9 @@ export type {
   BackendFactory,
   ExecuteResponse,
   SandboxBackendProtocol,
-} from "./backend.js";
+} from "./backend";
 
-export { isSandboxBackend } from "./backend.js";
+export { isSandboxBackend } from "./backend";
 
 // Event types
 export type {
@@ -70,7 +70,7 @@ export type {
   EventCallback,
   ToolEventContext,
   StreamWithEventsOptions,
-} from "./events.js";
+} from "./events";
 
 // Subagent types
 export type {
@@ -79,16 +79,16 @@ export type {
   BuiltinToolCreator,
   SubagentToolConfig,
   SubAgent,
-} from "./subagent.js";
+} from "./subagent";
 
 // Structured output types
 export type {
   StructuredAgentResult,
-} from "./structured-output.js";
+} from "./structured-output";
 
 export {
   hasStructuredOutput,
   eventHasStructuredOutput,
   getStructuredOutput,
   getEventOutput,
-} from "./structured-output.js";
+} from "./structured-output";

package/src/types/subagent.ts

@@ -4,7 +4,7 @@
 
 import type { ToolSet, LanguageModel } from "ai";
 import type { z } from "zod";
-import type { GenerationOptions, AdvancedAgentOptions } from "./core.js";
+import type { GenerationOptions, AdvancedAgentOptions } from "./core";
 
 /**
  * Configuration for dynamic tool approval.

package/src/utils/eviction.ts

@@ -6,8 +6,8 @@
  * This prevents context overflow from large tool outputs.
  */
 
-import type { BackendProtocol, BackendFactory, DeepAgentState } from "../types.js";
-import { DEFAULT_EVICTION_TOKEN_LIMIT as CENTRALIZED_EVICTION_LIMIT } from "../constants/limits.js";
+import type { BackendProtocol, BackendFactory, DeepAgentState } from "../types";
+import { DEFAULT_EVICTION_TOKEN_LIMIT as CENTRALIZED_EVICTION_LIMIT } from "../constants/limits";
 
 /**
  * Default token limit before evicting a tool result.

package/src/utils/index.ts

@@ -2,7 +2,7 @@
  * Utility functions for AI SDK Deep Agent.
  */
 
-export { patchToolCalls, hasDanglingToolCalls } from "./patch-tool-calls.js";
+export { patchToolCalls, hasDanglingToolCalls } from "./patch-tool-calls";
 export {
   evictToolResult,
   createToolResultWrapper,
@@ -12,7 +12,7 @@ export {
   DEFAULT_EVICTION_TOKEN_LIMIT,
   type EvictOptions,
   type EvictResult,
-} from "./eviction.js";
+} from "./eviction";
 export {
   summarizeIfNeeded,
   needsSummarization,
@@ -21,14 +21,14 @@ export {
   DEFAULT_KEEP_MESSAGES,
   type SummarizationOptions,
   type SummarizationResult,
-} from "./summarization.js";
+} from "./summarization";
 export {
   parseModelString,
-} from "./model-parser.js";
+} from "./model-parser";
 export {
   applyInterruptConfig,
   wrapToolsWithApproval,
   hasApprovalTools,
   type ApprovalCallback,
-} from "./approval.js";
+} from "./approval";
 

package/src/utils/summarization.ts

@@ -6,12 +6,12 @@
  */
 
 import { generateText, type LanguageModel } from "ai";
-import type { ModelMessage } from "../types.js";
-import { estimateTokens } from "./eviction.js";
+import type { ModelMessage } from "../types";
+import { estimateTokens } from "./eviction";
 import {
   DEFAULT_SUMMARIZATION_THRESHOLD as CENTRALIZED_THRESHOLD,
   DEFAULT_KEEP_MESSAGES as CENTRALIZED_KEEP,
-} from "../constants/limits.js";
+} from "../constants/limits";
 
 /**
  * Default token threshold before triggering summarization.