@uix-ai/adapter-agui 0.0.1

package/README.md

@@ -0,0 +1,145 @@
+# @uix-ai/adapter-agui
+
+Adapter to convert [AG-UI protocol](https://docs.ag-ui.com) streaming events to UIX Lucid IR format.
+
+## Install
+
+```bash
+pnpm add @uix-ai/adapter-agui
+```
+
+Peer dependencies: `react`, `@uix-ai/core`
+
+## Quick Start
+
+### Using the `useAGUI` hook (recommended)
+
+```tsx
+import { AgentChat } from '@uix-ai/agent'
+import { useAGUI } from '@uix-ai/adapter-agui/react'
+
+function App() {
+  const { conversations, status, send, stop } = useAGUI({ url: '/api/agent' })
+
+  return (
+    <AgentChat
+      conversations={conversations}
+      status={status}
+      onSend={send}
+      onStop={stop}
+    />
+  )
+}
+```
+
+### `useAGUI` Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `url` | `string` | *required* | AG-UI agent endpoint URL |
+| `threadId` | `string` | auto-generated | Thread ID for conversation continuity |
+| `headers` | `Record<string, string>` | -- | Custom headers for SSE connection |
+| `processorOptions` | `AGUIProcessorOptions` | -- | Event processor configuration |
+| `autoConnect` | `boolean` | `false` | Connect on mount |
+| `onError` | `(error: Error) => void` | -- | Error callback |
+| `onFinish` | `() => void` | -- | Run finished callback |
+
+**Returns:** `{ conversations, status, send, stop, isLoading, reset, error }`
+
+### With thread persistence
+
+```tsx
+const { conversations, send } = useAGUI({
+  url: '/api/agent',
+  threadId: 'thread-abc-123',
+  headers: { Authorization: 'Bearer ...' },
+})
+```
+
+## Manual `AGUIEventProcessor` Usage
+
+For non-React use cases or custom event sources, use the stateful processor directly:
+
+```typescript
+import { AGUIEventProcessor } from '@uix-ai/adapter-agui'
+
+const processor = new AGUIEventProcessor({
+  onUpdate: (conversations) => {
+    // Called after each event is processed
+    renderUI(conversations)
+  },
+})
+
+// Feed events from any source
+eventSource.onmessage = (event) => {
+  processor.processEvent(JSON.parse(event.data))
+}
+
+// Read current state at any time
+const conversations = processor.getConversations()
+
+// Reset all state
+processor.reset()
+```
+
+### Batch conversion (stateless)
+
+For one-shot conversion of a complete event array:
+
+```typescript
+import { fromAGUIEvents } from '@uix-ai/adapter-agui'
+
+const conversations = fromAGUIEvents(events)
+```
+
+## Supported Event Types
+
+### Lifecycle Events
+
+| Event | Description |
+|-------|-------------|
+| `RunStarted` | Agent run begins (with `threadId`, `runId`) |
+| `RunFinished` | Agent run completes; all streaming messages marked completed |
+| `RunError` | Agent run failed; last assistant message marked as error |
+| `StepStarted` | Agent step begins |
+| `StepFinished` | Agent step completes |
+
+### Text Message Events
+
+| Event | Description |
+|-------|-------------|
+| `TextMessageStart` | New message created with role and ID |
+| `TextMessageContent` | Text delta appended to current message |
+| `TextMessageEnd` | Message streaming complete |
+
+### Tool Call Events
+
+| Event | Description |
+|-------|-------------|
+| `ToolCallStart` | Tool invocation begins (attached to parent message) |
+| `ToolCallArgs` | Streamed tool input argument deltas |
+| `ToolCallEnd` | Tool input complete |
+| `ToolCallResult` | Tool output received |
+
+### Reasoning Events
+
+| Event | Description |
+|-------|-------------|
+| `ReasoningMessageStart` | Thinking/reasoning block begins |
+| `ReasoningMessageContent` | Reasoning text delta |
+| `ReasoningMessageEnd` | Reasoning complete |
+
+### State Events
+
+| Event | Description |
+|-------|-------------|
+| `StateSnapshot` | Full state snapshot |
+| `StateDelta` | JSON Patch delta for state |
+| `MessagesSnapshot` | Full messages snapshot |
+
+State events (`StateSnapshot`, `StateDelta`, `MessagesSnapshot`) are received but do not produce blocks in the current implementation.
+
+## Links
+
+- [UIX Repository](https://github.com/Deepractice/UIX)
+- [AG-UI Protocol Documentation](https://docs.ag-ui.com)

package/dist/chunk-MI5X6OBV.js

@@ -0,0 +1,267 @@
+// src/index.ts
+var blockIdCounter = 0;
+function defaultGenerateBlockId() {
+  return `agui-block-${Date.now()}-${++blockIdCounter}`;
+}
+function mapRole(role) {
+  switch (role) {
+    case "user":
+      return "user";
+    case "system":
+    case "developer":
+      return "system";
+    case "assistant":
+    case "tool":
+    default:
+      return "assistant";
+  }
+}
+var AGUIEventProcessor = class {
+  constructor(options = {}) {
+    this.messages = /* @__PURE__ */ new Map();
+    this.messageOrder = [];
+    this.currentRunId = null;
+    this.generateId = options.generateBlockId ?? defaultGenerateBlockId;
+    this.onUpdate = options.onUpdate;
+  }
+  /**
+   * Process a single AG-UI event and update internal state
+   */
+  processEvent(event) {
+    switch (event.type) {
+      case "RunStarted":
+        this.handleRunStarted(event);
+        break;
+      case "RunFinished":
+        this.handleRunFinished(event);
+        break;
+      case "RunError":
+        this.handleRunError(event);
+        break;
+      case "TextMessageStart":
+        this.handleTextMessageStart(event);
+        break;
+      case "TextMessageContent":
+        this.handleTextMessageContent(event);
+        break;
+      case "TextMessageEnd":
+        this.handleTextMessageEnd(event);
+        break;
+      case "ToolCallStart":
+        this.handleToolCallStart(event);
+        break;
+      case "ToolCallArgs":
+        this.handleToolCallArgs(event);
+        break;
+      case "ToolCallEnd":
+        this.handleToolCallEnd(event);
+        break;
+      case "ToolCallResult":
+        this.handleToolCallResult(event);
+        break;
+      case "ReasoningMessageStart":
+        this.handleReasoningStart(event);
+        break;
+      case "ReasoningMessageContent":
+        this.handleReasoningContent(event);
+        break;
+      case "ReasoningMessageEnd":
+        this.handleReasoningEnd(event);
+        break;
+      default:
+        break;
+    }
+    this.onUpdate?.(this.getConversations());
+  }
+  /**
+   * Process multiple AG-UI events in order
+   */
+  processEvents(events) {
+    for (const event of events) {
+      this.processEvent(event);
+    }
+  }
+  /**
+   * Get the current state as UIX LucidConversations
+   */
+  getConversations() {
+    return this.messageOrder.map((msgId) => {
+      const state = this.messages.get(msgId);
+      return this.buildConversation(state);
+    });
+  }
+  /**
+   * Reset all state
+   */
+  reset() {
+    this.messages.clear();
+    this.messageOrder = [];
+    this.currentRunId = null;
+  }
+  // -- Lifecycle Handlers --
+  handleRunStarted(event) {
+    this.currentRunId = event.runId;
+  }
+  handleRunFinished(_event) {
+    for (const state of this.messages.values()) {
+      if (state.status === "streaming") {
+        state.status = "completed";
+      }
+    }
+    this.currentRunId = null;
+  }
+  handleRunError(event) {
+    const lastAssistant = this.findLastAssistantMessage();
+    if (lastAssistant) {
+      lastAssistant.status = "error";
+    }
+  }
+  // -- Text Message Handlers --
+  handleTextMessageStart(event) {
+    const blockId = this.generateId();
+    const state = {
+      conversationId: event.messageId,
+      role: mapRole(event.role),
+      textBlockId: blockId,
+      textContent: "",
+      thinkingBlockId: null,
+      thinkingContent: "",
+      toolBlocks: /* @__PURE__ */ new Map(),
+      status: "streaming",
+      timestamp: event.timestamp ?? Date.now()
+    };
+    this.messages.set(event.messageId, state);
+    this.messageOrder.push(event.messageId);
+  }
+  handleTextMessageContent(event) {
+    const state = this.messages.get(event.messageId);
+    if (!state) return;
+    state.textContent += event.delta;
+  }
+  handleTextMessageEnd(event) {
+    const state = this.messages.get(event.messageId);
+    if (!state) return;
+    state.status = "completed";
+  }
+  // -- Tool Call Handlers --
+  handleToolCallStart(event) {
+    const parentId = event.parentMessageId ?? this.findLastAssistantMessageId();
+    if (!parentId) return;
+    const state = this.messages.get(parentId);
+    if (!state) return;
+    state.toolBlocks.set(event.toolCallId, {
+      blockId: this.generateId(),
+      name: event.toolCallName,
+      argsJson: ""
+    });
+  }
+  handleToolCallArgs(event) {
+    const tool = this.findToolBlock(event.toolCallId);
+    if (!tool) return;
+    tool.argsJson += event.delta;
+  }
+  handleToolCallEnd(event) {
+  }
+  handleToolCallResult(event) {
+    const tool = this.findToolBlock(event.toolCallId);
+    if (!tool) return;
+    tool.output = event.content;
+    tool.hasResult = true;
+  }
+  // -- Reasoning Handlers --
+  handleReasoningStart(event) {
+    const state = this.messages.get(event.messageId);
+    if (!state) return;
+    state.thinkingBlockId = this.generateId();
+    state.thinkingContent = "";
+  }
+  handleReasoningContent(event) {
+    const state = this.messages.get(event.messageId);
+    if (!state) return;
+    state.thinkingContent += event.delta;
+  }
+  handleReasoningEnd(event) {
+  }
+  // -- Helpers --
+  findLastAssistantMessageId() {
+    for (let i = this.messageOrder.length - 1; i >= 0; i--) {
+      const id = this.messageOrder[i];
+      const state = this.messages.get(id);
+      if (state?.role === "assistant") return id;
+    }
+    return void 0;
+  }
+  findLastAssistantMessage() {
+    const id = this.findLastAssistantMessageId();
+    return id ? this.messages.get(id) : void 0;
+  }
+  findToolBlock(toolCallId) {
+    for (const state of this.messages.values()) {
+      const tool = state.toolBlocks.get(toolCallId);
+      if (tool) return tool;
+    }
+    return void 0;
+  }
+  buildConversation(state) {
+    const blocks = [];
+    if (state.thinkingBlockId && state.thinkingContent) {
+      blocks.push({
+        id: state.thinkingBlockId,
+        type: "thinking",
+        status: state.status === "streaming" ? "streaming" : "completed",
+        content: {
+          reasoning: state.thinkingContent
+        }
+      });
+    }
+    if (state.textBlockId && state.textContent) {
+      blocks.push({
+        id: state.textBlockId,
+        type: "text",
+        status: state.status === "streaming" ? "streaming" : "completed",
+        content: {
+          text: state.textContent
+        }
+      });
+    }
+    for (const [_toolCallId, tool] of state.toolBlocks) {
+      let input = {};
+      try {
+        input = tool.argsJson ? JSON.parse(tool.argsJson) : {};
+      } catch {
+        input = tool.argsJson;
+      }
+      const hasResult = tool.hasResult === true;
+      const toolStatus = hasResult ? "success" : "running";
+      blocks.push({
+        id: tool.blockId,
+        type: "tool",
+        status: hasResult ? "completed" : "streaming",
+        content: {
+          name: tool.name,
+          input,
+          output: tool.output,
+          status: toolStatus
+        }
+      });
+    }
+    return {
+      id: state.conversationId,
+      role: state.role,
+      status: state.status,
+      blocks,
+      timestamp: state.timestamp
+    };
+  }
+};
+function fromAGUIEvents(events, options = {}) {
+  const processor = new AGUIEventProcessor(options);
+  processor.processEvents(events);
+  return processor.getConversations();
+}
+
+export {
+  AGUIEventProcessor,
+  fromAGUIEvents
+};
+//# sourceMappingURL=chunk-MI5X6OBV.js.map

package/dist/chunk-MI5X6OBV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @uix-ai/adapter-agui\n *\n * Adapter to convert AG-UI protocol events to UIX Lucid IR format.\n *\n * AG-UI (Agent-User Interaction Protocol) is an open, event-based protocol\n * that standardizes how AI agent backends connect to frontend applications.\n *\n * This adapter converts AG-UI's streaming events into UIX LucidConversation\n * and LucidBlock structures for rendering with UIX components.\n *\n * @see https://docs.ag-ui.com\n *\n * @example\n * ```typescript\n * import { AGUIEventProcessor } from '@uix-ai/adapter-agui'\n * import { MessageList } from '@uix-ai/agent'\n *\n * function Chat() {\n *   const processor = new AGUIEventProcessor()\n *   // Feed AG-UI events from your agent backend\n *   processor.processEvent(event)\n *   const conversations = processor.getConversations()\n *\n *   return <MessageList conversations={conversations} />\n * }\n * ```\n */\n\nimport type {\n  LucidConversation,\n  LucidBlock,\n  ContentStatus,\n  ToolStatus,\n  TextBlockContent,\n  ToolBlockContent,\n  ThinkingBlockContent,\n} from '@uix-ai/core'\n\n// ============================================================================\n// AG-UI Protocol Event Types\n// ============================================================================\n\n/**\n * AG-UI base event interface\n */\nexport interface AGUIBaseEvent {\n  type: string\n  timestamp?: number\n  rawEvent?: unknown\n}\n\n// -- Lifecycle Events --\n\nexport interface AGUIRunStartedEvent extends AGUIBaseEvent {\n  type: 'RunStarted'\n  threadId: string\n  runId: string\n  parentRunId?: string\n  input?: unknown\n}\n\nexport interface AGUIRunFinishedEvent extends AGUIBaseEvent {\n  type: 'RunFinished'\n  threadId: string\n  runId: string\n  result?: unknown\n  outcome?: 'success' | 'interrupt'\n  interrupt?: unknown\n}\n\nexport interface AGUIRunErrorEvent extends AGUIBaseEvent {\n  type: 'RunError'\n  message: string\n  code?: string\n}\n\nexport interface AGUIStepStartedEvent extends AGUIBaseEvent {\n  type: 'StepStarted'\n  stepName: string\n}\n\nexport interface AGUIStepFinishedEvent extends AGUIBaseEvent {\n  type: 'StepFinished'\n  stepName: string\n}\n\n// -- Text Message Events --\n\nexport interface AGUITextMessageStartEvent extends AGUIBaseEvent {\n  type: 'TextMessageStart'\n  messageId: string\n  role: 'developer' | 'system' | 'assistant' | 'user' | 'tool'\n}\n\nexport interface AGUITextMessageContentEvent extends AGUIBaseEvent {\n  type: 'TextMessageContent'\n  messageId: string\n  delta: string\n}\n\nexport interface AGUITextMessageEndEvent extends AGUIBaseEvent {\n  type: 'TextMessageEnd'\n  messageId: string\n}\n\n// -- Tool Call Events --\n\nexport interface AGUIToolCallStartEvent extends AGUIBaseEvent {\n  type: 'ToolCallStart'\n  toolCallId: string\n  toolCallName: string\n  parentMessageId?: string\n}\n\nexport interface AGUIToolCallArgsEvent extends AGUIBaseEvent {\n  type: 'ToolCallArgs'\n  toolCallId: string\n  delta: string\n}\n\nexport interface AGUIToolCallEndEvent extends AGUIBaseEvent {\n  type: 'ToolCallEnd'\n  toolCallId: string\n}\n\nexport interface AGUIToolCallResultEvent extends AGUIBaseEvent {\n  type: 'ToolCallResult'\n  messageId: string\n  toolCallId: string\n  content: unknown\n  role?: 'tool'\n}\n\n// -- State Events --\n\nexport interface AGUIStateSnapshotEvent extends AGUIBaseEvent {\n  type: 'StateSnapshot'\n  snapshot: Record<string, unknown>\n}\n\nexport interface AGUIStateDeltaEvent extends AGUIBaseEvent {\n  type: 'StateDelta'\n  delta: Array<{\n    op: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test'\n    path: string\n    value?: unknown\n    from?: string\n  }>\n}\n\nexport interface AGUIMessagesSnapshotEvent extends AGUIBaseEvent {\n  type: 'MessagesSnapshot'\n  messages: unknown[]\n}\n\n// -- Reasoning Events --\n\nexport interface AGUIReasoningMessageStartEvent extends AGUIBaseEvent {\n  type: 'ReasoningMessageStart'\n  messageId: string\n  role: 'assistant'\n}\n\nexport interface AGUIReasoningMessageContentEvent extends AGUIBaseEvent {\n  type: 'ReasoningMessageContent'\n  messageId: string\n  delta: string\n}\n\nexport interface AGUIReasoningMessageEndEvent extends AGUIBaseEvent {\n  type: 'ReasoningMessageEnd'\n  messageId: string\n}\n\n/**\n * Union of all supported AG-UI event types\n */\nexport type AGUIEvent =\n  | AGUIRunStartedEvent\n  | AGUIRunFinishedEvent\n  | AGUIRunErrorEvent\n  | AGUIStepStartedEvent\n  | AGUIStepFinishedEvent\n  | AGUITextMessageStartEvent\n  | AGUITextMessageContentEvent\n  | AGUITextMessageEndEvent\n  | AGUIToolCallStartEvent\n  | AGUIToolCallArgsEvent\n  | AGUIToolCallEndEvent\n  | AGUIToolCallResultEvent\n  | AGUIStateSnapshotEvent\n  | AGUIStateDeltaEvent\n  | AGUIMessagesSnapshotEvent\n  | AGUIReasoningMessageStartEvent\n  | AGUIReasoningMessageContentEvent\n  | AGUIReasoningMessageEndEvent\n  | AGUIBaseEvent\n\n// ============================================================================\n// Processor Options\n// ============================================================================\n\nexport interface AGUIProcessorOptions {\n  /**\n   * Custom ID generator for blocks\n   * @default () => `block-${Date.now()}-${counter}`\n   */\n  generateBlockId?: () => string\n\n  /**\n   * Callback when conversations are updated\n   */\n  onUpdate?: (conversations: LucidConversation[]) => void\n}\n\n// ============================================================================\n// Internal State Types\n// ============================================================================\n\ninterface MessageState {\n  conversationId: string\n  role: 'user' | 'assistant' | 'system'\n  textBlockId: string | null\n  textContent: string\n  thinkingBlockId: string | null\n  thinkingContent: string\n  toolBlocks: Map<string, { blockId: string; name: string; argsJson: string }>\n  status: ContentStatus\n  timestamp: number\n}\n\n// ============================================================================\n// AG-UI Event Processor\n// ============================================================================\n\nlet blockIdCounter = 0\n\nfunction defaultGenerateBlockId(): string {\n  return `agui-block-${Date.now()}-${++blockIdCounter}`\n}\n\n/**\n * Map AG-UI role to UIX ConversationRole\n */\nfunction mapRole(role: string): 'user' | 'assistant' | 'system' {\n  switch (role) {\n    case 'user':\n      return 'user'\n    case 'system':\n    case 'developer':\n      return 'system'\n    case 'assistant':\n    case 'tool':\n    default:\n      return 'assistant'\n  }\n}\n\n/**\n * Stateful processor that converts AG-UI streaming events to UIX LucidConversations.\n *\n * AG-UI uses a streaming event model (start → content/delta → end) while UIX\n * uses a snapshot model (LucidConversation[]). This processor accumulates\n * events and maintains the current conversation state.\n *\n * @example\n * ```typescript\n * const processor = new AGUIEventProcessor({\n *   onUpdate: (conversations) => setConversations(conversations)\n * })\n *\n * // Connect to AG-UI event source\n * eventSource.onmessage = (event) => {\n *   processor.processEvent(JSON.parse(event.data))\n * }\n * ```\n */\nexport class AGUIEventProcessor {\n  private messages: Map<string, MessageState> = new Map()\n  private messageOrder: string[] = []\n  private generateId: () => string\n  private onUpdate?: (conversations: LucidConversation[]) => void\n  private currentRunId: string | null = null\n\n  constructor(options: AGUIProcessorOptions = {}) {\n    this.generateId = options.generateBlockId ?? defaultGenerateBlockId\n    this.onUpdate = options.onUpdate\n  }\n\n  /**\n   * Process a single AG-UI event and update internal state\n   */\n  processEvent(event: AGUIEvent): void {\n    switch (event.type) {\n      case 'RunStarted':\n        this.handleRunStarted(event as AGUIRunStartedEvent)\n        break\n      case 'RunFinished':\n        this.handleRunFinished(event as AGUIRunFinishedEvent)\n        break\n      case 'RunError':\n        this.handleRunError(event as AGUIRunErrorEvent)\n        break\n      case 'TextMessageStart':\n        this.handleTextMessageStart(event as AGUITextMessageStartEvent)\n        break\n      case 'TextMessageContent':\n        this.handleTextMessageContent(event as AGUITextMessageContentEvent)\n        break\n      case 'TextMessageEnd':\n        this.handleTextMessageEnd(event as AGUITextMessageEndEvent)\n        break\n      case 'ToolCallStart':\n        this.handleToolCallStart(event as AGUIToolCallStartEvent)\n        break\n      case 'ToolCallArgs':\n        this.handleToolCallArgs(event as AGUIToolCallArgsEvent)\n        break\n      case 'ToolCallEnd':\n        this.handleToolCallEnd(event as AGUIToolCallEndEvent)\n        break\n      case 'ToolCallResult':\n        this.handleToolCallResult(event as AGUIToolCallResultEvent)\n        break\n      case 'ReasoningMessageStart':\n        this.handleReasoningStart(event as AGUIReasoningMessageStartEvent)\n        break\n      case 'ReasoningMessageContent':\n        this.handleReasoningContent(event as AGUIReasoningMessageContentEvent)\n        break\n      case 'ReasoningMessageEnd':\n        this.handleReasoningEnd(event as AGUIReasoningMessageEndEvent)\n        break\n      default:\n        // Unknown events are silently ignored\n        break\n    }\n\n    this.onUpdate?.(this.getConversations())\n  }\n\n  /**\n   * Process multiple AG-UI events in order\n   */\n  processEvents(events: AGUIEvent[]): void {\n    for (const event of events) {\n      this.processEvent(event)\n    }\n  }\n\n  /**\n   * Get the current state as UIX LucidConversations\n   */\n  getConversations(): LucidConversation[] {\n    return this.messageOrder.map((msgId) => {\n      const state = this.messages.get(msgId)!\n      return this.buildConversation(state)\n    })\n  }\n\n  /**\n   * Reset all state\n   */\n  reset(): void {\n    this.messages.clear()\n    this.messageOrder = []\n    this.currentRunId = null\n  }\n\n  // -- Lifecycle Handlers --\n\n  private handleRunStarted(event: AGUIRunStartedEvent): void {\n    this.currentRunId = event.runId\n  }\n\n  private handleRunFinished(_event: AGUIRunFinishedEvent): void {\n    // Mark all streaming messages as completed\n    for (const state of this.messages.values()) {\n      if (state.status === 'streaming') {\n        state.status = 'completed'\n      }\n    }\n    this.currentRunId = null\n  }\n\n  private handleRunError(event: AGUIRunErrorEvent): void {\n    // Find the last assistant message or create an error conversation\n    const lastAssistant = this.findLastAssistantMessage()\n    if (lastAssistant) {\n      lastAssistant.status = 'error'\n    }\n  }\n\n  // -- Text Message Handlers --\n\n  private handleTextMessageStart(event: AGUITextMessageStartEvent): void {\n    const blockId = this.generateId()\n    const state: MessageState = {\n      conversationId: event.messageId,\n      role: mapRole(event.role),\n      textBlockId: blockId,\n      textContent: '',\n      thinkingBlockId: null,\n      thinkingContent: '',\n      toolBlocks: new Map(),\n      status: 'streaming',\n      timestamp: event.timestamp ?? Date.now(),\n    }\n    this.messages.set(event.messageId, state)\n    this.messageOrder.push(event.messageId)\n  }\n\n  private handleTextMessageContent(event: AGUITextMessageContentEvent): void {\n    const state = this.messages.get(event.messageId)\n    if (!state) return\n    state.textContent += event.delta\n  }\n\n  private handleTextMessageEnd(event: AGUITextMessageEndEvent): void {\n    const state = this.messages.get(event.messageId)\n    if (!state) return\n    state.status = 'completed'\n  }\n\n  // -- Tool Call Handlers --\n\n  private handleToolCallStart(event: AGUIToolCallStartEvent): void {\n    // Attach tool to parent message or last assistant message\n    const parentId = event.parentMessageId ?? this.findLastAssistantMessageId()\n    if (!parentId) return\n\n    const state = this.messages.get(parentId)\n    if (!state) return\n\n    state.toolBlocks.set(event.toolCallId, {\n      blockId: this.generateId(),\n      name: event.toolCallName,\n      argsJson: '',\n    })\n  }\n\n  private handleToolCallArgs(event: AGUIToolCallArgsEvent): void {\n    const tool = this.findToolBlock(event.toolCallId)\n    if (!tool) return\n    tool.argsJson += event.delta\n  }\n\n  private handleToolCallEnd(event: AGUIToolCallEndEvent): void {\n    // Tool input is complete, waiting for result\n    // No state change needed - tool status will update on result\n  }\n\n  private handleToolCallResult(event: AGUIToolCallResultEvent): void {\n    const tool = this.findToolBlock(event.toolCallId)\n    if (!tool) return\n    // Tool result is stored in the block content output\n    ;(tool as any).output = event.content\n    ;(tool as any).hasResult = true\n  }\n\n  // -- Reasoning Handlers --\n\n  private handleReasoningStart(event: AGUIReasoningMessageStartEvent): void {\n    const state = this.messages.get(event.messageId)\n    if (!state) return\n    state.thinkingBlockId = this.generateId()\n    state.thinkingContent = ''\n  }\n\n  private handleReasoningContent(event: AGUIReasoningMessageContentEvent): void {\n    const state = this.messages.get(event.messageId)\n    if (!state) return\n    state.thinkingContent += event.delta\n  }\n\n  private handleReasoningEnd(event: AGUIReasoningMessageEndEvent): void {\n    // Reasoning block is now complete, no explicit status change needed\n    // as the block status is derived from conversation status\n  }\n\n  // -- Helpers --\n\n  private findLastAssistantMessageId(): string | undefined {\n    for (let i = this.messageOrder.length - 1; i >= 0; i--) {\n      const id = this.messageOrder[i]\n      const state = this.messages.get(id)\n      if (state?.role === 'assistant') return id\n    }\n    return undefined\n  }\n\n  private findLastAssistantMessage(): MessageState | undefined {\n    const id = this.findLastAssistantMessageId()\n    return id ? this.messages.get(id) : undefined\n  }\n\n  private findToolBlock(\n    toolCallId: string\n  ): { blockId: string; name: string; argsJson: string; output?: unknown; hasResult?: boolean } | undefined {\n    for (const state of this.messages.values()) {\n      const tool = state.toolBlocks.get(toolCallId)\n      if (tool) return tool as any\n    }\n    return undefined\n  }\n\n  private buildConversation(state: MessageState): LucidConversation {\n    const blocks: LucidBlock[] = []\n\n    // Add thinking block first (if present)\n    if (state.thinkingBlockId && state.thinkingContent) {\n      blocks.push({\n        id: state.thinkingBlockId,\n        type: 'thinking',\n        status: state.status === 'streaming' ? 'streaming' : 'completed',\n        content: {\n          reasoning: state.thinkingContent,\n        } as ThinkingBlockContent,\n      })\n    }\n\n    // Add text block\n    if (state.textBlockId && state.textContent) {\n      blocks.push({\n        id: state.textBlockId,\n        type: 'text',\n        status: state.status === 'streaming' ? 'streaming' : 'completed',\n        content: {\n          text: state.textContent,\n        } as TextBlockContent,\n      })\n    }\n\n    // Add tool blocks\n    for (const [_toolCallId, tool] of state.toolBlocks) {\n      let input: unknown = {}\n      try {\n        input = tool.argsJson ? JSON.parse(tool.argsJson) : {}\n      } catch {\n        input = tool.argsJson\n      }\n\n      const hasResult = (tool as any).hasResult === true\n      const toolStatus: ToolStatus = hasResult ? 'success' : 'running'\n\n      blocks.push({\n        id: tool.blockId,\n        type: 'tool',\n        status: hasResult ? 'completed' : 'streaming',\n        content: {\n          name: tool.name,\n          input,\n          output: (tool as any).output,\n          status: toolStatus,\n        } as ToolBlockContent,\n      })\n    }\n\n    return {\n      id: state.conversationId,\n      role: state.role,\n      status: state.status,\n      blocks,\n      timestamp: state.timestamp,\n    }\n  }\n}\n\n// ============================================================================\n// Convenience Functions\n// ============================================================================\n\n/**\n * Convert a batch of AG-UI events to UIX LucidConversations (stateless)\n *\n * For streaming use cases, prefer AGUIEventProcessor which maintains state.\n *\n * @example\n * ```typescript\n * const conversations = fromAGUIEvents(events)\n * ```\n */\nexport function fromAGUIEvents(\n  events: AGUIEvent[],\n  options: AGUIProcessorOptions = {}\n): LucidConversation[] {\n  const processor = new AGUIEventProcessor(options)\n  processor.processEvents(events)\n  return processor.getConversations()\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,222 @@
+import { LucidConversation } from '@uix-ai/core';
+
+/**
+ * @uix-ai/adapter-agui
+ *
+ * Adapter to convert AG-UI protocol events to UIX Lucid IR format.
+ *
+ * AG-UI (Agent-User Interaction Protocol) is an open, event-based protocol
+ * that standardizes how AI agent backends connect to frontend applications.
+ *
+ * This adapter converts AG-UI's streaming events into UIX LucidConversation
+ * and LucidBlock structures for rendering with UIX components.
+ *
+ * @see https://docs.ag-ui.com
+ *
+ * @example
+ * ```typescript
+ * import { AGUIEventProcessor } from '@uix-ai/adapter-agui'
+ * import { MessageList } from '@uix-ai/agent'
+ *
+ * function Chat() {
+ *   const processor = new AGUIEventProcessor()
+ *   // Feed AG-UI events from your agent backend
+ *   processor.processEvent(event)
+ *   const conversations = processor.getConversations()
+ *
+ *   return <MessageList conversations={conversations} />
+ * }
+ * ```
+ */
+
+/**
+ * AG-UI base event interface
+ */
+interface AGUIBaseEvent {
+    type: string;
+    timestamp?: number;
+    rawEvent?: unknown;
+}
+interface AGUIRunStartedEvent extends AGUIBaseEvent {
+    type: 'RunStarted';
+    threadId: string;
+    runId: string;
+    parentRunId?: string;
+    input?: unknown;
+}
+interface AGUIRunFinishedEvent extends AGUIBaseEvent {
+    type: 'RunFinished';
+    threadId: string;
+    runId: string;
+    result?: unknown;
+    outcome?: 'success' | 'interrupt';
+    interrupt?: unknown;
+}
+interface AGUIRunErrorEvent extends AGUIBaseEvent {
+    type: 'RunError';
+    message: string;
+    code?: string;
+}
+interface AGUIStepStartedEvent extends AGUIBaseEvent {
+    type: 'StepStarted';
+    stepName: string;
+}
+interface AGUIStepFinishedEvent extends AGUIBaseEvent {
+    type: 'StepFinished';
+    stepName: string;
+}
+interface AGUITextMessageStartEvent extends AGUIBaseEvent {
+    type: 'TextMessageStart';
+    messageId: string;
+    role: 'developer' | 'system' | 'assistant' | 'user' | 'tool';
+}
+interface AGUITextMessageContentEvent extends AGUIBaseEvent {
+    type: 'TextMessageContent';
+    messageId: string;
+    delta: string;
+}
+interface AGUITextMessageEndEvent extends AGUIBaseEvent {
+    type: 'TextMessageEnd';
+    messageId: string;
+}
+interface AGUIToolCallStartEvent extends AGUIBaseEvent {
+    type: 'ToolCallStart';
+    toolCallId: string;
+    toolCallName: string;
+    parentMessageId?: string;
+}
+interface AGUIToolCallArgsEvent extends AGUIBaseEvent {
+    type: 'ToolCallArgs';
+    toolCallId: string;
+    delta: string;
+}
+interface AGUIToolCallEndEvent extends AGUIBaseEvent {
+    type: 'ToolCallEnd';
+    toolCallId: string;
+}
+interface AGUIToolCallResultEvent extends AGUIBaseEvent {
+    type: 'ToolCallResult';
+    messageId: string;
+    toolCallId: string;
+    content: unknown;
+    role?: 'tool';
+}
+interface AGUIStateSnapshotEvent extends AGUIBaseEvent {
+    type: 'StateSnapshot';
+    snapshot: Record<string, unknown>;
+}
+interface AGUIStateDeltaEvent extends AGUIBaseEvent {
+    type: 'StateDelta';
+    delta: Array<{
+        op: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
+        path: string;
+        value?: unknown;
+        from?: string;
+    }>;
+}
+interface AGUIMessagesSnapshotEvent extends AGUIBaseEvent {
+    type: 'MessagesSnapshot';
+    messages: unknown[];
+}
+interface AGUIReasoningMessageStartEvent extends AGUIBaseEvent {
+    type: 'ReasoningMessageStart';
+    messageId: string;
+    role: 'assistant';
+}
+interface AGUIReasoningMessageContentEvent extends AGUIBaseEvent {
+    type: 'ReasoningMessageContent';
+    messageId: string;
+    delta: string;
+}
+interface AGUIReasoningMessageEndEvent extends AGUIBaseEvent {
+    type: 'ReasoningMessageEnd';
+    messageId: string;
+}
+/**
+ * Union of all supported AG-UI event types
+ */
+type AGUIEvent = AGUIRunStartedEvent | AGUIRunFinishedEvent | AGUIRunErrorEvent | AGUIStepStartedEvent | AGUIStepFinishedEvent | AGUITextMessageStartEvent | AGUITextMessageContentEvent | AGUITextMessageEndEvent | AGUIToolCallStartEvent | AGUIToolCallArgsEvent | AGUIToolCallEndEvent | AGUIToolCallResultEvent | AGUIStateSnapshotEvent | AGUIStateDeltaEvent | AGUIMessagesSnapshotEvent | AGUIReasoningMessageStartEvent | AGUIReasoningMessageContentEvent | AGUIReasoningMessageEndEvent | AGUIBaseEvent;
+interface AGUIProcessorOptions {
+    /**
+     * Custom ID generator for blocks
+     * @default () => `block-${Date.now()}-${counter}`
+     */
+    generateBlockId?: () => string;
+    /**
+     * Callback when conversations are updated
+     */
+    onUpdate?: (conversations: LucidConversation[]) => void;
+}
+/**
+ * Stateful processor that converts AG-UI streaming events to UIX LucidConversations.
+ *
+ * AG-UI uses a streaming event model (start → content/delta → end) while UIX
+ * uses a snapshot model (LucidConversation[]). This processor accumulates
+ * events and maintains the current conversation state.
+ *
+ * @example
+ * ```typescript
+ * const processor = new AGUIEventProcessor({
+ *   onUpdate: (conversations) => setConversations(conversations)
+ * })
+ *
+ * // Connect to AG-UI event source
+ * eventSource.onmessage = (event) => {
+ *   processor.processEvent(JSON.parse(event.data))
+ * }
+ * ```
+ */
+declare class AGUIEventProcessor {
+    private messages;
+    private messageOrder;
+    private generateId;
+    private onUpdate?;
+    private currentRunId;
+    constructor(options?: AGUIProcessorOptions);
+    /**
+     * Process a single AG-UI event and update internal state
+     */
+    processEvent(event: AGUIEvent): void;
+    /**
+     * Process multiple AG-UI events in order
+     */
+    processEvents(events: AGUIEvent[]): void;
+    /**
+     * Get the current state as UIX LucidConversations
+     */
+    getConversations(): LucidConversation[];
+    /**
+     * Reset all state
+     */
+    reset(): void;
+    private handleRunStarted;
+    private handleRunFinished;
+    private handleRunError;
+    private handleTextMessageStart;
+    private handleTextMessageContent;
+    private handleTextMessageEnd;
+    private handleToolCallStart;
+    private handleToolCallArgs;
+    private handleToolCallEnd;
+    private handleToolCallResult;
+    private handleReasoningStart;
+    private handleReasoningContent;
+    private handleReasoningEnd;
+    private findLastAssistantMessageId;
+    private findLastAssistantMessage;
+    private findToolBlock;
+    private buildConversation;
+}
+/**
+ * Convert a batch of AG-UI events to UIX LucidConversations (stateless)
+ *
+ * For streaming use cases, prefer AGUIEventProcessor which maintains state.
+ *
+ * @example
+ * ```typescript
+ * const conversations = fromAGUIEvents(events)
+ * ```
+ */
+declare function fromAGUIEvents(events: AGUIEvent[], options?: AGUIProcessorOptions): LucidConversation[];
+
+export { type AGUIBaseEvent, type AGUIEvent, AGUIEventProcessor, type AGUIMessagesSnapshotEvent, type AGUIProcessorOptions, type AGUIReasoningMessageContentEvent, type AGUIReasoningMessageEndEvent, type AGUIReasoningMessageStartEvent, type AGUIRunErrorEvent, type AGUIRunFinishedEvent, type AGUIRunStartedEvent, type AGUIStateDeltaEvent, type AGUIStateSnapshotEvent, type AGUIStepFinishedEvent, type AGUIStepStartedEvent, type AGUITextMessageContentEvent, type AGUITextMessageEndEvent, type AGUITextMessageStartEvent, type AGUIToolCallArgsEvent, type AGUIToolCallEndEvent, type AGUIToolCallResultEvent, type AGUIToolCallStartEvent, fromAGUIEvents };

package/dist/index.js

@@ -0,0 +1,9 @@
+import {
+  AGUIEventProcessor,
+  fromAGUIEvents
+} from "./chunk-MI5X6OBV.js";
+export {
+  AGUIEventProcessor,
+  fromAGUIEvents
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/react/index.d.ts

@@ -0,0 +1,106 @@
+import { AGUIProcessorOptions } from '../index.js';
+import { LucidConversation } from '@uix-ai/core';
+
+/**
+ * @uix-ai/adapter-agui/react
+ *
+ * React hooks for connecting to AG-UI protocol agent backends
+ * and rendering with UIX components.
+ *
+ * @example 3 lines to a full chat UI
+ * ```tsx
+ * import { AgentChat } from '@uix-ai/agent'
+ * import { useAGUI } from '@uix-ai/adapter-agui/react'
+ *
+ * function App() {
+ *   const { conversations, status, send } = useAGUI({ url: '/api/agent' })
+ *   return <AgentChat conversations={conversations} status={status} onSend={send} />
+ * }
+ * ```
+ */
+
+interface UseAGUIOptions {
+    /**
+     * AG-UI agent endpoint URL.
+     * The hook will connect via SSE (Server-Sent Events).
+     */
+    url: string;
+    /**
+     * Thread ID for conversation continuity.
+     * @default auto-generated
+     */
+    threadId?: string;
+    /**
+     * Custom headers for the SSE connection.
+     */
+    headers?: Record<string, string>;
+    /**
+     * AG-UI event processor options.
+     */
+    processorOptions?: AGUIProcessorOptions;
+    /**
+     * Auto-connect on mount.
+     * @default false
+     */
+    autoConnect?: boolean;
+    /**
+     * Callback when an error occurs.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback when the run finishes.
+     */
+    onFinish?: () => void;
+}
+interface UseAGUIReturn {
+    /** UIX LucidConversation array, ready for <AgentChat> */
+    conversations: LucidConversation[];
+    /** Chat status mapped to ChatWindowStatus */
+    status: 'idle' | 'loading' | 'streaming' | 'error';
+    /** Send a user message to the agent */
+    send: (message: string) => void;
+    /** Stop the current stream */
+    stop: () => void;
+    /** Whether the agent is currently responding */
+    isLoading: boolean;
+    /** Reset the conversation */
+    reset: () => void;
+    /** Error if any */
+    error: Error | null;
+}
+/**
+ * Connect to an AG-UI protocol agent backend and get UIX-ready conversations.
+ *
+ * Handles SSE connection, event processing, and state management.
+ * Returns data directly compatible with <AgentChat>.
+ *
+ * @example Basic usage
+ * ```tsx
+ * function Chat() {
+ *   const { conversations, status, send, stop } = useAGUI({
+ *     url: 'https://my-agent.com/api/ag-ui',
+ *   })
+ *
+ *   return (
+ *     <AgentChat
+ *       conversations={conversations}
+ *       status={status}
+ *       onSend={send}
+ *       onStop={stop}
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example With thread persistence
+ * ```tsx
+ * const { conversations, send } = useAGUI({
+ *   url: '/api/agent',
+ *   threadId: 'thread-abc-123',
+ *   headers: { Authorization: 'Bearer ...' },
+ * })
+ * ```
+ */
+declare function useAGUI(options: UseAGUIOptions): UseAGUIReturn;
+
+export { type UseAGUIOptions, type UseAGUIReturn, useAGUI };

package/dist/react/index.js

@@ -0,0 +1,130 @@
+import {
+  AGUIEventProcessor
+} from "../chunk-MI5X6OBV.js";
+
+// src/react/index.ts
+import { useState, useCallback, useRef, useEffect } from "react";
+function useAGUI(options) {
+  const { url, threadId, headers, processorOptions, onError, onFinish } = options;
+  const [conversations, setConversations] = useState([]);
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const processorRef = useRef(
+    new AGUIEventProcessor({
+      ...processorOptions,
+      onUpdate: (convs) => setConversations([...convs])
+    })
+  );
+  const abortRef = useRef(null);
+  const threadIdRef = useRef(threadId ?? `thread-${Date.now()}`);
+  useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  const send = useCallback(
+    async (message) => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setStatus("loading");
+      setError(null);
+      const userConv = {
+        id: `user-${Date.now()}`,
+        role: "user",
+        status: "completed",
+        blocks: [
+          {
+            id: `block-${Date.now()}`,
+            type: "text",
+            status: "completed",
+            content: { text: message }
+          }
+        ],
+        timestamp: Date.now()
+      };
+      setConversations((prev) => [...prev, userConv]);
+      try {
+        const requestHeaders = {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...headers
+        };
+        const response = await fetch(url, {
+          method: "POST",
+          headers: requestHeaders,
+          body: JSON.stringify({
+            threadId: threadIdRef.current,
+            message
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`AG-UI request failed: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+          throw new Error("No response body for SSE stream");
+        }
+        setStatus("streaming");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") continue;
+              try {
+                const event = JSON.parse(data);
+                processorRef.current.processEvent(event);
+              } catch {
+              }
+            }
+          }
+        }
+        setStatus("idle");
+        onFinish?.();
+      } catch (err) {
+        if (err.name === "AbortError") {
+          setStatus("idle");
+          return;
+        }
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStatus("error");
+        onError?.(error2);
+      }
+    },
+    [url, headers, onError, onFinish]
+  );
+  const stop = useCallback(() => {
+    abortRef.current?.abort();
+    setStatus("idle");
+  }, []);
+  const reset = useCallback(() => {
+    abortRef.current?.abort();
+    processorRef.current.reset();
+    setConversations([]);
+    setStatus("idle");
+    setError(null);
+    threadIdRef.current = `thread-${Date.now()}`;
+  }, []);
+  return {
+    conversations,
+    status,
+    send,
+    stop,
+    isLoading: status === "loading" || status === "streaming",
+    reset,
+    error
+  };
+}
+export {
+  useAGUI
+};
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.ts"],"sourcesContent":["/**\n * @uix-ai/adapter-agui/react\n *\n * React hooks for connecting to AG-UI protocol agent backends\n * and rendering with UIX components.\n *\n * @example 3 lines to a full chat UI\n * ```tsx\n * import { AgentChat } from '@uix-ai/agent'\n * import { useAGUI } from '@uix-ai/adapter-agui/react'\n *\n * function App() {\n *   const { conversations, status, send } = useAGUI({ url: '/api/agent' })\n *   return <AgentChat conversations={conversations} status={status} onSend={send} />\n * }\n * ```\n */\n\nimport { useState, useCallback, useRef, useEffect } from 'react'\nimport { AGUIEventProcessor } from '../index'\nimport type { AGUIEvent, AGUIProcessorOptions } from '../index'\nimport type { LucidConversation } from '@uix-ai/core'\n\n// ============================================================================\n// useAGUI - Connect to AG-UI agent backend\n// ============================================================================\n\nexport interface UseAGUIOptions {\n  /**\n   * AG-UI agent endpoint URL.\n   * The hook will connect via SSE (Server-Sent Events).\n   */\n  url: string\n\n  /**\n   * Thread ID for conversation continuity.\n   * @default auto-generated\n   */\n  threadId?: string\n\n  /**\n   * Custom headers for the SSE connection.\n   */\n  headers?: Record<string, string>\n\n  /**\n   * AG-UI event processor options.\n   */\n  processorOptions?: AGUIProcessorOptions\n\n  /**\n   * Auto-connect on mount.\n   * @default false\n   */\n  autoConnect?: boolean\n\n  /**\n   * Callback when an error occurs.\n   */\n  onError?: (error: Error) => void\n\n  /**\n   * Callback when the run finishes.\n   */\n  onFinish?: () => void\n}\n\nexport interface UseAGUIReturn {\n  /** UIX LucidConversation array, ready for <AgentChat> */\n  conversations: LucidConversation[]\n  /** Chat status mapped to ChatWindowStatus */\n  status: 'idle' | 'loading' | 'streaming' | 'error'\n  /** Send a user message to the agent */\n  send: (message: string) => void\n  /** Stop the current stream */\n  stop: () => void\n  /** Whether the agent is currently responding */\n  isLoading: boolean\n  /** Reset the conversation */\n  reset: () => void\n  /** Error if any */\n  error: Error | null\n}\n\n/**\n * Connect to an AG-UI protocol agent backend and get UIX-ready conversations.\n *\n * Handles SSE connection, event processing, and state management.\n * Returns data directly compatible with <AgentChat>.\n *\n * @example Basic usage\n * ```tsx\n * function Chat() {\n *   const { conversations, status, send, stop } = useAGUI({\n *     url: 'https://my-agent.com/api/ag-ui',\n *   })\n *\n *   return (\n *     <AgentChat\n *       conversations={conversations}\n *       status={status}\n *       onSend={send}\n *       onStop={stop}\n *     />\n *   )\n * }\n * ```\n *\n * @example With thread persistence\n * ```tsx\n * const { conversations, send } = useAGUI({\n *   url: '/api/agent',\n *   threadId: 'thread-abc-123',\n *   headers: { Authorization: 'Bearer ...' },\n * })\n * ```\n */\nexport function useAGUI(options: UseAGUIOptions): UseAGUIReturn {\n  const { url, threadId, headers, processorOptions, onError, onFinish } = options\n\n  const [conversations, setConversations] = useState<LucidConversation[]>([])\n  const [status, setStatus] = useState<'idle' | 'loading' | 'streaming' | 'error'>('idle')\n  const [error, setError] = useState<Error | null>(null)\n\n  const processorRef = useRef<AGUIEventProcessor>(\n    new AGUIEventProcessor({\n      ...processorOptions,\n      onUpdate: (convs) => setConversations([...convs]),\n    })\n  )\n  const abortRef = useRef<AbortController | null>(null)\n  const threadIdRef = useRef(threadId ?? `thread-${Date.now()}`)\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      abortRef.current?.abort()\n    }\n  }, [])\n\n  const send = useCallback(\n    async (message: string) => {\n      // Abort any existing connection\n      abortRef.current?.abort()\n\n      const controller = new AbortController()\n      abortRef.current = controller\n\n      setStatus('loading')\n      setError(null)\n\n      // Add user message to conversations immediately\n      const userConv: LucidConversation = {\n        id: `user-${Date.now()}`,\n        role: 'user',\n        status: 'completed',\n        blocks: [\n          {\n            id: `block-${Date.now()}`,\n            type: 'text',\n            status: 'completed',\n            content: { text: message },\n          },\n        ],\n        timestamp: Date.now(),\n      }\n      setConversations((prev) => [...prev, userConv])\n\n      try {\n        const requestHeaders: Record<string, string> = {\n          'Content-Type': 'application/json',\n          Accept: 'text/event-stream',\n          ...headers,\n        }\n\n        const response = await fetch(url, {\n          method: 'POST',\n          headers: requestHeaders,\n          body: JSON.stringify({\n            threadId: threadIdRef.current,\n            message,\n          }),\n          signal: controller.signal,\n        })\n\n        if (!response.ok) {\n          throw new Error(`AG-UI request failed: ${response.status} ${response.statusText}`)\n        }\n\n        if (!response.body) {\n          throw new Error('No response body for SSE stream')\n        }\n\n        setStatus('streaming')\n\n        // Parse SSE stream\n        const reader = response.body.getReader()\n        const decoder = new TextDecoder()\n        let buffer = ''\n\n        while (true) {\n          const { done, value } = await reader.read()\n          if (done) break\n\n          buffer += decoder.decode(value, { stream: true })\n          const lines = buffer.split('\\n')\n          buffer = lines.pop() ?? ''\n\n          for (const line of lines) {\n            if (line.startsWith('data: ')) {\n              const data = line.slice(6).trim()\n              if (data === '[DONE]') continue\n\n              try {\n                const event: AGUIEvent = JSON.parse(data)\n                processorRef.current.processEvent(event)\n              } catch {\n                // Skip malformed events\n              }\n            }\n          }\n        }\n\n        setStatus('idle')\n        onFinish?.()\n      } catch (err) {\n        if ((err as Error).name === 'AbortError') {\n          setStatus('idle')\n          return\n        }\n\n        const error = err instanceof Error ? err : new Error(String(err))\n        setError(error)\n        setStatus('error')\n        onError?.(error)\n      }\n    },\n    [url, headers, onError, onFinish]\n  )\n\n  const stop = useCallback(() => {\n    abortRef.current?.abort()\n    setStatus('idle')\n  }, [])\n\n  const reset = useCallback(() => {\n    abortRef.current?.abort()\n    processorRef.current.reset()\n    setConversations([])\n    setStatus('idle')\n    setError(null)\n    threadIdRef.current = `thread-${Date.now()}`\n  }, [])\n\n  return {\n    conversations,\n    status,\n    send,\n    stop,\n    isLoading: status === 'loading' || status === 'streaming',\n    reset,\n    error,\n  }\n}\n"],"mappings":"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","names":["error"]}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@uix-ai/adapter-agui",
+  "version": "0.0.1",
+  "description": "Adapter to convert AG-UI protocol events to UIX Lucid IR format",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@uix-ai/core": "workspace:*"
+  },
+  "peerDependencies": {
+    "@ag-ui/core": ">=0.0.1",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@ag-ui/core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "uix",
+    "ag-ui",
+    "agent-ui",
+    "adapter",
+    "protocol",
+    "converter"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Deepractice/UIX.git",
+    "directory": "packages/adapter-agui"
+  }
+}