브라우저 사용 도구

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 2048
tools:
  - type: browser_toolset_20260801
messages:
  - role: user
    content: Open example.com/docs and tell me how to get started.
YAML

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=2048,
    tools=[{"type": "browser_toolset_20260801"}],
    messages=[
        {
            "role": "user",
            "content": "Open example.com/docs and tell me how to get started.",
        }
    ],
)
print(response)

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 2048,
  tools: [{ type: "browser_toolset_20260801" }],
  messages: [
    {
      role: "user",
      content: "Open example.com/docs and tell me how to get started."
    }
  ]
});

console.log(response);

var client = new AnthropicClient();

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 2048,
    Tools = [new BrowserToolset20260801()],
    Messages =
    [
        new MessageParam
        {
            Role = Role.User,
            Content = "Open example.com/docs and tell me how to get started.",
        },
    ],
};

var response = await client.Messages.Create(parameters);
Console.WriteLine(response);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 2048,
	Tools: []anthropic.ToolUnionParam{
		{OfBrowserToolset20260801: &anthropic.BrowserToolset20260801Param{}},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Open example.com/docs and tell me how to get started.")),
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response.RawJSON())

import com.anthropic.models.messages.BrowserToolset20260801;
// ...

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(2048L)
        .addTool(BrowserToolset20260801.builder().build())
        .addUserMessage("Open example.com/docs and tell me how to get started.")
        .build();

    Message response = client.messages().create(params);
    IO.println(response);
}

$client = new Client();

$response = $client->messages->create(
    maxTokens: 2048,
    messages: [
        ['role' => 'user', 'content' => 'Open example.com/docs and tell me how to get started.'],
    ],
    model: 'claude-opus-5-5',
    tools: [
        ['type' => 'browser_toolset_20260801'],
    ],
);

echo $response;

client = Anthropic::Client.new

response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 2048,
  tools: [
    { type: "browser_toolset_20260801" }
  ],
  messages: [
    {
      role: "user",
      content: "Open example.com/docs and tell me how to get started."
    }
  ]
)

puts response

def navigate(url): return f"navigated to {url}"

def read_page(): return 'link "Docs" [ref_1]\nbutton "Search" [ref_2]'

def click(target): # A target is an element reference from read_page or find, or a viewport coordinate if target["type"] == "ref": return f"clicked {target['ref']}" return f"clicked at ({target['x']}, {target['y']})"

def type_text(text): return f"typed: {text}"

def capture_screenshot() -> list[ImageBlockParam]: # screenshot answers with an image block rather than text: return the result content list return [ { "type": "image", "source": {"type": "base64", "media_type": "image/png", "data": PLACEHOLDER_PNG}, } ]

def handle_browser_action(name, tool_input): if name == "navigate": return navigate(tool_input["url"]) elif name == "read_page": return read_page() elif name == "left_click": return click(tool_input["target"]) elif name == "type": return type_text(tool_input["text"]) elif name == "screenshot": return capture_screenshot() # Handle other actions as needed raise ValueError(f"Unknown or unimplemented member: {name}")

```typescript TypeScript
// Placeholder image data; a real executor captures the viewport as PNG bytes
const PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

function navigate(url: string): string {
  return `navigated to ${url}`;
}

function readPage(): string {
  return 'link "Docs" [ref_1]\nbutton "Search" [ref_2]';
}

function clickElement(ref: string): string {
  return `clicked ${ref}`;
}

function clickAt(x: number, y: number): string {
  return `clicked at (${x}, ${y})`;
}

function typeText(text: string): string {
  return `typed: ${text}`;
}

function captureScreenshot(): Anthropic.ImageBlockParam[] {
  // screenshot answers with an image block rather than text
  return [
    {
      type: "image",
      source: {
        type: "base64",
        media_type: "image/png",
        data: PLACEHOLDER_PNG,
      },
    },
  ];
}

function handleBrowserAction(
  action: string,
  input: unknown,
): string | Anthropic.ImageBlockParam[] {
  const params: object =
    typeof input === "object" && input !== null ? input : {};
  if (action === "navigate" && "url" in params) {
    return navigate(String(params.url));
  } else if (action === "read_page") {
    return readPage();
  } else if (action === "left_click" && "target" in params) {
    // target is an element reference from read_page or a viewport coordinate
    const target: object =
      typeof params.target === "object" && params.target !== null
        ? params.target
        : {};
    if ("type" in target && target.type === "ref" && "ref" in target) {
      return clickElement(String(target.ref));
    } else if ("x" in target && "y" in target) {
      return clickAt(Number(target.x), Number(target.y));
    }
  } else if (action === "type" && "text" in params) {
    return typeText(String(params.text));
  } else if (action === "screenshot") {
    return captureScreenshot();
  }
  // Handle other actions as needed
  throw new Error(`Unknown or unimplemented member: ${action}`);
}

// Placeholder image data; a real executor captures the viewport and returns the PNG bytes
const string PlaceholderPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

string Navigate(string url) => $"navigated to {url}";

string ReadPage() =>
    """
    link "Docs" [ref_1]
    button "Search" [ref_2]
    """;

string ClickRef(string elementRef) => $"clicked {elementRef}";

string ClickAt(int x, int y) => $"clicked at ({x}, {y})";

// target is {"type": "ref", "ref": "ref_1"} or {"type": "coordinate", "x": 640, "y": 380}
string Click(JsonElement target) =>
    target.GetProperty("type").GetString() == "ref"
        ? ClickRef(target.GetProperty("ref").GetString()!)
        : ClickAt(target.GetProperty("x").GetInt32(), target.GetProperty("y").GetInt32());

string TypeText(string text) => $"typed: {text}";

// screenshot answers with an image block rather than text: return the result content list
List<Block> CaptureScreenshot() =>
    [
        new ImageBlockParam(
            new Base64ImageSource { Data = PlaceholderPng, MediaType = MediaType.ImagePng }
        ),
    ];

ToolResultBlockParamContent HandleBrowserAction(
    string action,
    IReadOnlyDictionary<string, JsonElement> input
) =>
    action switch
    {
        "navigate" => Navigate(input["url"].GetString()!),
        "read_page" => ReadPage(),
        "left_click" => Click(input["target"]),
        "type" => TypeText(input["text"].GetString()!),
        "screenshot" => CaptureScreenshot(),
        // Handle other actions as needed
        _ => throw new NotSupportedException($"Unknown or unimplemented member: {action}"),
    };

// placeholderPNG stands in for a real capture: an executor returns the
// viewport as base64-encoded PNG data.
const placeholderPNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

// textContent wraps text as tool_result content.
func textContent(text string) []anthropic.ToolResultBlockParamContentUnion {
	return []anthropic.ToolResultBlockParamContentUnion{
		{OfText: &anthropic.TextBlockParam{Text: text}},
	}
}

func navigate(url string) string {
	return fmt.Sprintf("navigated to %s", url)
}

func readPage() string {
	return "link \"Docs\" [ref_1]\nbutton \"Search\" [ref_2]"
}

func clickRef(ref string) string {
	return fmt.Sprintf("clicked %s", ref)
}

func clickAt(x, y int) string {
	return fmt.Sprintf("clicked at (%d, %d)", x, y)
}

func typeText(text string) string {
	return fmt.Sprintf("typed: %s", text)
}

// captureScreenshot returns an image block rather than text.
func captureScreenshot() []anthropic.ToolResultBlockParamContentUnion {
	return []anthropic.ToolResultBlockParamContentUnion{{
		OfImage: &anthropic.ImageBlockParam{
			Source: anthropic.ImageBlockParamSourceUnion{
				OfBase64: &anthropic.Base64ImageSourceParam{
					MediaType: anthropic.Base64ImageSourceMediaTypeImagePNG,
					Data:      placeholderPNG,
				},
			},
		},
	}}
}

func handleBrowserAction(action string, params map[string]any) ([]anthropic.ToolResultBlockParamContentUnion, error) {
	switch action {
	case "navigate":
		if url, ok := params["url"].(string); ok {
			return textContent(navigate(url)), nil
		}
	case "read_page":
		return textContent(readPage()), nil
	case "left_click":
		// target is either an element reference from read_page or a viewport coordinate
		target, _ := params["target"].(map[string]any)
		if ref, ok := target["ref"].(string); ok && target["type"] == "ref" {
			return textContent(clickRef(ref)), nil
		}
		x, xok := target["x"].(float64)
		y, yok := target["y"].(float64)
		if xok && yok {
			return textContent(clickAt(int(x), int(y))), nil
		}
	case "type":
		if text, ok := params["text"].(string); ok {
			return textContent(typeText(text)), nil
		}
	case "screenshot":
		return captureScreenshot(), nil
	// Handle other actions as needed
	default:
		return nil, fmt.Errorf("unknown or unimplemented member: %s", action)
	}
	// Reached when a member's input is missing a field or a field has the wrong type
	return nil, fmt.Errorf("invalid input for %s", action)
}

/** Placeholder pixels; a real executor captures the viewport and base64-encodes the PNG. */
static final String PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

ToolResultBlockParam.Content captureScreenshot() {
    ImageBlockParam image = ImageBlockParam.builder()
            .source(Base64ImageSource.builder()
                    .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
                    .data(PLACEHOLDER_PNG)
                    .build())
            .build();
    return ToolResultBlockParam.Content.ofBlocks(
            List.of(ToolResultBlockParam.Content.Block.ofImage(image)));
}

String navigate(String url) {
    return "navigated to " + url;
}

String readPage() {
    return """
            link "Docs" [ref_1]
            button "Search" [ref_2]""";
}

String clickRef(String ref) {
    return "clicked " + ref;
}

String clickAt(long x, long y) {
    return "clicked at (" + x + ", " + y + ")";
}

String typeText(String text) {
    return "typed: " + text;
}

/** Runs one browser toolset member; {@code action} is the tool_use block's name. */
ToolResultBlockParam.Content handleBrowserAction(String action, Map<String, JsonValue> input) {
    if (action.equals("screenshot")) {
        return captureScreenshot(); // the one member here that answers with an image block
    }
    String output = switch (action) {
        case "navigate" -> navigate(input.get("url").asStringOrThrow());
        case "read_page" -> readPage();
        case "left_click" -> {
            // target is {"type": "ref", "ref": "ref_1"} or {"type": "coordinate", "x": 640, "y": 380}
            Map<String, JsonValue> target =
                    (Map<String, JsonValue>) input.get("target").asObject().get();
            if (target.get("type").asStringOrThrow().equals("ref")) {
                yield clickRef(target.get("ref").asStringOrThrow());
            }
            long x = ((Number) target.get("x").asNumber().get()).longValue();
            long y = ((Number) target.get("y").asNumber().get()).longValue();
            yield clickAt(x, y);
        }
        case "type" -> typeText(input.get("text").asStringOrThrow());
        // Handle other actions as needed
        default -> throw new UnsupportedOperationException("Unknown or unimplemented member: " + action);
    };
    return ToolResultBlockParam.Content.ofString(output);
}

// Stand-in for real PNG bytes; a real executor captures the viewport
const PLACEHOLDER_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';

function navigateTo(string $url): string
{
    return "navigated to {$url}";
}

function readPage(): string
{
    return <<<'TEXT'
        link "Docs" [ref_1]
        button "Search" [ref_2]
        TEXT;
}

function clickTarget(array $target): string
{
    // A target is an element reference from read_page or find, or a viewport pixel coordinate
    if ($target['type'] === 'ref') {
        return "clicked {$target['ref']}";
    }

    return "clicked at ({$target['x']}, {$target['y']})";
}

function typeText(string $text): string
{
    return "typed: {$text}";
}

function captureScreenshot(): array
{
    // screenshot answers with an image block rather than text, so return the result content list
    $image = [
        'type' => 'image',
        'source' => ['type' => 'base64', 'media_type' => 'image/png', 'data' => PLACEHOLDER_PNG],
    ];

    return [$image];
}

function handleBrowserAction(string $name, array $input): string|array
{
    return match ($name) {
        'navigate' => navigateTo($input['url']),
        'read_page' => readPage(),
        'left_click' => clickTarget($input['target']),
        'type' => typeText($input['text']),
        'screenshot' => captureScreenshot(),
        // Handle other actions as needed
        default => throw new RuntimeException("Unknown or unimplemented member: {$name}"),
    };
}

# Stand-in image data; a real executor captures the viewport as a PNG.
PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

def navigate(url)
  "navigated to #{url}"
end

def read_page
  <<~TREE
    link "Docs" [ref_1]
    button "Search" [ref_2]
  TREE
end

def click(target)
  return "clicked #{target[:ref]}" if target[:type] == "ref"

  "clicked at (#{target[:x]}, #{target[:y]})"
end

def type_text(text)
  "typed: #{text}"
end

def capture_screenshot
  [
    {
      type: "image",
      source: { type: "base64", media_type: "image/png", data: PLACEHOLDER_PNG }
    }
  ]
end

def handle_browser_action(name, input)
  case name
  when "navigate"
    navigate(input[:url])
  when "read_page"
    read_page
  when "left_click"
    # target is an element reference (from read_page or find) or a coordinate
    click(input[:target])
  when "type"
    type_text(input[:text])
  when "screenshot"
    capture_screenshot
  # Handle other actions as needed
  else
    raise ArgumentError, "Unknown or unimplemented member: #{name}"
  end
end

def process_tool_calls(response: Message) -> list[ToolResultBlockParam]: """ Run the browser actions in Claude's response in order and answer each one. After the first failure the rest are skipped, because Claude planned them assuming the earlier actions succeeded. """ tool_results: list[ToolResultBlockParam] = [] failed = False for block in response.content: # Only the browser toolset is declared; route other tools here if you add them if block.type != "tool_use" or block.toolset_name != "browser": continue result: ToolResultBlockParam = { "type": "tool_result", "tool_use_id": block.id, "toolset_name": "browser", } if failed: result["content"] = NOT_EXECUTED result["is_error"] = True else: try: # A string or a list of content blocks; a real executor also adds a # browser_state block to navigation and tab-management results result["content"] = handle_browser_action(block.name, block.input) except Exception as err: result["content"] = f"Error: {err}" result["is_error"] = True failed = True tool_results.append(result) return tool_results

```typescript TypeScript
const HALT_TEXT = "Not executed: an earlier action in this turn failed.";

function browserResult(
  toolUseId: string,
  content: string | Anthropic.ImageBlockParam[],
  isError?: boolean,
): Anthropic.ToolResultBlockParam {
  return {
    type: "tool_result",
    tool_use_id: toolUseId,
    toolset_name: "browser",
    content,
    is_error: isError,
  };
}

function processToolCalls(
  response: Anthropic.Message,
): Anthropic.ToolResultBlockParam[] {
  const toolResults: Anthropic.ToolResultBlockParam[] = [];
  let failed = false;
  for (const block of response.content) {
    if (block.type !== "tool_use") {
      continue;
    }
    if (block.toolset_name !== "browser") {
      // This example declares only the browser toolset; route other tools
      // here if you add them.
      continue;
    }
    if (failed) {
      // A batch stops at its first failure; answer later actions unexecuted
      toolResults.push(browserResult(block.id, HALT_TEXT, true));
      continue;
    }
    try {
      // A string or an image block list; a real executor also adds a
      // browser_state block to navigation and tab-management results
      const result = handleBrowserAction(block.name, block.input);
      toolResults.push(browserResult(block.id, result));
    } catch (error) {
      failed = true;
      const message = error instanceof Error ? error.message : String(error);
      toolResults.push(browserResult(block.id, `Error: ${message}`, true));
    }
  }
  return toolResults;
}

const string HaltText = "Not executed: an earlier action in this turn failed.";

List<ContentBlockParam> ProcessToolCalls(Message response)
{
    List<ContentBlockParam> toolResults = [];
    var failed = false;
    foreach (var block in response.Content)
    {
        if (!block.TryPickToolUse(out var toolUse))
        {
            continue;
        }

        if (toolUse.ToolsetName != "browser")
        {
            // This example declares only the browser toolset; route other tools
            // here if you add them.
            continue;
        }

        if (failed)
        {
            // A batch stops at its first failure; answer later actions without running them
            toolResults.Add(
                new ToolResultBlockParam(toolUse.ID)
                {
                    Content = HaltText,
                    IsError = true,
                    ToolsetName = "browser",
                }
            );
            continue;
        }

        try
        {
            // A string or a list of content blocks; a real executor also adds a
            // browser_state block to navigation and tab-management results
            var result = HandleBrowserAction(toolUse.Name, toolUse.Input);
            toolResults.Add(
                new ToolResultBlockParam(toolUse.ID) { Content = result, ToolsetName = "browser" }
            );
        }
        catch (Exception e)
        {
            failed = true;
            toolResults.Add(
                new ToolResultBlockParam(toolUse.ID)
                {
                    Content = $"Error: {e.Message}",
                    IsError = true,
                    ToolsetName = "browser",
                }
            );
        }
    }
    return toolResults;
}

const notExecuted = "Not executed: an earlier action in this turn failed."

// browserToolResult builds the result for one browser action. Unlike an
// ordinary tool result, it must echo the toolset name. A real executor also
// adds a browser_state block to navigation and tab-management results.
func browserToolResult(toolUseID string, content []anthropic.ToolResultBlockParamContentUnion, isError bool) anthropic.ContentBlockParamUnion {
	result := anthropic.ToolResultBlockParam{
		ToolUseID:   toolUseID,
		ToolsetName: anthropic.String("browser"),
		Content:     content,
	}
	if isError {
		result.IsError = anthropic.Bool(true)
	}
	return anthropic.ContentBlockParamUnion{OfToolResult: &result}
}

// processToolCalls runs the browser actions in Claude's response in order and
// builds one tool_result per tool_use block. After the first failure it skips
// the rest: Claude planned them assuming the earlier actions succeeded.
func processToolCalls(response *anthropic.Message) []anthropic.ContentBlockParamUnion {
	var toolResults []anthropic.ContentBlockParamUnion
	failed := false
	for _, block := range response.Content {
		switch variant := block.AsAny().(type) {
		case anthropic.ToolUseBlock:
			// This example declares only the browser toolset; route other tools here if you add them.
			if variant.ToolsetName != "browser" {
				continue
			}
			if failed {
				toolResults = append(toolResults, browserToolResult(variant.ID, textContent(notExecuted), true))
				continue
			}
			var input map[string]any
			var content []anthropic.ToolResultBlockParamContentUnion
			err := json.Unmarshal(variant.Input, &input)
			if err == nil {
				content, err = handleBrowserAction(variant.Name, input)
			}
			if err != nil {
				failed = true
				content = textContent("Error: " + err.Error())
			}
			toolResults = append(toolResults, browserToolResult(variant.ID, content, err != nil))
		}
	}
	return toolResults
}

/** The exact text the toolset contract prescribes for member calls skipped after a failure. */
static final String HALT_TEXT = "Not executed: an earlier action in this turn failed.";

/** Every result answering a browser toolset member echoes toolset_name. */
ToolResultBlockParam.Builder browserResult(ToolUseBlock toolUse) {
    return ToolResultBlockParam.builder()
            .toolUseId(toolUse.id())
            .toolsetName("browser");
}

/**
 * Run the browser actions in Claude's response in order and build one
 * tool_result per tool_use block. After the first failure, skip the rest:
 * Claude planned them assuming the earlier actions succeeded.
 */
List<ContentBlockParam> processToolCalls(Message response) {
    List<ContentBlockParam> toolResults = new ArrayList<>();
    boolean failed = false;
    for (ContentBlock block : response.content()) {
        // This example declares only the browser toolset; route other tools here if you add them.
        if (!block.isToolUse() || !block.asToolUse().toolsetName().equals(Optional.of("browser"))) {
            continue;
        }
        ToolUseBlock toolUse = block.asToolUse();
        ToolResultBlockParam result;
        if (failed) {
            result = browserResult(toolUse).content(HALT_TEXT).isError(true).build();
        } else {
            try {
                Map<String, JsonValue> input =
                        (Map<String, JsonValue>) toolUse._input().asObject().get();
                ToolResultBlockParam.Content output = handleBrowserAction(toolUse.name(), input);
                // A real executor also adds a browser_state block to navigation and
                // tab-management results; see "Track tabs with browser_state" on this page.
                result = browserResult(toolUse).content(output).build();
            } catch (RuntimeException e) {
                failed = true;
                result = browserResult(toolUse).content("Error: " + e.getMessage()).isError(true).build();
            }
        }
        toolResults.add(ContentBlockParam.ofToolResult(result));
    }
    return toolResults;
}

const HALT_TEXT = 'Not executed: an earlier action in this turn failed.';

function processToolCalls(Message $response): array
{
    $toolResults = [];
    $failed = false;
    foreach ($response->content as $block) {
        // This example declares only the browser toolset; route other tools here if you add them.
        if (!($block instanceof \Anthropic\Messages\ToolUseBlock) || $block->toolsetName !== 'browser') {
            continue;
        }
        $result = ['type' => 'tool_result', 'tool_use_id' => $block->id, 'toolset_name' => 'browser'];
        if ($failed) {
            // A batch stops at its first failure; the remaining actions are answered without running
            $toolResults[] = [...$result, 'content' => HALT_TEXT, 'is_error' => true];
            continue;
        }
        try {
            // A real executor also returns a browser_state block on navigation and tab-management results
            $toolResults[] = [...$result, 'content' => handleBrowserAction($block->name, $block->input)];
        } catch (Throwable $e) {
            $failed = true;
            $toolResults[] = [...$result, 'content' => 'Error: ' . $e->getMessage(), 'is_error' => true];
        }
    }

    return $toolResults;
}

NOT_EXECUTED = "Not executed: an earlier action in this turn failed."

# Run the browser actions in Claude's response in order and build one
# tool_result per tool_use block. After the first failure, skip the rest:
# Claude planned them assuming the earlier actions succeeded.
def process_tool_calls(response)
  tool_results = []
  failed = false
  response.content.each do |block|
    # This example declares only the browser toolset; route other tools here
    # if you add them.
    next unless block.type == :tool_use && block.toolset_name == "browser"

    result = { type: "tool_result", tool_use_id: block.id, toolset_name: "browser" }
    if failed
      result.update(content: NOT_EXECUTED, is_error: true)
    else
      begin
        # A String, or content blocks for a screenshot. A real executor also adds
        # a browser_state block to navigation and tab-management results.
        result[:content] = handle_browser_action(block.name, block.input)
      rescue => e
        result.update(content: "Error: #{e.message}", is_error: true)
        failed = true
      end
    end
    tool_results << result
  end
  tool_results
end