call method

Implementation

Future<AgentMessage> call({
  ToolSchema? responseFormat,
  List<Tool> tools = const [],
  int maxRecursiveToolCalls = 1,
}) async {
  List<Message> messages = await readMessages();
  ToolSchema? schema = tools.isNotEmpty ? null : responseFormat;
  ChatResult result = await llm.connector(
    ChatRequest(
      messages: [
        if (initialSystemMessage != null)
          Message.system(initialSystemMessage!),
        ...messages,
      ],
      model: llm.model,
      responseFormat: schema,
      tools: tools,
      user: user,
    ),
  );

  await Future.wait(
    agentUsageListeners.map(
      (i) => i(AgentUsageEvent(this, result.usage, result.realCost)),
    ),
  );

  await addMessage(result.message);

  if (result.message.toolCalls.isNotEmpty) {
    maxRecursiveToolCalls--;
    for (ToolCall tc in result.message.toolCalls) {
      String output = "";
      Tool? tool = tools.select((i) => i.name == tc.name);

      if (tool == null) {
        output = "Tool not found: ${tc.name}";
        continue;
      }

      try {
        output = await tool(agent: this, arguments: jsonDecode(tc.arguments));
      } catch (e, es) {
        output = "Error calling tool: ${e.toString()}";
        print("Tool Call Exception ${tool.name}(${tc.arguments}) => $e $es");
      }

      await addMessage(
        ToolMessage(content: Content.text(output), toolCallId: tc.id),
      );
    }

    if (maxRecursiveToolCalls > 0) {
      return this(
        responseFormat: schema,
        tools: tools,
        maxRecursiveToolCalls: maxRecursiveToolCalls,
      );
    }

    return this(responseFormat: responseFormat, tools: []);
  }

  return result.message;
}