@cloudbase/agent-adapter-llm 0.0.22

package/README.md

@@ -0,0 +1,154 @@
+# @cloudbase/agent-adapter-llm
+
+Direct LLM adapter for AG-Kit agents with support for OpenAI and Anthropic models.
+
+## Features
+
+- ✅ Direct OpenAI and Anthropic model integration
+- ✅ Automatic streaming message conversion to AGUI events
+- ✅ Support for tool calls (function calling)
+- ✅ Type-safe with TypeScript
+- ✅ Observable-based event streaming
+- ✅ No additional abstraction layers
+
+## Installation
+
+```bash
+npm install @cloudbase/agent-adapter-llm openai @anthropic-ai/sdk
+```
+
+## Quick Start
+
+### With OpenAI
+
+```typescript
+import OpenAI from 'openai';
+import { LLMAgent } from '@cloudbase/agent-adapter-llm';
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY
+});
+
+const agent = new LLMAgent({
+  agentId: 'my-agent',
+  model: openai,
+  modelName: 'gpt-4o-mini',
+  systemPrompt: 'You are a helpful assistant.',
+  temperature: 0.7,
+  maxTokens: 2000
+});
+
+const observable = agent.run({
+  messages: [
+    { id: 'msg_1', role: 'user', content: 'Hello!' }
+  ],
+  runId: 'run_123',
+  threadId: 'thread_456',
+  tools: []
+});
+
+observable.subscribe({
+  next: (event) => {
+    console.log('Event:', event);
+  }
+});
+```
+
+### With Anthropic
+
+```typescript
+import Anthropic from '@anthropic-ai/sdk';
+import { LLMAgent } from '@cloudbase/agent-adapter-llm';
+
+const anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY
+});
+
+const agent = new LLMAgent({
+  agentId: 'my-agent',
+  model: anthropic,
+  modelName: 'claude-3-5-sonnet-20241022',
+  systemPrompt: 'You are a helpful assistant.',
+  temperature: 0.7,
+  maxTokens: 2000
+});
+```
+
+## AGUI Events
+
+The agent emits the following AGUI protocol events:
+
+- `RUN_STARTED` - Run has started
+- `TEXT_MESSAGE_START` - Text message streaming started
+- `TEXT_MESSAGE_CONTENT` - Text content delta
+- `TEXT_MESSAGE_END` - Text message streaming ended
+- `TOOL_CALL_START` - Tool call started
+- `TOOL_CALL_ARGS` - Tool call arguments delta
+- `TOOL_CALL_END` - Tool call ended
+- `RUN_FINISHED` - Run completed successfully
+- `RUN_ERROR` - Run encountered an error
+
+## Configuration
+
+### LLMAgentConfig
+
+```typescript
+interface LLMAgentConfig {
+  agentId: string;           // Unique agent identifier
+  name?: string;             // Agent name
+  description?: string;      // Agent description
+  model: OpenAI | Anthropic; // Model provider instance
+  modelName: string;         // Model name (e.g., 'gpt-4o-mini', 'claude-3-5-sonnet-20241022')
+  systemPrompt?: string;     // System prompt
+  temperature?: number;      // Temperature (0-2)
+  maxTokens?: number;        // Max tokens to generate
+  threadId?: string;         // Thread ID
+}
+```
+
+## Streaming Example
+
+```typescript
+import { EventType } from '@ag-ui/client';
+
+observable.subscribe({
+  next: (event) => {
+    switch (event.type) {
+      case EventType.TEXT_MESSAGE_CONTENT:
+        process.stdout.write(event.delta);
+        break;
+      case EventType.TOOL_CALL_START:
+        console.log(`\nTool: ${event.toolCallName}`);
+        break;
+      case EventType.RUN_FINISHED:
+        console.log('\nDone!');
+        break;
+    }
+  }
+});
+```
+
+## Tool Calling
+
+```typescript
+const tools = [
+  {
+    name: 'get_weather',
+    description: 'Get the current weather',
+    parameters: JSON.stringify({
+      type: 'object',
+      properties: {
+        location: { type: 'string' }
+      },
+      required: ['location']
+    })
+  }
+];
+
+agent.run({ messages, runId, threadId, tools });
+```
+
+## License
+
+MIT
+

package/dist/index.d.mts

@@ -0,0 +1,298 @@
+import { AbstractAgent, RunAgentInput, BaseEvent, Message, Tool, EventType } from '@ag-ui/client';
+import { Observable } from 'rxjs';
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+
+/**
+ * LLMAgent - Direct LLM integration with AGUI protocol
+ * Supports OpenAI and Anthropic models with streaming message conversion
+ */
+
+type ModelProvider = OpenAI | Anthropic;
+interface LLMAgentConfig {
+    agentId?: string;
+    name?: string;
+    description?: string;
+    threadId?: string;
+    model: ModelProvider;
+    modelName: string;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+    maxToolRounds?: number;
+    onToolCall?: (toolCall: {
+        id: string;
+        name: string;
+        arguments: string;
+    }) => void;
+    onToolResult?: (result: {
+        toolCallId: string;
+        result: any;
+        error?: string;
+    }) => void;
+}
+/**
+ * LLMAgent - Direct model integration with AGUI protocol
+ *
+ * Example:
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { LLMAgent } from '@cloudbase/agent-adapter-llm';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ * const agent = new LLMAgent({
+ *   agentId: 'my-agent',
+ *   model: openai,
+ *   modelName: 'gpt-4o-mini',
+ *   systemPrompt: 'You are a helpful assistant.'
+ * });
+ * ```
+ */
+declare class LLMAgent extends AbstractAgent {
+    private model;
+    private modelType;
+    private modelName;
+    private systemPrompt?;
+    private temperature?;
+    private maxTokens?;
+    private maxToolRounds;
+    private onToolCall?;
+    private onToolResult?;
+    name: string;
+    constructor(config: LLMAgentConfig);
+    run(input: RunAgentInput): Observable<BaseEvent>;
+    private _run;
+    private runOpenAI;
+    private runAnthropic;
+    /**
+     * Run model once (single round, no tool execution)
+     */
+    private runOnce;
+    /**
+     * Execute tools
+     */
+    private executeTools;
+    /**
+     * Execute tool function
+     */
+    private executeToolFunction;
+    /**
+     * Convert tool results to messages
+     */
+    private toolResultsToMessages;
+    /**
+     * Extract text content from events
+     */
+    private extractTextFromEvents;
+}
+
+/**
+ * OpenAI Converter - AGUI Protocol to OpenAI Format
+ */
+
+/**
+ * Convert AGUI messages to OpenAI chat completion format
+ */
+declare function convertMessagesToOpenAI(messages: Message[], systemPrompt?: string): OpenAI.Chat.ChatCompletionMessageParam[];
+/**
+ * Convert AGUI tools to OpenAI function calling format
+ */
+declare function convertToolsToOpenAI(tools?: Tool[]): OpenAI.Chat.ChatCompletionTool[] | undefined;
+/**
+ * Create OpenAI streaming request options
+ */
+declare function createOpenAIStreamOptions(config: {
+    modelName: string;
+    messages: OpenAI.Chat.ChatCompletionMessageParam[];
+    tools?: OpenAI.Chat.ChatCompletionTool[];
+    temperature?: number;
+    maxTokens?: number;
+    user?: string;
+}): OpenAI.Chat.ChatCompletionCreateParamsStreaming;
+
+/**
+ * Anthropic Converter - AGUI Protocol to Anthropic Format
+ */
+
+/**
+ * Convert AGUI messages to Anthropic message format
+ */
+declare function convertMessagesToAnthropic(messages: Message[]): Anthropic.MessageParam[];
+/**
+ * Convert AGUI tools to Anthropic tools format
+ */
+declare function convertToolsToAnthropic(tools?: Tool[]): Anthropic.Tool[] | undefined;
+/**
+ * Create Anthropic streaming request options
+ */
+declare function createAnthropicStreamOptions(config: {
+    modelName: string;
+    messages: Anthropic.MessageParam[];
+    tools?: Anthropic.Tool[];
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+}): Anthropic.MessageCreateParamsStreaming;
+
+/**
+ * OpenAI Stream Processor - Convert OpenAI streaming responses to AGUI events
+ */
+
+interface StreamContext$1 {
+    threadId: string;
+    runId: string;
+    messageId: string;
+}
+/**
+ * Process OpenAI streaming chunk and emit AGUI events
+ */
+declare function processOpenAIStream(stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>, context: StreamContext$1): AsyncGenerator<{
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: any;
+    content?: undefined;
+    messageId?: undefined;
+    role?: undefined;
+    delta?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: any;
+    content: string;
+    messageId?: undefined;
+    role?: undefined;
+    delta?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId: string;
+    toolCallId?: undefined;
+    content?: undefined;
+    role?: undefined;
+    delta?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId: string;
+    role: string;
+    toolCallId?: undefined;
+    content?: undefined;
+    delta?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId: string;
+    delta: string;
+    toolCallId?: undefined;
+    content?: undefined;
+    role?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: string;
+    toolCallName: string;
+    content?: undefined;
+    messageId?: undefined;
+    role?: undefined;
+    delta?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: string;
+    delta: string;
+    content?: undefined;
+    messageId?: undefined;
+    role?: undefined;
+    toolCallName?: undefined;
+}, void, unknown>;
+
+/**
+ * Anthropic Stream Processor - Convert Anthropic streaming responses to AGUI events
+ */
+
+interface StreamContext {
+    threadId: string;
+    runId: string;
+    messageId: string;
+}
+/**
+ * Process Anthropic streaming events and emit AGUI events
+ */
+declare function processAnthropicStream(stream: AsyncIterable<Anthropic.MessageStreamEvent>, context: StreamContext): AsyncGenerator<{
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId: string;
+    role: string;
+    toolCallId?: undefined;
+    toolCallName?: undefined;
+    delta?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: string;
+    toolCallName: string;
+    messageId?: undefined;
+    role?: undefined;
+    delta?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId: string;
+    delta: string;
+    role?: undefined;
+    toolCallId?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: string;
+    delta: string;
+    messageId?: undefined;
+    role?: undefined;
+    toolCallName?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    toolCallId: string;
+    messageId?: undefined;
+    role?: undefined;
+    toolCallName?: undefined;
+    delta?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId: string;
+    role?: undefined;
+    toolCallId?: undefined;
+    toolCallName?: undefined;
+    delta?: undefined;
+} | {
+    type: EventType;
+    threadId: string;
+    runId: string;
+    messageId?: undefined;
+    role?: undefined;
+    toolCallId?: undefined;
+    toolCallName?: undefined;
+    delta?: undefined;
+}, void, unknown>;
+
+export { LLMAgent, type LLMAgentConfig, type ModelProvider, convertMessagesToAnthropic, convertMessagesToOpenAI, convertToolsToAnthropic, convertToolsToOpenAI, createAnthropicStreamOptions, createOpenAIStreamOptions, processAnthropicStream, processOpenAIStream };