ハーネス設計が新しいソフトウェアエンジニアリングになる

---
name: sapporo-orgchart-qa
description: 札幌市の機構図について、局・部の一覧や所属を自然文で質問されたときに使う。税、交通、組織図、機構図、どの局・どの部かという質問が対象。
---

# 札幌市 機構図 Q&A

札幌市の機構図に関する質問には、必ず `get_sapporo_orgchart` custom tool を呼ぶ。

## 手順

1. `get_sapporo_orgchart` を入力なしで呼ぶ。
2. 返却されたJSONの `bureaus` と `departments` だけを根拠に答える。
3. 回答にはJSONの `year` を添える。
4. JSONにない内容は推測せず、「抽出データでは確認できない」と答える。
5. 電話番号・職員名は、明示的に聞かれない限り出力しない。

## JSONの形

```json
{
  "source": "令和8年度 札幌市機構図",
  "year": "令和8年度",
  "bureaus": ["財政局"],
  "departments": {
    "財政局": ["財政部", "税政部", "管財部"]
  }
}
```

取得元とパース条件は `references/` を参照する。

# 機構図パース規則

## 目次から局一覧を取得する

局などの上位組織は本文の住所や説明にも現れるため、一覧と数え上げには目次を使う。

- 「名称 + ドットリーダー + ページ番号」の行から名称を抽出する。
- 名称が `局` で終わるものを候補にする。
- `委員会` を含むものと `事務局` で終わるものは除外する。

## 本文から局と部を対応付ける

本文を上から順に走査する。

1. 目次から得た局名と完全一致する単独行を見つけたら、現在の局を切り替える。
2. その後に現れる行の先頭トークンが `○○部長` なら、`長` を除いた `○○部` を現在の局へ紐づける。
3. `担当部長` と `副○○部長` は組織上の部ではないため除外する。
4. 同じ部名が複数回現れても重複させない。

## 注意

- PDFBoxはOCRではない。画像だけのPDFには別途OCRが必要。
- PDFの段組みや文字配置が年度版で変わると、読み順と改行が変化する可能性がある。
- 年度によって組織は変わるため、回答には必ず版を付ける。
- 電話番号・職員名は、明示的に聞かれない限り出力しない。

{
  "sources": [
    {
      "id": "orgchart-r8",
      "name": "令和8年度 札幌市機構図",
      "type": "orgchart",
      "year": "令和8年度",
      "url": "https://www.city.sapporo.jp/org/address/documents/r8kikouzu.pdf"
    }
  ]
}

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Comparator;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * sapporo-orgchart-qa/ を配布用の .skill（ZIP）へまとめる。
 *
 * ZIP内にはトップレベルディレクトリを残す。
 *
 * sapporo-orgchart-qa.skill
 * └── sapporo-orgchart-qa/
 *     ├── SKILL.md
 *     └── references/
 *         ├── parsing-notes.md
 *         └── sources.json
 */
public final class PackageSkill {

  private static final String SKILL_DIR = "sapporo-orgchart-qa";
  private static final String OUTPUT = SKILL_DIR + ".skill";

  private PackageSkill() {}

  public static void main(String[] args) throws IOException {
    Path skillRoot = Path.of(SKILL_DIR);
    Path skillMd = skillRoot.resolve("SKILL.md");
    if (!Files.isDirectory(skillRoot)) {
      throw new IOException("スキルディレクトリが見つかりません: " + skillRoot);
    }
    if (!Files.isRegularFile(skillMd)) {
      throw new IOException("SKILL.md が見つかりません: " + skillMd);
    }

    Path output = Path.of(OUTPUT);
    Files.deleteIfExists(output);

    try (ZipOutputStream zip = new ZipOutputStream(Files.newOutputStream(output));
        Stream<Path> paths = Files.walk(skillRoot)) {

      paths
          .filter(Files::isRegularFile)
          .filter(PackageSkill::shouldInclude)
          .sorted(Comparator.naturalOrder())
          .forEach(path -> addEntry(zip, path));
    }

    System.out.println("created: " + output.toAbsolutePath());
  }

  private static boolean shouldInclude(Path path) {
    String filename = path.getFileName().toString();
    return !filename.equals(".DS_Store") && !filename.endsWith("~");
  }

  private static void addEntry(ZipOutputStream zip, Path file) {
    String entryName = file.toString().replace(File.separatorChar, '/');

    try {
      zip.putNextEntry(new ZipEntry(entryName));
      Files.copy(file, zip);
      zip.closeEntry();
    } catch (IOException exception) {
      throw new IllegalStateException("ZIPへの追加に失敗しました: " + file, exception);
    }
  }
}

import static com.google.common.base.Preconditions.checkArgument;

import com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.text.Normalizer;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.pdfbox.Loader;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.text.PDFTextStripper;
import tools.jackson.databind.ObjectMapper;
import tools.jackson.databind.json.JsonMapper;

/**
 * 札幌市機構図を取得・解析し、Managed Agentsのcustom toolへ返すJSONを生成する。
 *
 * <p>LLMは呼ばない。次の処理だけを決定的に行う。
 *
 * <ol>
 *   <li>sources.jsonをJacksonで読む
 *   <li>PDFをJava HttpClientで取得する
 *   <li>PDFBoxでテキストを抽出する
 *   <li>Guavaを使い、局一覧と局→部の対応を不変コレクションへまとめる
 *   <li>JacksonでJSONを生成する
 * </ol>
 */
public final class OrgchartQa {

  private static final String SOURCE_ID = "orgchart-r8";
  private static final Path SKILL_DIR = Path.of("sapporo-orgchart-qa");
  private static final Path CATALOG = SKILL_DIR.resolve("references/sources.json");
  private static final Path CACHE_DIR = Path.of("target/data");
  private static final ObjectMapper JSON = JsonMapper.builder().build();
  private static final HttpClient HTTP =
      HttpClient.newBuilder()
          .followRedirects(HttpClient.Redirect.NORMAL)
          .connectTimeout(Duration.ofSeconds(20))
          .build();

  private static final Splitter TOKENS =
      Splitter.on(CharMatcher.whitespace()).trimResults().omitEmptyStrings();

  /** 目次の「組織名 + ドットリーダー + 任意のページ番号」。 */
  private static final Pattern INDEX_ROW =
      Pattern.compile("^(.+?)\\s*[・･…\\.]{3,}\\s*(?:[0-9０-９]+)?\\s*$");

  /** 行頭トークンが「○○部長」の場合に、○○部を取得する。 */
  private static final Pattern DEPARTMENT_HEAD = Pattern.compile("^(.+?部)長$");

  private OrgchartQa() {}

  /** ManagedAgentRunnerから呼ぶcustom toolの本体。 */
  public static String extractJson() throws IOException, InterruptedException {
    return JSON.writeValueAsString(extract());
  }

  /** custom tool失敗時も、文字列連結ではなくJacksonでJSONにする。 */
  public static String errorJson(String message) {
    Map<String, String> error =
        ImmutableMap.of(
            "error", "orgchart extraction failed", "message", Strings.nullToEmpty(message));
    return JSON.writeValueAsString(error);
  }

  /** 単体確認用。Managed Agentsを使わず抽出結果だけを整形表示する。 */
  public static void main(String[] args) throws Exception {
    System.out.println(JSON.writerWithDefaultPrettyPrinter().writeValueAsString(extract()));
  }

  private static OrgchartResult extract() throws IOException, InterruptedException {
    Source source = source(SOURCE_ID);
    String text = loadText(source);
    List<String> bureaus = bureaus(text);
    Map<String, List<String>> departments = departmentsByBureau(text, bureaus);

    return new OrgchartResult(source.name(), source.year(), bureaus, departments);
  }

  /** sources.jsonから資料IDに一致する定義を取得する。 */
  private static Source source(String sourceId) throws IOException {
    checkArgument(!Strings.isNullOrEmpty(sourceId), "sourceId is required");

    if (!Files.isRegularFile(CATALOG)) {
      throw new IOException("sources.jsonが見つかりません: " + CATALOG);
    }

    try (Reader reader = Files.newBufferedReader(CATALOG, StandardCharsets.UTF_8)) {
      Catalog catalog = JSON.readValue(reader, Catalog.class);
      if (catalog == null || catalog.sources() == null) {
        throw new IOException("sources.jsonの形式が不正です: sources がありません");
      }

      for (Source source : catalog.sources()) {
        if (source != null && sourceId.equals(source.id())) {
          validateSource(source);
          return source;
        }
      }
    }

    throw new IOException("sources.jsonに資料IDがありません: " + sourceId);
  }

  /** テキスト指定がなければ、PDF取得→PDFBox抽出を行う。 */
  private static String loadText(Source source) throws IOException, InterruptedException {
    checkArgument(source != null, "source is required");

    String textOverride = System.getenv("ORGCHART_TEXT_FILE");
    if (!Strings.isNullOrEmpty(textOverride)) {
      Path textFile = Path.of(textOverride);
      if (!Files.isRegularFile(textFile)) {
        throw new IOException("ORGCHART_TEXT_FILEが見つかりません: " + textFile);
      }
      return Files.readString(textFile, StandardCharsets.UTF_8);
    }

    Path pdf = downloadPdf(source);
    String text = extractPdfText(pdf);

    Files.createDirectories(CACHE_DIR);
    Files.writeString(CACHE_DIR.resolve(source.id() + ".txt"), text, StandardCharsets.UTF_8);

    return text;
  }

  /** PDFを一時ファイルへ取得し、PDFヘッダ確認後にキャッシュへ置く。 */
  private static Path downloadPdf(Source source) throws IOException, InterruptedException {
    checkArgument(source != null, "source is required");

    Files.createDirectories(CACHE_DIR);

    Path destination = CACHE_DIR.resolve(source.id() + ".pdf");
    boolean refresh = Boolean.parseBoolean(System.getenv().getOrDefault("REFRESH_SOURCE", "false"));

    if (!refresh && Files.isRegularFile(destination) && Files.size(destination) > 0) {
      return destination;
    }

    HttpRequest request =
        HttpRequest.newBuilder(URI.create(source.url()))
            .timeout(Duration.ofMinutes(2))
            .header("Accept", "application/pdf")
            .header("User-Agent", "fundoshi-harness-engineering-demo/1.0")
            .GET()
            .build();

    HttpResponse<byte[]> response = HTTP.send(request, HttpResponse.BodyHandlers.ofByteArray());

    if (response.statusCode() < 200 || response.statusCode() >= 300) {
      throw new IOException("PDF取得に失敗しました: HTTP " + response.statusCode() + " / " + source.url());
    }

    byte[] body = response.body();
    if (!looksLikePdf(body)) {
      String contentType = response.headers().firstValue("Content-Type").orElse("unknown");
      throw new IOException("取得内容がPDFではありません: Content-Type=" + contentType);
    }

    Path temporary = CACHE_DIR.resolve(source.id() + ".pdf.part");
    Files.write(temporary, body);
    try {
      Files.move(
          temporary,
          destination,
          StandardCopyOption.REPLACE_EXISTING,
          StandardCopyOption.ATOMIC_MOVE);
    } catch (AtomicMoveNotSupportedException exception) {
      Files.move(temporary, destination, StandardCopyOption.REPLACE_EXISTING);
    }

    return destination;
  }

  /** PDFBoxで文字レイヤーをプレーンテキストへ変換する。OCRは行わない。 */
  private static String extractPdfText(Path pdf) throws IOException {
    checkArgument(pdf != null, "pdf is required");

    if (!Files.isRegularFile(pdf)) {
      throw new IOException("PDFが見つかりません: " + pdf);
    }

    try (PDDocument document = Loader.loadPDF(new File(pdf.toString()))) {
      PDFTextStripper stripper = new PDFTextStripper();
      stripper.setSortByPosition(true);
      return stripper.getText(document);
    }
  }

  /** 目次形式の行から組織名を抜き出す。 */
  private static List<String> parseIndex(String text) {
    checkArgument(text != null, "text is required");

    ImmutableList.Builder<String> names = ImmutableList.builder();

    for (String raw : text.split("\\R")) {
      String line = normalize(raw);
      Matcher matcher = INDEX_ROW.matcher(line);

      if (matcher.matches()) {
        String name = matcher.group(1).strip();
        if (!name.isEmpty()) {
          names.add(name);
        }
      }
    }

    return names.build();
  }

  /** 委員会・事務局を除く執行機関としての「局」。 */
  private static List<String> bureaus(String text) {
    Set<String> unique = new LinkedHashSet<>();

    for (String name : parseIndex(text)) {
      if (name.endsWith("局") && !name.contains("委員会") && !name.endsWith("事務局")) {
        unique.add(name);
      }
    }

    return ImmutableList.copyOf(unique);
  }

  /** 本文を上から走査する。 単独行の局名でcurrentBureauを切り替え、行頭の「○○部長」を現在の局へ紐づける。 */
  private static Map<String, List<String>> departmentsByBureau(String text, List<String> bureaus) {

    checkArgument(text != null, "text is required");
    checkArgument(bureaus != null, "bureaus is required");

    Set<String> knownBureaus = ImmutableSet.copyOf(bureaus);
    Map<String, LinkedHashSet<String>> mutable = new LinkedHashMap<>();
    for (String bureau : bureaus) {
      mutable.put(bureau, new LinkedHashSet<>());
    }

    String currentBureau = null;

    for (String raw : text.split("\\R")) {
      String line = normalize(raw);

      if (knownBureaus.contains(line)) {
        currentBureau = line;
        continue;
      }

      if (currentBureau == null || line.isEmpty()) {
        continue;
      }

      List<String> tokens = TOKENS.splitToList(line);
      if (tokens.isEmpty()) {
        continue;
      }

      Matcher matcher = DEPARTMENT_HEAD.matcher(tokens.getFirst());
      if (!matcher.matches()) {
        continue;
      }

      String department = matcher.group(1);
      if (department.contains("担当") || department.contains("副")) {
        continue;
      }

      mutable.get(currentBureau).add(department);
    }

    ImmutableMap.Builder<String, List<String>> result = ImmutableMap.builder();
    mutable.forEach((bureau, departments) -> result.put(bureau, ImmutableList.copyOf(departments)));

    return result.buildOrThrow();
  }

  private static String normalize(String value) {
    String normalized = Normalizer.normalize(Strings.nullToEmpty(value), Normalizer.Form.NFKC);

    return normalized.replace('\u3000', ' ').strip();
  }

  private static boolean looksLikePdf(byte[] bytes) {
    return bytes != null
        && bytes.length >= 5
        && bytes[0] == '%'
        && bytes[1] == 'P'
        && bytes[2] == 'D'
        && bytes[3] == 'F'
        && bytes[4] == '-';
  }

  private static void validateSource(Source source) throws IOException {
    try {
      checkArgument(!Strings.isNullOrEmpty(source.id()), "id is required");
      checkArgument(!Strings.isNullOrEmpty(source.name()), "name is required");
      checkArgument(!Strings.isNullOrEmpty(source.year()), "year is required");
      checkArgument(!Strings.isNullOrEmpty(source.url()), "url is required");
    } catch (IllegalArgumentException exception) {
      throw new IOException("sources.jsonの資料定義に必須項目がありません: " + exception.getMessage(), exception);
    }
  }

  record Catalog(List<Source> sources) {}

  record Source(String id, String name, String type, String year, String url) {}

  record OrgchartResult(
      String source, String year, List<String> bureaus, Map<String, List<String>> departments) {}
}

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.MultipartField;
import com.anthropic.core.http.StreamResponse;
import com.anthropic.models.beta.agents.AgentCreateParams;
import com.anthropic.models.beta.agents.AgentUpdateParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
import com.anthropic.models.beta.agents.BetaManagedAgentsCustomToolInputSchema;
import com.anthropic.models.beta.agents.BetaManagedAgentsCustomToolParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
import com.anthropic.models.beta.agents.BetaManagedAgentsModelConfigParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;
import com.anthropic.models.beta.sessions.SessionCreateParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsStreamSessionEvents;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsTextBlock;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserCustomToolResultEventParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserMessageEventParams;
import com.anthropic.models.beta.sessions.events.EventSendParams;
import com.anthropic.models.beta.skills.SkillCreateParams;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/**
 * Managed Agentsのセットアップと実行を行うクライアント。
 *
 * セットアップ:
 *   mvn -q compile exec:java -Dexec.args="setup"
 *
 * 質問:
 *   ANTHROPIC_ENVIRONMENT_ID と ANTHROPIC_AGENT_ID を設定してから
 *   mvn -q compile exec:java -Dexec.args="税に関わる部はどの局？"
 */
public final class ManagedAgentRunner {

  static final String TOOL_NAME = "get_sapporo_orgchart";
  static final Path SKILL_DIRECTORY = Path.of("sapporo-orgchart-qa");

  private final AnthropicClient client;

  ManagedAgentRunner(AnthropicClient client) {
    this.client = client;
  }

  public static void main(String[] args) throws Exception {
    ManagedAgentRunner runner = new ManagedAgentRunner(AnthropicOkHttpClient.fromEnv());

    if (args.length > 0 && "setup".equalsIgnoreCase(args[0])) {
      SetupResult setup = runner.setup();
      System.out.println("created skill      : " + setup.skillId());
      System.out.println("created environment: " + setup.environmentId());
      System.out.println("created agent      : " + setup.agentId());
      System.out.println();
      System.out.println("export ANTHROPIC_ENVIRONMENT_ID=\"" + setup.environmentId() + "\"");
      System.out.println("export ANTHROPIC_AGENT_ID=\"" + setup.agentId() + "\"");
      return;
    }

    String environmentId = requiredEnvironment("ANTHROPIC_ENVIRONMENT_ID");
    String agentId = requiredEnvironment("ANTHROPIC_AGENT_ID");
    String question =
        args.length == 0 ? "税に関わる部はどの局にありますか。交通に関わる部も教えてください。" : String.join(" ", args);

    System.out.println("A." + runner.ask(environmentId, agentId, question));
  }

  /** Agent・Environment・Skillは最初に一度だけ作成し、IDを保存して使い回す。 */
  SetupResult setup() throws IOException {
    ensureSkillDirectory();

    var environment =
        client
            .beta()
            .environments()
            .create(EnvironmentCreateParams.builder().name("sapporo-orgchart-environment").build());

    String skillId = uploadSkill();

    var agentV1 =
        client
            .beta()
            .agents()
            .create(
                AgentCreateParams.builder()
                    .name("sapporo-orgchart-agent")
                    .model(
                        BetaManagedAgentsModelConfigParams.builder()
                            .id(BetaManagedAgentsModel.CLAUDE_SONNET_5)
                            .build())
                    .system("札幌市の機構図に関する質問には、添付スキルに従い、custom toolの結果だけを根拠に日本語で簡潔に答えてください。")
                    // Skillはサンドボックス内のSKILL.mdやreferencesをreadツールで読む。
                    // agent_toolsetを追加すると、readを含む組み込みツールが既定で有効になる。
                    .addTool(
                        BetaManagedAgentsAgentToolset20260401Params.builder()
                            .type(
                                BetaManagedAgentsAgentToolset20260401Params.Type
                                    .AGENT_TOOLSET_20260401)
                            .build())
                    .addTool(
                        BetaManagedAgentsCustomToolParams.builder()
                            .type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
                            .name(TOOL_NAME)
                            .description("札幌市の機構図から、局一覧と局から部への対応をJSONで返す。入力は不要。")
                            .inputSchema(
                                BetaManagedAgentsCustomToolInputSchema.builder()
                                    .properties(
                                        BetaManagedAgentsCustomToolInputSchema.Properties.builder()
                                            .build())
                                    .required(ImmutableList.of())
                                    .build())
                            .build())
                    .build());

    var agent =
        client
            .beta()
            .agents()
            .update(
                AgentUpdateParams.builder()
                    .agentId(agentV1.id())
                    .version(agentV1.version())
                    .addCustomSkill(skillId)
                    .build());

    return new SetupResult(environment.id(), agent.id(), skillId);
  }

  /** Sessionを毎回作成し、custom tool要求が来たらJava側でOrgchartQaを実行する。 */
  String ask(String environmentId, String agentId, String question)
      throws IOException, InterruptedException {

    checkArgument(!Strings.isNullOrEmpty(environmentId), "environmentId is required");
    checkArgument(!Strings.isNullOrEmpty(agentId), "agentId is required");
    checkArgument(!Strings.isNullOrEmpty(question), "question is required");

    var session =
        client
            .beta()
            .sessions()
            .create(
                SessionCreateParams.builder().environmentId(environmentId).agent(agentId).build());

    client
        .beta()
        .sessions()
        .events()
        .send(
            EventSendParams.builder()
                .sessionId(session.id())
                .addUserMessageEvent(
                    ImmutableList.of(
                        BetaManagedAgentsUserMessageEventParams.Content.ofText(
                            BetaManagedAgentsTextBlock.builder()
                                .type(BetaManagedAgentsTextBlock.Type.TEXT)
                                .text(question)
                                .build())))
                .build());

    System.out.println("Q." + question);
    System.out.println();

    StringBuilder answer = new StringBuilder();

    try (StreamResponse<BetaManagedAgentsStreamSessionEvents> response =
        client.beta().sessions().events().streamStreaming(session.id())) {

      Iterator<BetaManagedAgentsStreamSessionEvents> events = response.stream().iterator();

      while (events.hasNext()) {
        BetaManagedAgentsStreamSessionEvents event = events.next();

        if (event.isAgentCustomToolUse()) {
          var toolUse = event.asAgentCustomToolUse();

          if (TOOL_NAME.equals(toolUse.name())) {
            String toolResult = executeToolSafely();
            System.out.println("tool_result: " + toolResult);

            client
                .beta()
                .sessions()
                .events()
                .send(
                    EventSendParams.builder()
                        .sessionId(session.id())
                        .addEvent(
                            BetaManagedAgentsUserCustomToolResultEventParams.builder()
                                .type(
                                    BetaManagedAgentsUserCustomToolResultEventParams.Type
                                        .USER_CUSTOM_TOOL_RESULT)
                                .customToolUseId(toolUse.id())
                                .addTextContent(toolResult)
                                .build())
                        .build());
          }
        } else if (event.isAgentMessage()) {
          event.asAgentMessage().content().forEach(block -> answer.append(block.text()));
        } else if (event.isSessionError()) {
          throw new IllegalStateException(
              "Managed Agents session error: " + event.asSessionError());
        }

        if (event.isSessionStatusIdle() && event.asSessionStatusIdle().stopReason().isEndTurn()) {
          break;
        }
      }
    }

    if (answer.isEmpty()) {
      throw new IllegalStateException("エージェントの回答テキストを取得できませんでした");
    }

    return answer.toString().strip();
  }

  private String executeToolSafely() {
    try {
      return OrgchartQa.extractJson();
    } catch (Exception exception) {
      String message =
          exception.getMessage() == null
              ? exception.getClass().getSimpleName()
              : exception.getMessage();
      return OrgchartQa.errorJson(message);
    }
  }

  private String uploadSkill() throws IOException {
    var builder =
        SkillCreateParams.builder()
            .displayTitle("sapporo-orgchart-qa-" + System.currentTimeMillis());

    ImmutableList.Builder<Path> filesBuilder = ImmutableList.builder();
    try (var paths = Files.walk(SKILL_DIRECTORY)) {
      paths
          .filter(Files::isRegularFile)
          .filter(path -> !path.getFileName().toString().equals(".DS_Store"))
          .sorted(Comparator.naturalOrder())
          .forEach(filesBuilder::add);
    }
    List<Path> files = filesBuilder.build();

    for (Path file : files) {
      byte[] content = Files.readAllBytes(file);
      String filename =
          SKILL_DIRECTORY.getFileName()
              + "/"
              + SKILL_DIRECTORY.relativize(file).toString().replace('\\', '/');
      InputStream input = new ByteArrayInputStream(content);

      builder.addFile(
          MultipartField.<InputStream>builder().value(input).filename(filename).build());
    }

    return client.beta().skills().create(builder.build()).id();
  }

  private static void ensureSkillDirectory() throws IOException {
    if (!Files.isRegularFile(SKILL_DIRECTORY.resolve("SKILL.md"))) {
      throw new IOException("SKILL.mdが見つかりません: " + SKILL_DIRECTORY.resolve("SKILL.md"));
    }
    if (!Files.isRegularFile(SKILL_DIRECTORY.resolve("references/sources.json"))) {
      throw new IOException(
          "sources.jsonが見つかりません: " + SKILL_DIRECTORY.resolve("references/sources.json"));
    }
  }

  private static String requiredEnvironment(String name) {
    String value = System.getenv(name);
    checkState(!Strings.isNullOrEmpty(value), "%s を設定してください", name);
    return value;
  }

  record SetupResult(String environmentId, String agentId, String skillId) {}
}