@cloudbase/agent-adapter-llm 1.0.1-alpha.30

package/dist/index.mjs

@@ -0,0 +1,673 @@
+// src/agent.ts
+import {
+  AbstractAgent,
+  EventType as EventType3
+} from "@ag-ui/client";
+import { Observable } from "rxjs";
+
+// src/converters/openai.ts
+function convertMessagesToOpenAI(messages, systemPrompt) {
+  const openaiMessages = [];
+  if (systemPrompt) {
+    openaiMessages.push({
+      role: "system",
+      content: systemPrompt
+    });
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      openaiMessages.push({
+        role: "user",
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      });
+    } else if (msg.role === "assistant") {
+      openaiMessages.push({
+        role: "assistant",
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) || "",
+        tool_calls: msg.toolCalls?.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments
+          }
+        }))
+      });
+    } else if (msg.role === "tool") {
+      openaiMessages.push({
+        role: "tool",
+        tool_call_id: msg.toolCallId,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      });
+    }
+  }
+  return openaiMessages;
+}
+function convertToolsToOpenAI(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: typeof tool.parameters === "string" ? JSON.parse(tool.parameters) : tool.parameters
+    }
+  }));
+}
+function createOpenAIStreamOptions(config) {
+  return {
+    model: config.modelName,
+    messages: config.messages,
+    tools: config.tools,
+    temperature: config.temperature,
+    max_tokens: config.maxTokens,
+    user: config.user,
+    stream: true
+  };
+}
+
+// src/converters/anthropic.ts
+function convertMessagesToAnthropic(messages) {
+  const anthropicMessages = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const contentStr = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      anthropicMessages.push({
+        role: "user",
+        content: contentStr
+      });
+    } else if (msg.role === "assistant") {
+      const content = [];
+      if (msg.content) {
+        const contentStr = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        content.push({
+          type: "text",
+          text: contentStr
+        });
+      }
+      if (msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments)
+          });
+        }
+      }
+      anthropicMessages.push({
+        role: "assistant",
+        content
+      });
+    } else if (msg.role === "tool") {
+      const contentStr = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      anthropicMessages.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: msg.toolCallId,
+          content: contentStr
+        }]
+      });
+    }
+  }
+  return anthropicMessages;
+}
+function convertToolsToAnthropic(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: typeof tool.parameters === "string" ? JSON.parse(tool.parameters) : tool.parameters
+  }));
+}
+function createAnthropicStreamOptions(config) {
+  return {
+    model: config.modelName,
+    max_tokens: config.maxTokens || 4096,
+    temperature: config.temperature,
+    system: config.systemPrompt || void 0,
+    messages: config.messages,
+    tools: config.tools,
+    stream: true
+  };
+}
+
+// src/processors/openai-stream.ts
+import { EventType } from "@ag-ui/client";
+async function* processOpenAIStream(stream, context) {
+  const { threadId, runId, messageId } = context;
+  const state = {
+    hasStarted: false,
+    fullContent: "",
+    toolCallsMap: /* @__PURE__ */ new Map()
+  };
+  const reasoningState = {
+    hasStarted: false,
+    fullContent: "",
+    toolCallsMap: /* @__PURE__ */ new Map()
+  };
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta;
+    if (!delta) continue;
+    if (delta.role === "tool") {
+      const toolCallId = delta.tool_call_id;
+      if (toolCallId) {
+        if (state.toolCallsMap.has(toolCallId)) {
+          yield {
+            type: EventType.TOOL_CALL_END,
+            threadId,
+            runId,
+            toolCallId
+          };
+          state.toolCallsMap.delete(toolCallId);
+        }
+        yield {
+          type: EventType.TOOL_CALL_RESULT,
+          threadId,
+          runId,
+          toolCallId,
+          content: delta.content || ""
+        };
+      }
+      continue;
+    }
+    if (delta.content) {
+      if (reasoningState.hasStarted) {
+        reasoningState.hasStarted = false;
+        yield {
+          type: EventType.THINKING_TEXT_MESSAGE_END,
+          threadId,
+          runId,
+          messageId
+        };
+        yield {
+          type: EventType.THINKING_END,
+          threadId,
+          runId,
+          messageId
+        };
+      }
+      if (!state.hasStarted) {
+        yield {
+          type: EventType.TEXT_MESSAGE_START,
+          threadId,
+          runId,
+          messageId,
+          role: "assistant"
+        };
+        state.hasStarted = true;
+      }
+      state.fullContent += delta.content;
+      yield {
+        type: EventType.TEXT_MESSAGE_CONTENT,
+        threadId,
+        runId,
+        messageId,
+        delta: delta.content
+      };
+    }
+    if (delta.reasoning_content) {
+      if (!reasoningState.hasStarted) {
+        yield {
+          type: EventType.THINKING_START,
+          threadId,
+          runId,
+          messageId
+        };
+        yield {
+          type: EventType.THINKING_TEXT_MESSAGE_START,
+          threadId,
+          runId,
+          messageId,
+          role: "assistant"
+        };
+        reasoningState.hasStarted = true;
+      }
+      reasoningState.fullContent += delta.reasoning_content;
+      yield {
+        type: EventType.THINKING_TEXT_MESSAGE_CONTENT,
+        threadId,
+        runId,
+        messageId,
+        delta: delta.reasoning_content
+      };
+    }
+    if (delta.tool_calls) {
+      for (const toolCall of delta.tool_calls) {
+        const toolCallId = toolCall.id || `tool_${toolCall.index}`;
+        if (toolCall.function?.name) {
+          yield {
+            type: EventType.TOOL_CALL_START,
+            threadId,
+            runId,
+            toolCallId,
+            toolCallName: toolCall.function.name
+          };
+          if (toolCall.function.arguments) {
+            yield {
+              type: EventType.TOOL_CALL_ARGS,
+              threadId,
+              runId,
+              toolCallId,
+              delta: toolCall.function.arguments
+            };
+          }
+          state.toolCallsMap.set(toolCallId, {
+            name: toolCall.function.name,
+            args: toolCall.function.arguments || ""
+          });
+        } else if (toolCall.function?.arguments) {
+          const existing = state.toolCallsMap.get(toolCallId);
+          if (existing) {
+            existing.args += toolCall.function.arguments;
+            yield {
+              type: EventType.TOOL_CALL_ARGS,
+              threadId,
+              runId,
+              toolCallId,
+              delta: toolCall.function.arguments
+            };
+          }
+        }
+      }
+    }
+  }
+  if (state.hasStarted) {
+    yield {
+      type: EventType.TEXT_MESSAGE_END,
+      threadId,
+      runId,
+      messageId
+    };
+  }
+  if (reasoningState.hasStarted) {
+    yield {
+      type: EventType.THINKING_TEXT_MESSAGE_END,
+      threadId,
+      runId,
+      messageId
+    };
+    yield {
+      type: EventType.THINKING_END,
+      threadId,
+      runId,
+      messageId
+    };
+  }
+  for (const [toolCallId] of state.toolCallsMap) {
+    yield {
+      type: EventType.TOOL_CALL_END,
+      threadId,
+      runId,
+      toolCallId
+    };
+  }
+}
+
+// src/processors/anthropic-stream.ts
+import { EventType as EventType2 } from "@ag-ui/client";
+async function* processAnthropicStream(stream, context) {
+  const { threadId, runId, messageId } = context;
+  const state = {
+    hasStarted: false,
+    fullContent: "",
+    toolCallsMap: /* @__PURE__ */ new Map(),
+    indexToIdMap: /* @__PURE__ */ new Map()
+  };
+  for await (const event of stream) {
+    if (event.type === "content_block_start") {
+      const block = event.content_block;
+      if (block.type === "text") {
+        if (!state.hasStarted) {
+          yield {
+            type: EventType2.TEXT_MESSAGE_START,
+            threadId,
+            runId,
+            messageId,
+            role: "assistant"
+          };
+          state.hasStarted = true;
+        }
+      } else if (block.type === "tool_use") {
+        state.indexToIdMap.set(event.index, block.id);
+        yield {
+          type: EventType2.TOOL_CALL_START,
+          threadId,
+          runId,
+          toolCallId: block.id,
+          toolCallName: block.name
+        };
+        state.toolCallsMap.set(block.id, {
+          name: block.name,
+          input: ""
+        });
+      }
+    } else if (event.type === "content_block_delta") {
+      const delta = event.delta;
+      if (delta.type === "text_delta") {
+        state.fullContent += delta.text;
+        yield {
+          type: EventType2.TEXT_MESSAGE_CONTENT,
+          threadId,
+          runId,
+          messageId,
+          delta: delta.text
+        };
+      } else if (delta.type === "input_json_delta") {
+        const toolCallId = state.indexToIdMap.get(event.index);
+        if (toolCallId) {
+          const toolCall = state.toolCallsMap.get(toolCallId);
+          if (toolCall) {
+            toolCall.input += delta.partial_json;
+            yield {
+              type: EventType2.TOOL_CALL_ARGS,
+              threadId,
+              runId,
+              toolCallId,
+              delta: delta.partial_json
+            };
+          }
+        }
+      }
+    } else if (event.type === "content_block_stop") {
+      const toolCallId = state.indexToIdMap.get(event.index);
+      if (toolCallId && state.toolCallsMap.has(toolCallId)) {
+        yield {
+          type: EventType2.TOOL_CALL_END,
+          threadId,
+          runId,
+          toolCallId
+        };
+      }
+    }
+  }
+  if (state.hasStarted) {
+    yield {
+      type: EventType2.TEXT_MESSAGE_END,
+      threadId,
+      runId,
+      messageId
+    };
+  }
+  yield {
+    type: EventType2.RUN_FINISHED,
+    threadId,
+    runId
+  };
+}
+
+// src/agent.ts
+import { randomUUID } from "crypto";
+function detectModelProviderType(model) {
+  if ("chat" in model && typeof model.chat?.completions?.create === "function") {
+    return "openai";
+  }
+  if ("messages" in model && typeof model.messages?.create === "function") {
+    return "anthropic";
+  }
+  throw new Error(
+    "Unsupported model provider. Expected OpenAI or Anthropic SDK instance."
+  );
+}
+var LLMAgent = class extends AbstractAgent {
+  constructor(config) {
+    super({
+      agentId: config.agentId || config.name || "llm-agent",
+      description: config.description || "",
+      threadId: config.threadId || "",
+      ...config
+    });
+    this.model = config.model;
+    this.modelType = detectModelProviderType(config.model);
+    this.modelName = config.modelName;
+    this.systemPrompt = config.systemPrompt;
+    this.temperature = config.temperature;
+    this.maxTokens = config.maxTokens;
+    this.maxToolRounds = config.maxToolRounds || 5;
+    this.onToolCall = config.onToolCall;
+    this.onToolResult = config.onToolResult;
+    this.name = config.name || config.agentId || "llm-agent";
+  }
+  run(input) {
+    return new Observable((subscriber) => {
+      this._run(subscriber, input).catch((error) => {
+        subscriber.next({
+          type: EventType3.RUN_ERROR,
+          message: error instanceof Error ? error.message : String(error),
+          code: error instanceof Error ? error.name : "UNKNOWN_ERROR"
+        });
+        subscriber.error(error);
+      });
+    });
+  }
+  async _run(subscriber, input) {
+    const { runId, threadId, tools } = input;
+    try {
+      subscriber.next({
+        type: EventType3.RUN_STARTED,
+        threadId,
+        runId
+      });
+      if (!tools || tools.length === 0) {
+        await this.runOnce(subscriber, input);
+        subscriber.next({
+          type: EventType3.RUN_FINISHED,
+          threadId,
+          runId
+        });
+        subscriber.complete();
+        return;
+      }
+      let messages = [...input.messages];
+      let round = 0;
+      while (round < this.maxToolRounds) {
+        round++;
+        const events = [];
+        const toolCallsMap = /* @__PURE__ */ new Map();
+        await this.runOnce(subscriber, { ...input, messages }, (event) => {
+          events.push(event);
+          if (event.type === EventType3.TOOL_CALL_START) {
+            toolCallsMap.set(event.toolCallId, {
+              name: event.toolCallName,
+              args: ""
+            });
+          } else if (event.type === EventType3.TOOL_CALL_ARGS) {
+            const existing = toolCallsMap.get(event.toolCallId);
+            if (existing) {
+              existing.args += event.delta;
+            }
+          }
+        });
+        if (toolCallsMap.size === 0) {
+          subscriber.next({
+            type: EventType3.RUN_FINISHED,
+            threadId,
+            runId
+          });
+          subscriber.complete();
+          return;
+        }
+        const toolCalls = Array.from(toolCallsMap.entries()).map(
+          ([id, data]) => ({
+            id,
+            name: data.name,
+            arguments: data.args
+          })
+        );
+        const assistantMessage = {
+          id: `msg_${Date.now()}`,
+          role: "assistant",
+          content: this.extractTextFromEvents(events),
+          toolCalls: toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: tc.arguments
+            }
+          }))
+        };
+        messages.push(assistantMessage);
+        const toolResults = await this.executeTools(toolCalls, tools);
+        const toolMessages = this.toolResultsToMessages(toolResults);
+        messages.push(...toolMessages);
+      }
+      subscriber.next({
+        type: EventType3.RUN_ERROR,
+        message: `Maximum tool execution rounds (${this.maxToolRounds}) reached`,
+        code: "MAX_TOOL_ROUNDS_EXCEEDED"
+      });
+      subscriber.complete();
+    } catch (error) {
+      throw error;
+    }
+  }
+  async runOpenAI(subscriber, input) {
+    const { messages, runId, threadId, tools, state, forwardedProps } = input;
+    const openai = this.model;
+    const openaiMessages = convertMessagesToOpenAI(messages, this.systemPrompt);
+    const openaiTools = convertToolsToOpenAI(tools);
+    const streamOptions = createOpenAIStreamOptions({
+      modelName: this.modelName,
+      messages: openaiMessages,
+      tools: openaiTools,
+      temperature: this.temperature,
+      maxTokens: this.maxTokens,
+      user: state?.__request_context__?.user?.id || forwardedProps?.user || randomUUID()
+    });
+    const stream = await openai.chat.completions.create(streamOptions);
+    const messageId = `msg_${Date.now()}`;
+    const context = { threadId, runId, messageId };
+    for await (const event of processOpenAIStream(stream, context)) {
+      subscriber.next(event);
+    }
+  }
+  async runAnthropic(subscriber, input) {
+    const { messages, runId, threadId, tools } = input;
+    const anthropic = this.model;
+    const anthropicMessages = convertMessagesToAnthropic(messages);
+    const anthropicTools = convertToolsToAnthropic(tools);
+    const streamOptions = createAnthropicStreamOptions({
+      modelName: this.modelName,
+      messages: anthropicMessages,
+      tools: anthropicTools,
+      systemPrompt: this.systemPrompt,
+      temperature: this.temperature,
+      maxTokens: this.maxTokens
+    });
+    const stream = await anthropic.messages.create(streamOptions);
+    const messageId = `msg_${Date.now()}`;
+    const context = { threadId, runId, messageId };
+    for await (const event of processAnthropicStream(stream, context)) {
+      subscriber.next(event);
+    }
+  }
+  /**
+   * Run model once (single round, no tool execution)
+   */
+  async runOnce(subscriber, input, eventCallback) {
+    const wrappedSubscriber = eventCallback ? {
+      next: (event) => {
+        subscriber.next(event);
+        eventCallback(event);
+      }
+    } : subscriber;
+    if (this.modelType === "openai") {
+      await this.runOpenAI(wrappedSubscriber, input);
+    } else if (this.modelType === "anthropic") {
+      await this.runAnthropic(wrappedSubscriber, input);
+    } else {
+      throw new Error("Unsupported model provider");
+    }
+  }
+  /**
+   * Execute tools
+   */
+  async executeTools(toolCalls, tools) {
+    const toolsMap = new Map(tools.map((t) => [t.name, t]));
+    return Promise.all(
+      toolCalls.map(async (toolCall) => {
+        if (this.onToolCall) {
+          this.onToolCall(toolCall);
+        }
+        try {
+          const tool = toolsMap.get(toolCall.name);
+          if (!tool) {
+            throw new Error(`Tool not found: ${toolCall.name}`);
+          }
+          const args = JSON.parse(toolCall.arguments);
+          const result = await this.executeToolFunction(tool, args);
+          const toolResult = {
+            toolCallId: toolCall.id,
+            result
+          };
+          if (this.onToolResult) {
+            this.onToolResult(toolResult);
+          }
+          return toolResult;
+        } catch (error) {
+          const toolResult = {
+            toolCallId: toolCall.id,
+            result: null,
+            error: error instanceof Error ? error.message : String(error)
+          };
+          if (this.onToolResult) {
+            this.onToolResult(toolResult);
+          }
+          return toolResult;
+        }
+      })
+    );
+  }
+  /**
+   * Execute tool function
+   */
+  async executeToolFunction(tool, args) {
+    if (tool.execute) {
+      return await tool.execute(args);
+    }
+    throw new Error(`Tool ${tool.name} does not have an execute method`);
+  }
+  /**
+   * Convert tool results to messages
+   */
+  toolResultsToMessages(results) {
+    return results.map(
+      (result) => ({
+        id: `tool_result_${result.toolCallId}`,
+        role: "tool",
+        toolCallId: result.toolCallId,
+        content: result.error ? `Error: ${result.error}` : JSON.stringify(result.result)
+      })
+    );
+  }
+  /**
+   * Extract text content from events
+   */
+  extractTextFromEvents(events) {
+    let text = "";
+    for (const event of events) {
+      if (event.type === EventType3.TEXT_MESSAGE_CONTENT) {
+        text += event.delta;
+      }
+    }
+    return text;
+  }
+};
+export {
+  LLMAgent,
+  convertMessagesToAnthropic,
+  convertMessagesToOpenAI,
+  convertToolsToAnthropic,
+  convertToolsToOpenAI,
+  createAnthropicStreamOptions,
+  createOpenAIStreamOptions,
+  processAnthropicStream,
+  processOpenAIStream
+};
+//# sourceMappingURL=index.mjs.map