deepagentsdk 0.12.0 → 0.14.0

package/dist/adapters/elements/index.d.mts

@@ -1,212 +1,147 @@
-import { _t as BackendProtocol, d as DeepAgentEvent } from "../../types-4g9UvXal.mjs";
-import { LanguageModel, ToolSet } from "ai";
-import "react";
+import { p as DeepAgentEvent, r as ModelMessage$1, t as DeepAgent, yt as DeepAgentState } from "../../agent-D0bKkNI-.mjs";
+import { UIMessage, UIMessage as UIMessage$1, UIMessagePart } from "ai";
 
-//#region src/adapters/elements/types.d.ts
+//#region src/adapters/elements/createElementsRouteHandler.d.ts
 
 /**
- * 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
+ * Options for creating an Elements route handler
  */
-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
- */
-interface UIMessage {
-  id: string;
-  role: "user" | "assistant";
-  parts: UIMessagePart[];
-  status: "submitted" | "streaming" | "ready" | "error";
-}
-/**
- * UI status that Elements components use
- */
-type UIStatus = "submitted" | "streaming" | "ready" | "error";
-/**
- * PromptInput component message format
- */
-interface PromptInputMessage {
-  text: string;
-}
-/**
- * Tool parts extracted from current message for Tool component
- */
-interface ToolUIPart {
-  type: "tool-call" | "tool-result";
-  toolCallId: string;
-  toolName: string;
-  args?: unknown;
-  result?: unknown;
-  isError?: boolean;
-}
-/**
- * Return type for useElementsAdapter hook
- */
-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>;
+interface CreateElementsRouteHandlerOptions {
   /**
-   * Abort current streaming
+   * The DeepAgent instance to use for handling requests
    */
-  abort: () => void;
+  agent: DeepAgent;
   /**
-   * Clear all messages
+   * Optional callback before processing a request.
+   * Use for authentication, logging, rate limiting, etc.
+   *
+   * @example
+   * ```typescript
+   * onRequest: async (req) => {
+   *   const token = req.headers.get('Authorization');
+   *   if (!validateToken(token)) {
+   *     throw new Error('Unauthorized');
+   *   }
+   * }
+   * ```
    */
-  clear: () => void;
-}
-//#endregion
-//#region src/adapters/elements/useElementsAdapter.d.ts
-/**
- * Options for useElementsAdapter hook
- */
-interface UseElementsAdapterOptions {
+  onRequest?: (req: Request) => Promise<void> | void;
   /**
-   * Language model instance from AI SDK provider
+   * Optional initial state to provide to the agent.
+   * If not provided, uses empty state { todos: [], files: {} }
    */
-  model: LanguageModel;
+  initialState?: DeepAgentState;
   /**
-   * Backend for state management
+   * Optional thread ID for checkpointing.
+   * If provided, enables conversation persistence.
    */
-  backend: BackendProtocol;
+  threadId?: string;
   /**
-   * Optional tools to provide to the agent
-   */
-  tools?: ToolSet;
-  /**
-   * Maximum number of tool loop iterations
-   * @default 10
+   * Optional maximum number of steps for the agent loop.
    */
   maxSteps?: number;
   /**
-   * System prompt for the agent
+   * Custom ID generator for message IDs.
+   * Defaults to crypto.randomUUID if available.
    */
-  systemPrompt?: string;
+  generateId?: () => string;
 }
 /**
- * Hook that adapts deepagentsdk to work with AI SDK Elements UI components
+ * Creates a route handler that processes chat requests using DeepAgent
+ * and streams all 26+ event types in UI Message Stream Protocol format.
+ *
+ * The returned handler:
+ * - Accepts POST requests with { messages: UIMessage[] } body
+ * - Runs DeepAgent with the conversation history
+ * - Streams responses in UI Message Stream Protocol format
+ * - Works with useChat hook from @ai-sdk/react
+ * - Provides full visibility into agent behavior (file ops, web requests, subagents, etc.)
  *
  * @param options - Configuration options
- * @returns Elements-compatible interface
+ * @returns A request handler function compatible with Next.js/Express
+ */
+declare function createElementsRouteHandler(options: CreateElementsRouteHandlerOptions): (req: Request) => Promise<Response>;
+/**
+ * Maps a DeepAgent event to a UI Message Stream Protocol event.
  *
- * @example
- * ```tsx
- * import { useElementsAdapter } from 'deepagentsdk/elements';
- * import { Conversation, Message, PromptInput } from '@/components/ai-elements';
+ * This function handles all 26+ DeepAgent event types, mapping:
+ * - Standard protocol events (text, tools, steps, errors)
+ * - Custom data events (file operations, web requests, subagents, execution)
  *
- * function Chat() {
- *   const { uiMessages, sendMessage } = useElementsAdapter({
- *     model,
- *     backend
- *   });
+ * @param event - The DeepAgent event to map
+ * @param writer - The UI message stream writer
+ * @param genId - ID generator function
+ * @param currentTextId - The current text part ID (for tracking streaming text)
+ * @returns The new currentTextId value (string | null)
  *
- *   return (
- *     <Conversation>
- *       {uiMessages.map(msg => <Message key={msg.id} from={msg.role} />)}
- *       <PromptInput onSubmit={sendMessage} />
- *     </Conversation>
- *   );
- * }
+ * @example
+ * ```typescript
+ * // Handles text streaming with proper ID tracking
+ * let textId: string | null = null;
+ * textId = mapEventToProtocol({ type: 'text', text: 'Hello' }, writer, genId, textId);
+ * // textId is now the ID of the active text part
  * ```
  */
-declare function useElementsAdapter(options: UseElementsAdapterOptions): UseElementsAdapterReturn;
-//#endregion
-//#region src/cli/hooks/useAgent.d.ts
-type AgentStatus = "idle" | "thinking" | "streaming" | "tool-call" | "subagent" | "done" | "error";
-interface AgentEventLog {
-  id: string;
-  type: DeepAgentEvent["type"] | "text-segment";
-  event: DeepAgentEvent | {
-    type: "text-segment";
-    text: string;
-  };
-  timestamp: Date;
-}
+declare function mapEventToProtocol(event: DeepAgentEvent, writer: {
+  write: (chunk: any) => void;
+}, genId: () => string, currentTextId: string | null): string | null;
+/**
+ * Type for the request handler returned by createElementsRouteHandler
+ */
+type ElementsRouteHandler = (req: Request) => Promise<Response>;
 //#endregion
-//#region src/adapters/elements/statusAdapter.d.ts
+//#region src/adapters/elements/messageConverters.d.ts
 /**
- * Maps deepagentsdk AgentStatus to Elements UIStatus
+ * Re-export AI SDK's convertToModelMessages for convenience.
+ *
+ * This function converts UIMessage[] (from useChat) to ModelMessage[]
+ * (for agent consumption), handling:
+ * - Role mapping (user/assistant)
+ * - Tool call/result parts
+ * - Text content extraction
  *
- * @param agentStatus - The agent status from useAgent hook
- * @returns The corresponding UI status for Elements components
+ * @example
+ * ```typescript
+ * import { convertUIMessagesToModelMessages } from 'deepagentsdk/adapters/elements';
  *
- * 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)
+ * const modelMessages = await convertUIMessagesToModelMessages(uiMessages);
+ * ```
  */
-declare function mapAgentStatusToUIStatus(agentStatus: AgentStatus): UIStatus;
-//#endregion
-//#region src/adapters/elements/messageAdapter.d.ts
+declare function convertUIMessagesToModelMessages(messages: UIMessage$1[]): Promise<ModelMessage$1[]>;
 /**
- * Converts agent event log to UIMessage format expected by Elements
+ * Extract the last user message text from a UIMessage array.
+ * Useful for extracting the prompt from a conversation.
  *
- * @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
+ * @param messages - Array of UI messages
+ * @returns The text content of the last user message, or undefined if none
+ */
+declare function extractLastUserMessage(messages: UIMessage$1[]): string | undefined;
+/**
+ * Check if the messages contain any tool parts.
+ * This is a simplified helper that checks for any tool-related parts.
+ *
+ * @param messages - Array of UI messages
+ * @returns True if there are any tool-related parts in the messages
+ */
+declare function hasToolParts(messages: UIMessage$1[]): boolean;
+/**
+ * Count the number of messages by role.
  *
- * 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
+ * @param messages - Array of UI messages
+ * @returns Object with counts by role
  */
-declare function convertEventsToUIMessages(events: AgentEventLog[], streamingText: string, uiStatus: UIStatus): UIMessage[];
+declare function countMessagesByRole(messages: UIMessage$1[]): {
+  user: number;
+  assistant: number;
+  system: number;
+};
 /**
- * Extracts tool parts from the most recent assistant message
+ * Extract all text content from a message.
  *
- * @param messages - UIMessage array
- * @returns Array of tool parts (tool-call and tool-result)
+ * @param message - A UI message
+ * @returns Combined text from all text parts
  */
-declare function extractToolParts(messages: UIMessage[]): ({
-  type: "tool-call";
-  toolCallId: string;
-  toolName: string;
-  args: unknown;
-  result?: undefined;
-  isError?: undefined;
-} | {
-  type: "tool-result";
-  toolCallId: string;
-  toolName: string;
-  result: unknown;
-  isError: boolean | undefined;
-  args?: undefined;
-})[];
+declare function extractTextFromMessage(message: UIMessage$1): string;
 //#endregion
-export { type PromptInputMessage, type ToolUIPart, type UIMessage, type UIMessagePart, type UIStatus, type UseElementsAdapterOptions, type UseElementsAdapterReturn, convertEventsToUIMessages, extractToolParts, mapAgentStatusToUIStatus, useElementsAdapter };
+export { type CreateElementsRouteHandlerOptions, type ElementsRouteHandler, type UIMessage, type UIMessagePart, convertUIMessagesToModelMessages, countMessagesByRole, createElementsRouteHandler, extractLastUserMessage, extractTextFromMessage, hasToolParts, mapEventToProtocol };
 //# sourceMappingURL=index.d.mts.map