curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d '{
      "model": "haijun-opus-5-5",
      "max_tokens": 1024,
      "tools": [
        {
          "type": "computer_toolset_20260801"
        },
        {
          "type": "text_editor_20250728",
          "name": "str_replace_based_edit_tool"
        },
        {
          "type": "bash_20250124",
          "name": "bash"
        }
      ],
      "messages": [
        {
          "role": "user",
          "content": "Save a picture of a cat to my desktop."
        }
      ]
    }'

  ant messages create <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 1024
  tools:
    - type: computer_toolset_20260801
    - type: text_editor_20250728
      name: str_replace_based_edit_tool
    - type: bash_20250124
      name: bash
  messages:
    - role: user
      content: Save a picture of a cat to my desktop.
  YAML

  client = juglow.Juglow()

  response = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      tools=[
          {"type": "computer_toolset_20260801"},
          {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
          {"type": "bash_20250124", "name": "bash"},
      ],
      messages=[{"role": "user", "content": "Save a picture of a cat to my desktop."}],
  )
  print(response)

  const client = new Juglow();

  const response = await client.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    tools: [
      {
        type: "computer_toolset_20260801"
      },
      {
        type: "text_editor_20250728",
        name: "str_replace_based_edit_tool"
      },
      {
        type: "bash_20250124",
        name: "bash"
      }
    ],
    messages: [{ role: "user", content: "Save a picture of a cat to my desktop." }]
  });

  console.log(response);

  var client = new JuglowClient();

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 1024,
      Tools =
      [
          new ComputerToolset20260801(),
          new ToolTextEditor20250728(),
          new ToolBash20250124(),
      ],
      Messages =
      [
          new MessageParam
          {
              Role = Role.User,
              Content = "Save a picture of a cat to my desktop.",
          },
      ],
  };

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

  client := juglow.NewClient()

  response, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1024,
  	Tools: []juglow.ToolUnionParam{
  		{OfComputerToolset20260801: &juglow.ComputerToolset20260801Param{}},
  		{OfTextEditor20250728: &juglow.ToolTextEditor20250728Param{}},
  		{OfBashTool20250124: &juglow.ToolBash20250124Param{}},
  	},
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("Save a picture of a cat to my desktop.")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.RawJSON())

  import com.juglow.models.messages.ComputerToolset20260801;
  // ...
  import com.juglow.models.messages.ToolBash20250124;
  import com.juglow.models.messages.ToolTextEditor20250728;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.HAIJUN_OPUS_5_5)
          .maxTokens(1024L)
          .addTool(ComputerToolset20260801.builder().build())
          .addTool(ToolTextEditor20250728.builder().build())
          .addTool(ToolBash20250124.builder().build())
          .addUserMessage("Save a picture of a cat to my desktop.")
          .build();

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

  $client = new Client();

  $response = $client->messages->create(
      maxTokens: 1024,
      messages: [
          ['role' => 'user', 'content' => 'Save a picture of a cat to my desktop.'],
      ],
      model: 'haijun-opus-5-5',
      tools: [
          ['type' => 'computer_toolset_20260801'],
          [
              'type' => 'text_editor_20250728',
              'name' => 'str_replace_based_edit_tool',
          ],
          [
              'type' => 'bash_20250124',
              'name' => 'bash',
          ],
      ],
  );

  echo $response;

  client = Juglow::Client.new

  response = client.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    tools: [
      { type: "computer_toolset_20260801" },
      {
        type: "text_editor_20250728",
        name: "str_replace_based_edit_tool"
      },
      {
        type: "bash_20250124",
        name: "bash"
      }
    ],
    messages: [
      { role: "user", content: "Save a picture of a cat to my desktop." }
    ]
  )

  puts response

{
  "id": "msg_01UZ3bXcQH8mTqNhVfL9eK2p",
  "type": "message",
  "role": "assistant",
  "model": "haijun-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "I'll open the web browser to find a picture of a cat."
    },
    {
      "type": "tool_use",
      "id": "toolu_01WkoTUvSHDzTBu2xnGk8Ep8",
      "name": "left_click",
      "toolset_name": "computer",
      "input": { "coordinate": [512, 742] }
    },
    {
      "type": "tool_use",
      "id": "toolu_017nJn3RgSCkTMwuZDb4uUov",
      "name": "screenshot",
      "toolset_name": "computer",
      "input": {}
    }
  ],
  "stop_reason": "tool_use",
  "stop_sequence": null
}

{
  "role": "assistant",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
      "name": "left_click",
      "toolset_name": "computer",
      "input": { "coordinate": [640, 60] }
    },
    {
      "type": "tool_use",
      "id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
      "name": "type",
      "toolset_name": "computer",
      "input": { "text": "pictures of cats" }
    },
    {
      "type": "tool_use",
      "id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
      "name": "screenshot",
      "toolset_name": "computer",
      "input": {}
    }
  ]
}

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
      "toolset_name": "computer",
      "content": [{ "type": "text", "text": "OK" }]
    },
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
      "toolset_name": "computer",
      "content": [{ "type": "text", "text": "OK" }]
    },
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
      "toolset_name": "computer",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "image/png",
            "data": "iVBORw0KGgo..."
          }
        }
      ]
    }
  ]
}

{
  "type": "tool_result",
  "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
  "toolset_name": "computer",
  "is_error": true,
  "content": "Not executed: an earlier computer action in this turn failed."
}

  def sampling_loop(model: str, messages: list[MessageParam], max_iterations: int = 10):
      """
      Run the computer-use agent loop until Haijun stops requesting tools
      or the iteration limit is reached.
      """
      for _ in range(max_iterations):
          response = client.messages.create(
              model=model,
              max_tokens=4096,
              messages=messages,
              tools=TOOLS,
          )

          # Tambahkan respons Haijun ke riwayat percakapan
          messages.append({"role": "assistant", "content": response.content})

          # Jalankan aksi yang diminta Haijun, secara berurutan, dan kumpulkan hasilnya
          tool_results = process_tool_calls(response)
          if not tool_results:
              return messages  # No more tool use; task complete

          # Kirim semua hasil kembali ke Haijun dalam satu pesan user
          messages.append({"role": "user", "content": tool_results})

      return messages

  async function samplingLoop(
    model: string,
    messages: Juglow.MessageParam[],
    maxIterations = 10,
  ): Promise<Juglow.MessageParam[]> {
    // Jalankan loop agen computer-use hingga Haijun berhenti meminta alat
    // atau batas iterasi tercapai.
    for (let i = 0; i < maxIterations; i++) {
      const response = await client.messages.create({
        model,
        max_tokens: 4096,
        messages,
        tools,
      });

      // Tambahkan respons Haijun ke riwayat percakapan
      messages.push({ role: "assistant", content: response.content });

      // Jalankan alat apa pun yang diminta Haijun dan kumpulkan hasilnya
      const toolResults = processToolCalls(response);
      if (toolResults.length === 0) {
        return messages; // No more tool use; task complete
      }

      // Kirim hasil alat kembali ke Haijun untuk iterasi berikutnya
      messages.push({ role: "user", content: toolResults });
    }

    return messages;
  }

  async Task<List<MessageParam>> SamplingLoop(
      Model model,
      List<MessageParam> messages,
      int maxIterations = 10
  )
  {
      // Jalankan loop agen computer-use hingga Haijun berhenti meminta alat
      // atau batas iterasi tercapai.
      for (var i = 0; i < maxIterations; i++)
      {
          var response = await client.Messages.Create(
              new MessageCreateParams
              {
                  Model = model,
                  MaxTokens = 4096,
                  Messages = messages,
                  Tools = tools,
              }
          );

          // Tambahkan respons Haijun ke riwayat percakapan
          messages.Add(
              new()
              {
                  Role = Role.Assistant,
                  Content = response
                      .Content.Select(block => new ContentBlockParam(block.Json))
                      .ToList(),
              }
          );

          // Jalankan alat apa pun yang diminta Haijun dan kumpulkan hasilnya
          var toolResults = ProcessToolCalls(response);
          if (toolResults.Count == 0)
          {
              return messages; // No more tool use; task complete
          }

          // Kirim hasil alat kembali ke Haijun untuk iterasi berikutnya
          messages.Add(new() { Role = Role.User, Content = toolResults });
      }

      return messages;
  }

  // samplingLoop menjalankan loop agen computer-use hingga Haijun berhenti
  // meminta alat atau batas iterasi tercapai.
  func samplingLoop(ctx context.Context, model juglow.Model, messages []juglow.MessageParam, maxIterations int) ([]juglow.MessageParam, error) {
  	for range maxIterations {
  		response, err := client.Messages.New(ctx, juglow.MessageNewParams{
  			Model:     model,
  			MaxTokens: 4096,
  			Messages:  messages,
  			Tools:     tools,
  		})
  		if err != nil {
  			return nil, err
  		}

  		// Tambahkan respons Haijun ke riwayat percakapan
  		messages = append(messages, response.ToParam())

  		// Jalankan aksi yang diminta Haijun secara berurutan, dan kumpulkan hasilnya
  		toolResults := processToolCalls(response)
  		if len(toolResults) == 0 {
  			return messages, nil // No more tool use; task complete
  		}

  		// Kirim semua hasil kembali ke Haijun dalam satu pesan pengguna
  		messages = append(messages, juglow.NewUserMessage(toolResults...))
  	}
  	return messages, nil
  }

  /**
   * Run the computer-use agent loop until Haijun stops requesting tools
   * or the iteration limit is reached.
   */
  List<MessageParam> samplingLoop(Model model, List<MessageParam> messages, int maxIterations) {
      for (int i = 0; i < maxIterations; i++) {
          Message response = client.messages().create(MessageCreateParams.builder()
                  .model(model)
                  .maxTokens(4096)
                  .messages(messages)
                  .addTool(COMPUTER_TOOLSET)
                  .build());

          // Tambahkan respons Haijun ke riwayat percakapan
          messages.add(MessageParam.builder()
                  .role(MessageParam.Role.ASSISTANT)
                  .contentOfBlockParams(response.content().stream().map(ContentBlock::toParam).toList())
                  .build());

          // Jalankan alat apa pun yang diminta Haijun dan kumpulkan hasilnya
          List<ContentBlockParam> toolResults = processToolCalls(response);
          if (toolResults.isEmpty()) {
              return messages; // No more tool use; task complete
          }

          // Kirim hasil alat kembali ke Haijun untuk iterasi berikutnya
          messages.add(MessageParam.builder()
                  .role(MessageParam.Role.USER)
                  .contentOfBlockParams(toolResults)
                  .build());
      }
      return messages;
  }

  /**
   * Run the computer-use agent loop until Haijun stops requesting tools
   * or the iteration limit is reached.
   */
  function samplingLoop(string $model, array $messages, int $maxIterations = 10): array
  {
      global $client, $tools;

      for ($i = 0; $i < $maxIterations; $i++) {
          $response = $client->messages->create(
              model: $model,
              maxTokens: 4096,
              messages: $messages,
              tools: $tools,
          );

          // Tambahkan respons Haijun ke riwayat percakapan
          $messages[] = MessageParam::with(role: Role::ASSISTANT, content: $response->content);

          // Jalankan alat yang diminta Haijun dan kumpulkan hasilnya
          $toolResults = processToolCalls($response);
          if ($toolResults === []) {
              return $messages; // No more tool use; task complete
          }

          // Kirim hasil alat kembali ke Haijun untuk iterasi berikutnya
          $messages[] = MessageParam::with(role: Role::USER, content: $toolResults);
      }

      return $messages;
  }

  # Jalankan loop agen computer-use hingga Haijun berhenti meminta alat
  # atau batas iterasi tercapai.
  def sampling_loop(model, messages, max_iterations: 10)
    max_iterations.times do
      response = CLIENT.messages.create(
        model: model,
        max_tokens: 4096,
        messages: messages,
        tools: TOOLS
      )

      # Tambahkan respons Haijun ke riwayat percakapan
      messages << { role: "assistant", content: response.content }

      # Jalankan aksi yang diminta Haijun, secara berurutan, dan kumpulkan hasilnya
      tool_results = process_tool_calls(response)
      return messages if tool_results.empty? # No more tool use; task complete

      # Kirim semua hasil kembali ke Haijun dalam satu pesan pengguna
      messages << { role: "user", content: tool_results }
    end

    messages
  end

  {
    "type": "tool_use",
    "id": "toolu_01Qg8m3XqC5aRy7tD2eS4jUg",
    "name": "left_click",
    "toolset_name": "computer",
    "input": { "coordinate": [500, 300], "text": "shift" }
  }

  {
    "type": "tool_use",
    "id": "toolu_01Ed6j9VnA3yPw5rB8cQ2gSe",
    "name": "left_click_drag",
    "toolset_name": "computer",
    "input": {
      "start_coordinate": [200, 300],
      "coordinate": [600, 300]
    }
  }

  {
    "type": "tool_use",
    "id": "toolu_01Yc5h8UmZ2xNv4qA7bP9fRd",
    "name": "scroll",
    "toolset_name": "computer",
    "input": {
      "coordinate": [500, 400],
      "scroll_direction": "down",
      "scroll_amount": 3
    }
  }

  {
    "type": "tool_use",
    "id": "toolu_01Sb4g7TkY9wLu3pX6zM8eQc",
    "name": "key",
    "toolset_name": "computer",
    "input": { "text": "Tab", "repeat": 4 }
  }

  {
    "type": "tool_use",
    "id": "toolu_01Kf7k2WpB4zQx6sC9dR3hTf",
    "name": "zoom",
    "toolset_name": "computer",
    "input": { "region": [100, 200, 400, 350] }
  }

  {
    "type": "tool_use",
    "id": "toolu_01Ekh3vqB6yTs2mNc4Rw8pLd",
    "name": "cursor_position",
    "toolset_name": "computer",
    "input": {}
  }

{
  "type": "computer_toolset_20260801",
  "configs": {
    "zoom": { "enabled": false }
  },
  "cache_control": { "type": "ephemeral" }
}

  # Data gambar placeholder; executor sungguhan menangkap layar dan mengembalikan byte PNG
  PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

  def capture_screenshot() -> list[ImageBlockParam]:
      # screenshot menjawab dengan blok gambar, bukan teks: kembalikan daftar konten hasil
      return [
          {
              "type": "image",
              "source": {"type": "base64", "media_type": "image/png", "data": PLACEHOLDER_PNG},
          }
      ]

  def click(coordinate=None):
      if coordinate is None:
          return "clicked at current cursor"
      x, y = coordinate
      return f"clicked at ({x}, {y})"

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

  def handle_computer_action(name, tool_input):
      match name:
          case "screenshot":
              return capture_screenshot()
          case "left_click":
              # coordinate bersifat opsional; tanpanya, klik di posisi kursor saat ini
              return click(tool_input.get("coordinate"))
          case "type":
              return type_text(tool_input["text"])
      # Tangani aksi lain sesuai kebutuhan
      raise ValueError(f"Unknown or unimplemented member: {name}")

  // Data gambar placeholder; eksekutor nyata menangkap layar sebagai byte PNG
  const PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

  function captureScreenshot(): Juglow.ImageBlockParam[] {
    // screenshot menjawab dengan blok gambar, bukan teks
    return [
      {
        type: "image",
        source: {
          type: "base64",
          media_type: "image/png",
          data: PLACEHOLDER_PNG,
        },
      },
    ];
  }

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

  function clickAtCursor(): string {
    return "clicked at the current cursor position";
  }

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

  function handleComputerAction(
    action: string,
    input: unknown,
  ): string | Juglow.ImageBlockParam[] {
    const params: object =
      typeof input === "object" && input !== null ? input : {};
    switch (action) {
      case "screenshot":
        return captureScreenshot();
      case "left_click":
        // coordinate bersifat opsional pada toolset; tanpanya, klik di posisi kursor
        if ("coordinate" in params && Array.isArray(params.coordinate)) {
          const [x, y] = params.coordinate;
          return clickAt(x, y);
        }
        return clickAtCursor();
      case "type":
        if ("text" in params) {
          return typeText(String(params.text));
        }
        break;
    }
    // Tangani aksi lain sesuai kebutuhan
    throw new Error(`Unknown or unimplemented member: ${action}`);
  }

  // Data gambar placeholder; eksekutor nyata menangkap layar dan mengembalikan byte PNG
  const string PlaceholderPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

  // screenshot menjawab dengan blok gambar, bukan teks: kembalikan daftar konten hasil
  List<Block> CaptureScreenshot() =>
      [
          new ImageBlockParam(
              new Base64ImageSource { Data = PlaceholderPng, MediaType = MediaType.ImagePng }
          ),
      ];

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

  string ClickAtCursor() => "clicked at the current cursor position";

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

  ToolResultBlockParamContent HandleComputerAction(
      string action,
      IReadOnlyDictionary<string, JsonElement> input
  ) =>
      action switch
      {
          "screenshot" => CaptureScreenshot(),
          // coordinate bersifat opsional pada anggota click; tanpanya, klik di posisi kursor saat ini
          "left_click" when input.TryGetValue("coordinate", out var xy) => ClickAt(
              xy[0].GetInt32(),
              xy[1].GetInt32()
          ),
          "left_click" => ClickAtCursor(),
          "type" => TypeText(input["text"].GetString()!),
          // Tangani aksi lain sesuai kebutuhan
          _ => throw new NotSupportedException($"Unknown or unimplemented member: {action}"),
      };

  // placeholderPNG menggantikan tangkapan layar nyata: executor mengembalikan
  // layar sebagai data PNG yang dienkode base64.
  const placeholderPNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

  // captureScreenshot mengembalikan blok gambar, bukan teks.
  func captureScreenshot() []juglow.ToolResultBlockParamContentUnion {
  	return []juglow.ToolResultBlockParamContentUnion{{
  		OfImage: &juglow.ImageBlockParam{
  			Source: juglow.ImageBlockParamSourceUnion{
  				OfBase64: &juglow.Base64ImageSourceParam{
  					MediaType: juglow.Base64ImageSourceMediaTypeImagePNG,
  					Data:      placeholderPNG,
  				},
  			},
  		},
  	}}
  }

  // textContent membungkus teks sebagai konten tool_result.
  func textContent(text string) []juglow.ToolResultBlockParamContentUnion {
  	return []juglow.ToolResultBlockParamContentUnion{
  		{OfText: &juglow.TextBlockParam{Text: text}},
  	}
  }

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

  func clickAtCursor() string {
  	return "clicked at the current cursor position"
  }

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

  func handleComputerAction(action string, params map[string]any) ([]juglow.ToolResultBlockParamContentUnion, error) {
  	switch action {
  	case "screenshot":
  		return captureScreenshot(), nil
  	case "left_click":
  		// coordinate bersifat opsional; tanpanya, klik di posisi kursor saat ini
  		coord, ok := params["coordinate"].([]any)
  		if !ok {
  			return textContent(clickAtCursor()), nil
  		}
  		if len(coord) == 2 {
  			x, xok := coord[0].(float64)
  			y, yok := coord[1].(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
  		}
  	// Tangani aksi lain sesuai kebutuhan
  	default:
  		return nil, fmt.Errorf("unknown or unimplemented member: %s", action)
  	}
  	// Tercapai saat input anggota tidak memiliki field atau field bertipe salah
  	return nil, fmt.Errorf("invalid input for %s", action)
  }

  /** Placeholder pixels; a real executor captures the screen 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 clickAt(long x, long y) {
      return "clicked at (" + x + ", " + y + ")";
  }

  String clickAtCursor() {
      return "clicked at current cursor";
  }

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

  /** Runs one computer toolset member; {@code action} is the tool_use block's name. */
  ToolResultBlockParam.Content handleComputerAction(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 "left_click" -> {
              JsonValue coordinate = input.get("coordinate"); // optional on the toolset
              if (coordinate == null) {
                  yield clickAtCursor();
              }
              List<JsonValue> point = (List<JsonValue>) coordinate.asArray().get();
              long x = ((Number) point.get(0).asNumber().get()).longValue();
              long y = ((Number) point.get(1).asNumber().get()).longValue();
              yield clickAt(x, y);
          }
          case "type" -> typeText(input.get("text").asStringOrThrow());
          // Tangani aksi lain sesuai kebutuhan
          default -> throw new UnsupportedOperationException("Unknown or unimplemented member: " + action);
      };
      return ToolResultBlockParam.Content.ofString(output);
  }

  // Pengganti untuk byte PNG asli; eksekutor nyata menangkap layar
  const PLACEHOLDER_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';

  function captureScreenshot(): array
  {
      // screenshot menjawab dengan blok gambar, bukan teks, jadi kembalikan daftar konten hasil
      $image = [
          'type' => 'image',
          'source' => ['type' => 'base64', 'media_type' => 'image/png', 'data' => PLACEHOLDER_PNG],
      ];

      return [$image];
  }

  function clickAt(?array $coordinate): string
  {
      // left_click boleh tanpa coordinate; jika demikian, klik terjadi di posisi kursor saat ini
      if ($coordinate === null) {
          return 'clicked at current cursor';
      }
      [$x, $y] = $coordinate;

      return "clicked at ({$x}, {$y})";
  }

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

  function handleComputerAction(string $name, array $input): string|array
  {
      return match ($name) {
          'screenshot' => captureScreenshot(),
          'left_click' => clickAt($input['coordinate'] ?? null),
          'type' => typeText($input['text']),
          // Tangani aksi lain sesuai kebutuhan
          default => throw new RuntimeException("Unknown or unimplemented member: {$name}"),
      };
  }

  # Data gambar pengganti; eksekutor nyata menangkap layar sebagai PNG.
  PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

  # screenshot menjawab dengan blok gambar, bukan teks
  def capture_screenshot
    [
      {
        type: "image",
        source: { type: "base64", media_type: "image/png", data: PLACEHOLDER_PNG }
      }
    ]
  end

  def click(coordinate = nil)
    return "clicked at current cursor" if coordinate.nil?

    x, y = coordinate
    "clicked at (#{x}, #{y})"
  end

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

  def handle_computer_action(name, input)
    case name
    when "screenshot"
      capture_screenshot
    when "left_click"
      # coordinate bersifat opsional; tanpanya, klik di posisi kursor saat ini
      click(input[:coordinate])
    when "type"
      type_text(input[:text])
    # Tangani aksi lain sesuai kebutuhan
    else
      raise ArgumentError, "Unknown or unimplemented member: #{name}"
    end
  end

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

  def process_tool_calls(response: Message) -> list[ToolResultBlockParam]:
      """
      Run the computer actions in Haijun's response in order and answer each
      one. After the first failure the rest are skipped, because Haijun planned
      them assuming the earlier actions succeeded.
      """
      tool_results: list[ToolResultBlockParam] = []
      failed = False
      for block in response.content:
          # Hanya toolset computer yang dideklarasikan; arahkan alat lain ke sini jika Anda menambahkannya
          if block.type != "tool_use" or block.toolset_name != "computer":
              continue
          result: ToolResultBlockParam = {
              "type": "tool_result",
              "tool_use_id": block.id,
              "toolset_name": "computer",
          }
          if failed:
              result["content"] = NOT_EXECUTED
              result["is_error"] = True
          else:
              try:
                  # Sebuah string, atau daftar blok konten seperti gambar screenshot
                  result["content"] = handle_computer_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

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

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

  function processToolCalls(
    response: Juglow.Message,
  ): Juglow.ToolResultBlockParam[] {
    const toolResults: Juglow.ToolResultBlockParam[] = [];
    let failed = false;
    for (const block of response.content) {
      if (block.type !== "tool_use") {
        continue;
      }
      if (block.toolset_name !== "computer") {
        // Contoh ini hanya mendeklarasikan toolset computer; arahkan alat lain
        // ke sini jika Anda menambahkannya.
        continue;
      }
      if (failed) {
        // Batch berhenti pada kegagalan pertama; jawab aksi berikutnya sebagai tidak dieksekusi
        toolResults.push(computerResult(block.id, HALT_TEXT, true));
        continue;
      }
      try {
        // Sebuah string, atau daftar blok gambar yang dikembalikan screenshot
        const result = handleComputerAction(block.name, block.input);
        toolResults.push(computerResult(block.id, result));
      } catch (error) {
        failed = true;
        const message = error instanceof Error ? error.message : String(error);
        toolResults.push(computerResult(block.id, `Error: ${message}`, true));
      }
    }
    return toolResults;
  }

  const string HaltText = "Not executed: an earlier computer 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 != "computer")
          {
              // Contoh ini hanya mendeklarasikan toolset computer; arahkan alat lain
              // ke sini jika Anda menambahkannya.
              continue;
          }

          if (failed)
          {
              // Batch berhenti pada kegagalan pertamanya; jawab aksi berikutnya tanpa menjalankannya
              toolResults.Add(
                  new ToolResultBlockParam(toolUse.ID)
                  {
                      Content = HaltText,
                      IsError = true,
                      ToolsetName = "computer",
                  }
              );
              continue;
          }

          try
          {
              // Sebuah string, atau daftar blok gambar yang dikembalikan screenshot
              var result = HandleComputerAction(toolUse.Name, toolUse.Input);
              toolResults.Add(
                  new ToolResultBlockParam(toolUse.ID) { Content = result, ToolsetName = "computer" }
              );
          }
          catch (Exception e)
          {
              failed = true;
              toolResults.Add(
                  new ToolResultBlockParam(toolUse.ID)
                  {
                      Content = $"Error: {e.Message}",
                      IsError = true,
                      ToolsetName = "computer",
                  }
              );
          }
      }
      return toolResults;
  }

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

  // computerToolResult membangun hasil untuk satu aksi komputer. Berbeda dengan
  // hasil alat biasa, ia harus menyertakan kembali nama toolset.
  func computerToolResult(toolUseID string, content []juglow.ToolResultBlockParamContentUnion, isError bool) juglow.ContentBlockParamUnion {
  	result := juglow.ToolResultBlockParam{
  		ToolUseID:   toolUseID,
  		ToolsetName: juglow.String("computer"),
  		Content:     content,
  	}
  	if isError {
  		result.IsError = juglow.Bool(true)
  	}
  	return juglow.ContentBlockParamUnion{OfToolResult: &result}
  }

  // processToolCalls menjalankan aksi komputer dalam respons Haijun secara berurutan dan
  // membangun satu tool_result per blok tool_use. Setelah kegagalan pertama, sisanya
  // dilewati: Haijun merencanakannya dengan asumsi aksi sebelumnya berhasil.
  func processToolCalls(response *juglow.Message) []juglow.ContentBlockParamUnion {
  	var toolResults []juglow.ContentBlockParamUnion
  	failed := false
  	for _, block := range response.Content {
  		switch variant := block.AsAny().(type) {
  		case juglow.ToolUseBlock:
  			// Contoh ini hanya mendeklarasikan toolset komputer; arahkan alat lain ke sini jika Anda menambahkannya.
  			if variant.ToolsetName != "computer" {
  				continue
  			}
  			if failed {
  				toolResults = append(toolResults, computerToolResult(variant.ID, textContent(notExecuted), true))
  				continue
  			}
  			var input map[string]any
  			var content []juglow.ToolResultBlockParamContentUnion
  			err := json.Unmarshal(variant.Input, &input)
  			if err == nil {
  				// Teks, atau blok gambar yang dikembalikan screenshot
  				content, err = handleComputerAction(variant.Name, input)
  			}
  			if err != nil {
  				failed = true
  				content = textContent("Error: " + err.Error())
  			}
  			toolResults = append(toolResults, computerToolResult(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 computer action in this turn failed.";

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

  /**
   * Run the computer actions in Haijun's response in order and build one
   * tool_result per tool_use block. After the first failure, skip the rest:
   * Haijun 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()) {
          // Contoh ini hanya mendeklarasikan toolset computer; arahkan alat lain ke sini jika Anda menambahkannya.
          if (!block.isToolUse() || !block.asToolUse().toolsetName().equals(Optional.of("computer"))) {
              continue;
          }
          ToolUseBlock toolUse = block.asToolUse();
          ToolResultBlockParam result;
          if (failed) {
              result = computerResult(toolUse).content(HALT_TEXT).isError(true).build();
          } else {
              try {
                  Map<String, JsonValue> input =
                          (Map<String, JsonValue>) toolUse._input().asObject().get();
                  // Sebuah string, atau blok gambar yang dikembalikan oleh screenshot
                  ToolResultBlockParam.Content output = handleComputerAction(toolUse.name(), input);
                  result = computerResult(toolUse).content(output).build();
              } catch (RuntimeException e) {
                  failed = true;
                  result = computerResult(toolUse).content("Error: " + e.getMessage()).isError(true).build();
              }
          }
          toolResults.add(ContentBlockParam.ofToolResult(result));
      }
      return toolResults;
  }

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

  function processToolCalls(Message $response): array
  {
      $toolResults = [];
      $failed = false;
      foreach ($response->content as $block) {
          // Contoh ini hanya mendeklarasikan toolset computer; arahkan alat lain ke sini jika Anda menambahkannya.
          if (!($block instanceof \Juglow\Messages\ToolUseBlock) || $block->toolsetName !== 'computer') {
              continue;
          }
          $result = ['type' => 'tool_result', 'tool_use_id' => $block->id, 'toolset_name' => 'computer'];
          if ($failed) {
              // Batch berhenti pada kegagalan pertama; aksi sisanya dijawab tanpa dijalankan
              $toolResults[] = [...$result, 'content' => HALT_TEXT, 'is_error' => true];
              continue;
          }
          try {
              // Sebuah string, atau daftar blok gambar yang dikembalikan screenshot
              $toolResults[] = [...$result, 'content' => handleComputerAction($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 computer action in this turn failed."

  # Jalankan aksi komputer dalam respons Haijun secara berurutan dan buat satu
  # tool_result per blok tool_use. Setelah kegagalan pertama, lewati sisanya:
  # Haijun merencanakannya dengan asumsi aksi sebelumnya berhasil.
  def process_tool_calls(response)
    tool_results = []
    failed = false
    response.content.each do |block|
      # Contoh ini hanya mendeklarasikan toolset komputer; arahkan alat lain ke sini
      # jika Anda menambahkannya.
      next unless block.type == :tool_use && block.toolset_name == "computer"

      result = { type: "tool_result", tool_use_id: block.id, toolset_name: "computer" }
      if failed
        result.update(content: NOT_EXECUTED, is_error: true)
      else
        begin
          # Sebuah String, atau blok konten gambar yang dikembalikan screenshot
          result[:content] = handle_computer_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

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "toolset_name": "computer",
      "content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
      "is_error": true
    }
  ]
}

  import math

  screen_width, screen_height = 1512, 982

  def get_scale_factor(width, height):
      """Calculate scale factor to meet API constraints."""
      long_edge = max(width, height)
      total_pixels = width * height

      long_edge_scale = 1568 / long_edge
      total_pixels_scale = math.sqrt(1_150_000 / total_pixels)

      return min(1.0, long_edge_scale, total_pixels_scale)

  # Saat mengambil tangkapan layar
  scale = get_scale_factor(screen_width, screen_height)
  scaled_width = int(screen_width * scale)
  scaled_height = int(screen_height * scale)

  # Ubah ukuran gambar ke dimensi yang diskalakan sebelum mengirimnya ke Haijun
  screenshot = capture_and_resize(scaled_width, scaled_height)

  # Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran semula
  def execute_click(x, y):
      screen_x = x / scale
      screen_y = y / scale
      perform_click(screen_x, screen_y)

  const screenWidth = 1512;
  const screenHeight = 982;
  const MAX_LONG_EDGE = 1568;
  const MAX_PIXELS = 1_150_000;

  function getScaleFactor(width: number, height: number): number {
    const longEdge = Math.max(width, height);
    const totalPixels = width * height;

    const longEdgeScale = MAX_LONG_EDGE / longEdge;
    const totalPixelsScale = Math.sqrt(MAX_PIXELS / totalPixels);

    return Math.min(1.0, longEdgeScale, totalPixelsScale);
  }

  // Saat mengambil tangkapan layar
  const scale = getScaleFactor(screenWidth, screenHeight);
  const scaledWidth = Math.floor(screenWidth * scale);
  const scaledHeight = Math.floor(screenHeight * scale);

  // Ubah ukuran gambar ke dimensi yang diskalakan sebelum dikirim ke Haijun
  const screenshot = captureAndResize(scaledWidth, scaledHeight);

  // Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran asli
  function executeClick(x: number, y: number): void {
    const screenX = x / scale;
    const screenY = y / scale;
    performClick(screenX, screenY);
  }

  int screenWidth = 1512, screenHeight = 982;

  double GetScaleFactor(int width, int height)
  {
      // Hitung faktor skala untuk memenuhi batasan API.
      int longEdge = Math.Max(width, height);
      int totalPixels = width * height;

      double longEdgeScale = 1568.0 / longEdge;
      double totalPixelsScale = Math.Sqrt(1_150_000.0 / totalPixels);

      return Math.Min(1.0, Math.Min(longEdgeScale, totalPixelsScale));
  }

  // Saat mengambil tangkapan layar
  double scale = GetScaleFactor(screenWidth, screenHeight);
  int scaledWidth = (int)(screenWidth * scale);
  int scaledHeight = (int)(screenHeight * scale);

  // Ubah ukuran gambar ke dimensi yang telah diskalakan sebelum mengirim ke Haijun
  var screenshot = CaptureAndResize(scaledWidth, scaledHeight);

  // Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran semula
  void ExecuteClick(int x, int y)
  {
      double screenX = x / scale;
      double screenY = y / scale;
      PerformClick(screenX, screenY);
  }

  func getScaleFactor(width, height int) float64 {
  	longest := float64(max(width, height))
  	area := float64(width * height)
  	return min(1.0, 1568/longest, math.Sqrt(1_150_000/area))
  }

  // ...
  	screenWidth, screenHeight := 1512, 982

  	// Saat mengambil tangkapan layar
  	scale := getScaleFactor(screenWidth, screenHeight)
  	scaledWidth := int(float64(screenWidth) * scale)
  	scaledHeight := int(float64(screenHeight) * scale)

  	// Ubah ukuran gambar ke dimensi yang diskalakan sebelum dikirim ke Haijun
  	screenshot := captureAndResize(scaledWidth, scaledHeight)

  	// Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran asli
  	executeClick := func(x, y int) {
  		performClick(float64(x)/scale, float64(y)/scale)
  	}

  static double getScaleFactor(int width, int height) {
      return Math.min(
          1.0,
          Math.min(
              1568.0 / Math.max(width, height),
              Math.sqrt(1_150_000.0 / (width * height))
          )
      );
  }

  void main() {
      int screenWidth = 1512, screenHeight = 982;

      // Saat mengambil tangkapan layar
      double scale = getScaleFactor(screenWidth, screenHeight);
      int scaledWidth = (int)(screenWidth * scale);
      int scaledHeight = (int)(screenHeight * scale);

      // Ubah ukuran gambar ke dimensi yang diskalakan sebelum mengirim ke Haijun
      var screenshot = captureAndResize(scaledWidth, scaledHeight);

      // Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran asli
      BiConsumer<Integer, Integer> executeClick =
          (x, y) -> performClick(x / scale, y / scale);
  // ...
  }

  function getScaleFactor(int $width, int $height): float
  {
      return min(
          1.0,
          1568 / max($width, $height),
          sqrt(1_150_000 / ($width * $height)),
      );
  }

  $screenWidth = 1512;
  $screenHeight = 982;

  // Saat mengambil tangkapan layar
  $scale = getScaleFactor($screenWidth, $screenHeight);
  $scaledWidth = (int)($screenWidth * $scale);
  $scaledHeight = (int)($screenHeight * $scale);

  // Ubah ukuran gambar ke dimensi yang diskalakan sebelum mengirim ke Haijun
  $screenshot = captureAndResize($scaledWidth, $scaledHeight);

  // Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran asli
  $executeClick = fn(int $x, int $y) => performClick($x / $scale, $y / $scale);

  def get_scale_factor(width, height)
    [1.0, 1568.0 / [width, height].max, Math.sqrt(1_150_000.0 / (width * height))].min
  end

  screen_width, screen_height = 1512, 982

  # Saat mengambil tangkapan layar
  scale = get_scale_factor(screen_width, screen_height)
  scaled_width = (screen_width * scale).to_i
  scaled_height = (screen_height * scale).to_i

  # Ubah ukuran gambar ke dimensi yang diskalakan sebelum mengirim ke Haijun
  screenshot = capture_and_resize(scaled_width, scaled_height)

  # Saat menangani koordinat dari Haijun, skalakan kembali ke ukuran asli
  execute_click = ->(x, y) { perform_click(x / scale, y / scale) }

      def click_and_wait(x, y, wait_time=0.5):
          click_at(x, y)
          time.sleep(wait_time)  # Allow UI to update

      async function clickAndWait(x: number, y: number, waitMs = 500): Promise<void> {
        clickAt(x, y);
        await setTimeout(waitMs); // Allow UI to update
      }

      static void ClickAndWait(int x, int y, double waitSeconds = 0.5)
      {
          ClickAt(x, y);
          Thread.Sleep(TimeSpan.FromSeconds(waitSeconds));  // Allow UI to update
      }

      func clickAndWaitFor(x, y int, wait time.Duration) {
      	clickAt(x, y)
      	time.Sleep(wait) // Allow UI to update
      }

      func clickAndWait(x, y int) {
      	clickAndWaitFor(x, y, 500*time.Millisecond)
      }

      void clickAndWait(int x, int y) throws InterruptedException {
          clickAndWait(x, y, 500);
      }

      void clickAndWait(int x, int y, long waitTimeMillis) throws InterruptedException {
          clickAt(x, y);
          Thread.sleep(waitTimeMillis);  // Allow UI to update
      }

      function clickAndWait(int $x, int $y, float $waitSeconds = 0.5): void
      {
          clickAt($x, $y);
          usleep((int) ($waitSeconds * 1_000_000));  // Allow UI to update
      }

      def click_and_wait(x, y, wait_time: 0.5)
        click_at(x, y)
        sleep(wait_time) # Allow UI to update
      end

      display_width, display_height = 1024, 768

      def validate_action(action_type, params):
          if action_type == "left_click" and "coordinate" in params:
              x, y = params["coordinate"]
              if not (0 <= x < display_width and 0 <= y < display_height):
                  return False, "Coordinates out of bounds"
          return True, None

      const displayWidth = 1024;
      const displayHeight = 768;

      interface ActionParams {
        coordinate?: [number, number];
      }

      function validateAction(actionType: string, params: ActionParams): [boolean, string | null] {
        if (actionType === "left_click" && params.coordinate) {
          const [x, y] = params.coordinate;
          if (!(x >= 0 && x < displayWidth && y >= 0 && y < displayHeight)) {
            return [false, "Coordinates out of bounds"];
          }
        }
        return [true, null];
      }

      const int DisplayWidth = 1024;
      const int DisplayHeight = 768;
      // ...
      static (bool IsValid, string? Error) ValidateAction(string actionType, IReadOnlyDictionary<string, JsonElement> parameters)
      {
          if (actionType == "left_click" && parameters.TryGetValue("coordinate", out JsonElement coordinate))
          {
              int x = coordinate[0].GetInt32();
              int y = coordinate[1].GetInt32();
              if (x is < 0 or >= DisplayWidth || y is < 0 or >= DisplayHeight)
              {
                  return (false, "Coordinates out of bounds");
              }
          }
          return (true, null);
      }

      const (
      	displayWidth  = 1024
      	displayHeight = 768
      )

      func validateAction(actionType string, params map[string]any) (bool, string) {
      	raw, hasCoordinate := params["coordinate"]
      	if actionType == "left_click" && hasCoordinate {
      		coord, ok := raw.([]any)
      		if !ok || len(coord) != 2 {
      			return false, "Invalid coordinate"
      		}
      		x, y := int(coord[0].(float64)), int(coord[1].(float64))
      		if !(0 <= x && x < displayWidth && 0 <= y && y < displayHeight) {
      			return false, "Coordinates out of bounds"
      		}
      	}
      	return true, ""
      }

      static final int DISPLAY_WIDTH = 1024;
      static final int DISPLAY_HEIGHT = 768;

      record Validation(boolean valid, String error) {}

      Validation validateAction(String actionType, Map<String, JsonValue> params) {
          if (actionType.equals("left_click") && params.containsKey("coordinate")) {
              List<JsonValue> coord = (List<JsonValue>) params.get("coordinate").asArray().get();
              long x = ((Number) coord.get(0).asNumber().get()).longValue();
              long y = ((Number) coord.get(1).asNumber().get()).longValue();
              if (!(0 <= x && x < DISPLAY_WIDTH && 0 <= y && y < DISPLAY_HEIGHT)) {
                  return new Validation(false, "Coordinates out of bounds");
              }
          }
          return new Validation(true, null);
      }

      const DISPLAY_WIDTH = 1024;
      const DISPLAY_HEIGHT = 768;

      /** @return array{bool, ?string} */
      function validateAction(string $actionType, array $params): array
      {
          if ($actionType === 'left_click' && isset($params['coordinate'])) {
              [$x, $y] = $params['coordinate'];
              if (!(0 <= $x && $x < DISPLAY_WIDTH && 0 <= $y && $y < DISPLAY_HEIGHT)) {
                  return [false, 'Coordinates out of bounds'];
              }
          }
          return [true, null];
      }

      DISPLAY_WIDTH = 1024
      DISPLAY_HEIGHT = 768

      def validate_action(action_type, params)
        if action_type == "left_click" && params.key?(:coordinate)
          x, y = params[:coordinate]
          unless (0...DISPLAY_WIDTH).cover?(x) && (0...DISPLAY_HEIGHT).cover?(y)
            return [false, "Coordinates out of bounds"]
          end
        end
        [true, nil]
      end

      import logging

      def log_action(action_type, params, result):
          logging.info(f"Action: {action_type}, Params: {params}, Result: {result}")

      function logAction(actionType: string, params: unknown, result: unknown): void {
        console.error(
          `Action: ${actionType}, Params: ${JSON.stringify(params)}, Result: ${JSON.stringify(
            result
          )}`
        );
      }

      static void LogAction(string actionType, object? parameters, object? result)
      {
          Console.Error.WriteLine($"Action: {actionType}, Params: {parameters}, Result: {result}");
      }

      func logAction(actionType string, params map[string]any, result any) {
      	log.Printf("Action: %s, Params: %v, Result: %v", actionType, params, result)
      }

      import static java.lang.System.Logger.Level.INFO;

      static final System.Logger LOGGER = System.getLogger("computer-use");

      void logAction(String actionType, Object params, Object result) {
          LOGGER.log(INFO, "Action: {0}, Params: {1}, Result: {2}", actionType, params, result);
      }

      function logAction(string $actionType, array $params, mixed $result): void
      {
          error_log(sprintf(
              'Action: %s, Params: %s, Result: %s',
              $actionType,
              json_encode($params),
              json_encode($result),
          ));
      }

      require "logger"

      LOGGER = Logger.new($stderr)

      def log_action(action_type, params, result)
        LOGGER.info("Action: #{action_type}, Params: #{params}, Result: #{result}")
      end

{
  "type": "computer_20251124",
  "name": "computer",
  "display_width_px": 1024,
  "display_height_px": 768,
  "display_number": 1
}

{
  "type": "computer_toolset_20260801",
  "configs": {
    "zoom": { "enabled": false }
  }
}

{
  "type": "tool_use",
  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
  "name": "computer",
  "input": { "action": "left_click", "coordinate": [500, 300] }
}

{
  "type": "tool_use",
  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
  "name": "left_click",
  "toolset_name": "computer",
  "input": { "coordinate": [500, 300] }
}