Managed Agents から X に自動投稿する

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

import com.google.cloud.secretmanager.v1.AccessSecretVersionResponse;
import com.google.cloud.secretmanager.v1.SecretManagerServiceClient;
import com.google.cloud.secretmanager.v1.SecretName;
import com.google.cloud.secretmanager.v1.SecretPayload;
import com.google.cloud.secretmanager.v1.SecretVersionName;
import com.google.common.base.Strings;
import com.google.protobuf.ByteString;
import java.io.IOException;

/**
 * X の refresh token を Google Secret Manager で管理する。
 *
 * <p>Secret 自体はあらかじめ作成しておく。 更新時には既存 Secret に新しい SecretVersion を追加する。
 */
public class XRefreshTokenStore {

  private final String projectId;
  private final String secretId;

  XRefreshTokenStore(String projectId, String secretId) {
    checkState(!Strings.isNullOrEmpty(projectId) && !projectId.isBlank(), "GCP_PROJECT_ID を設定してください");
    checkState(!Strings.isNullOrEmpty(secretId) && !secretId.isBlank(), "X_REFRESH_TOKEN_SECRET_ID を設定してください");
    this.projectId = projectId;
    this.secretId = secretId;
  }

  /** Secret Manager の latest version から 現在の refresh token を取得する。 */
  String load() {
    SecretVersionName versionName = SecretVersionName.of(projectId, secretId, "latest");
    try (SecretManagerServiceClient client = SecretManagerServiceClient.create()) {
      AccessSecretVersionResponse response = client.accessSecretVersion(versionName);
      String refreshToken = response.getPayload().getData().toStringUtf8();
      checkState(!refreshToken.isBlank(), "Secret Manager の refresh token が空です");
      return refreshToken;
    } catch (IOException e) {
      throw new IllegalStateException("Secret Manager から refresh token を取得できませんでした", e);
    }
  }

  /** refresh token が変更された場合だけ 新しい SecretVersion として保存する。 */
  void saveIfChanged(String currentRefreshToken, String nextRefreshToken) {
    checkState(!Strings.isNullOrEmpty(nextRefreshToken) && !nextRefreshToken.isBlank(), "保存する refresh token が空です");

    /*
     * Xがrefresh_tokenを返さず、
     * 現在値をそのまま使う場合は
     * SecretVersionを増やさない。
     */
    if (nextRefreshToken.equals(currentRefreshToken)) {
      return;
    }

    SecretName secretName = SecretName.of(projectId, secretId);
    SecretPayload payload = SecretPayload.newBuilder().setData(ByteString.copyFromUtf8(nextRefreshToken)).build();

    try (SecretManagerServiceClient client = SecretManagerServiceClient.create()) {
      client.addSecretVersion(secretName, payload);
    } catch (IOException e) {
      throw new IllegalStateException("Secret Manager への refresh token 保存に失敗しました", e);
    }
  }
}

import static com.google.common.base.Preconditions.checkState;
import static java.nio.charset.StandardCharsets.UTF_8;

import com.google.common.base.Strings;
import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Base64;
import tools.jackson.databind.JsonNode;
import tools.jackson.databind.ObjectMapper;

/**
 * X OAuth 2.0 の refresh token を使って access token を更新する。
 *
 * <p>この処理はエージェントの外側で行う。 refresh token や client secret を Managed Agents のサンドボックスには渡さない。
 */
public class XTokenRefresher {

  private static final URI TOKEN_ENDPOINT = URI.create("https://api.x.com/2/oauth2/token");
  private static final ObjectMapper JSON = new ObjectMapper();

  /**
   * X token endpoint の更新結果。
   *
   * <p>refresh_token がレスポンスに含まれない場合は、呼び出し時に渡された refresh token をそのまま返す。
   */
  record Tokens(String accessToken, String refreshToken, long expiresInSeconds) {}

  private final String clientId;
  private final String clientSecret;
  private final HttpClient httpClient = HttpClient.newHttpClient();

  XTokenRefresher(String clientId, String clientSecret) {
    checkState(!Strings.isNullOrEmpty(clientId) && !clientId.isBlank(), "X_CLIENT_ID を設定してください");
    checkState(!Strings.isNullOrEmpty(clientSecret) && !clientSecret.isBlank(), "X_CLIENT_SECRET を設定してください");
    this.clientId = clientId;
    this.clientSecret = clientSecret;
  }

  /** refresh token から最新の access token を取得する。 */
  Tokens refresh(String refreshToken) {
    checkState(!Strings.isNullOrEmpty(refreshToken) && !refreshToken.isBlank(), "refresh token が空です");
    String form = "grant_type=refresh_token" + "&refresh_token=" + formEncode(refreshToken);
    String basic = Base64.getEncoder().encodeToString((clientId + ":" + clientSecret).getBytes(UTF_8));
    HttpRequest request =
        HttpRequest.newBuilder(TOKEN_ENDPOINT)
            .header("Content-Type", "application/x-www-form-urlencoded")
            .header("Accept", "application/json")
            .header("Authorization", "Basic " + basic)
            .POST(HttpRequest.BodyPublishers.ofString(form, UTF_8))
            .build();

    try {
      HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString(UTF_8));
      if (response.statusCode() < 200 || response.statusCode() >= 300) {
        throw new IllegalStateException(
            "X OAuth token refresh failed: HTTP "
                + response.statusCode()
                + " / "
                + sanitizeError(response.body()));
      }
      JsonNode body = JSON.readTree(response.body());
      String accessToken = requiredText(body, "access_token");
      long expiresIn = requiredPositiveLong(body, "expires_in");

      /*
       * X が refresh_token を返した場合は、
       * その値を次回用として採用する。
       *
       * 公式文書では refresh token のローテーション挙動が
       * 明示されていないため、返らなかった場合は
       * 現在の refresh token を使い続ける。
       */
      String nextRefreshToken = optionalText(body, "refresh_token", refreshToken);
      return new Tokens(accessToken, nextRefreshToken, expiresIn);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new IllegalStateException("X OAuth token refresh が中断されました", e);
    } catch (IOException e) {
      throw new IllegalStateException("X OAuth token refresh に失敗しました", e);
    }
  }

  private static String formEncode(String value) {
    return URLEncoder.encode(value, UTF_8);
  }

  private static String requiredText(JsonNode body, String name) {
    JsonNode value = body.get(name);
    checkState(value != null && value.isString() && !value.asString().isBlank(),
        "X OAuth response に %s がありません",
        name);
    return value.asString();
  }

  private static long requiredPositiveLong(JsonNode body, String name) {
    JsonNode value = body.get(name);
    checkState(value != null && value.isNumber(), "X OAuth response に %s がありません", name);
    long result = value.asLong();
    checkState(result > 0, "X OAuth response の %s が不正です: %s", name, result);
    return result;
  }

  private static String optionalText(JsonNode body, String name, String defaultValue) {
    JsonNode value = body.get(name);
    if (value == null || !value.isString() || value.asString().isBlank()) {
      return defaultValue;
    }
    return value.asString();
  }

  /** エラー本文全体をログに出さず、 error / error_description だけを取り出す。 */
  private static String sanitizeError(String responseBody) {
    try {
      JsonNode body = JSON.readTree(responseBody);
      String error = optionalText(body, "error", "unknown_error");
      String description = optionalText(body, "error_description", "");
      return description.isBlank() ? error : error + ": " + description;
    } catch (RuntimeException e) {
      return "response body could not be parsed";
    }
  }
}

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

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.core.http.StreamResponse;
import com.anthropic.models.beta.agents.AgentCreateParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolsetDefaultConfigParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsAlwaysAllowPolicy;
import com.anthropic.models.beta.agents.BetaManagedAgentsBashToolConfigParams;
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.BetaManagedAgentsUserMessageEventParams;
import com.anthropic.models.beta.sessions.events.EventSendParams;
import com.anthropic.models.beta.vaults.VaultCreateParams;
import com.anthropic.models.beta.vaults.credentials.BetaManagedAgentsEnvironmentVariableCreateParams;
import com.anthropic.models.beta.vaults.credentials.BetaManagedAgentsEnvironmentVariableUpdateParams;
import com.anthropic.models.beta.vaults.credentials.BetaManagedAgentsInjectionLocationParams;
import com.anthropic.models.beta.vaults.credentials.CredentialCreateParams;
import com.anthropic.models.beta.vaults.credentials.CredentialUpdateParams;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import java.util.Iterator;
import tools.jackson.databind.ObjectMapper;

/**
 * Managed Agents から X に投稿するデモ。
 *
 * <p>投稿用 access token は Anthropic Vault の environment_variable に保存する。 サンドボックスにはプレースホルダだけが置かれ、 実際の値は egress で差し替えられる。
 * <p>refresh token は Google Secret Manager に保存し、 エージェントの外側で X の token endpoint を呼び出して更新する。
 * <p>更新時には、新しい refresh token が返った場合は 先に Secret Manager に保存してから access token を Vault に書き戻す。
 *
 * <p>セットアップ:
 * <pre>
 * mvn -q compile exec:java -Dexec.args="setup"
 * </pre>
 *
 * <p>実行:
 * <pre>
 * mvn -q compile exec:java
 * </pre>
 */
public final class XPostingAgent {

  private static final ObjectMapper JSON = new ObjectMapper();
  private static final String X_API_HOST = "api.x.com";
  private static final String SECRET_NAME = "X_ACCESS_TOKEN";
  private static final String SYSTEM =
      """
      渡されたJSONを body にして、
      bash から次のリクエストを1回だけ送ってください。

      JSONは改変しないでください。
      トークンは環境変数 %s にあります。

      curl -sS -X POST https://%s/2/tweets \\
        -H "Authorization: Bearer $%s" \\
        -H "Content-Type: application/json" \\
        -d '<渡されたJSON>'

      レスポンスをそのまま報告してください。
      トークンの中身は出力しないでください。
      """
        .formatted(SECRET_NAME, X_API_HOST, SECRET_NAME);

  private static final String TEXT = "ぼくはまちちゃん";
  private final AnthropicClient client;
  private final XTokenRefresher refresher;
  private final XRefreshTokenStore refreshTokenStore;

  XPostingAgent(AnthropicClient client, XTokenRefresher refresher, XRefreshTokenStore refreshTokenStore) {
    this.client = client;
    this.refresher = refresher;
    this.refreshTokenStore = refreshTokenStore;
  }

  public static void main(String[] args) {
    String apiKey = System.getenv().getOrDefault("ANTHROPIC_API_KEY", "");
    if (apiKey.isBlank()) {
      System.out.println("ANTHROPIC_API_KEY を設定してください。");
      return;
    }
    XPostingAgent app =
        new XPostingAgent(
            AnthropicOkHttpClient.fromEnv(),
            new XTokenRefresher(requiredEnvironment("X_CLIENT_ID"), requiredEnvironment("X_CLIENT_SECRET")),
            new XRefreshTokenStore(
                requiredEnvironment("GCP_PROJECT_ID"),
                requiredEnvironment("X_REFRESH_TOKEN_SECRET_ID")));
    if (args.length > 0 && "setup".equalsIgnoreCase(args[0])) {
      app.setup();
      return;
    }

    app.run(
        requiredEnvironment("ANTHROPIC_ENVIRONMENT_ID"),
        requiredEnvironment("ANTHROPIC_AGENT_ID"),
        requiredEnvironment("ANTHROPIC_VAULT_ID"),
        requiredEnvironment("ANTHROPIC_CREDENTIAL_ID"));
  }

  /** 投稿するJSONはモデルではなくJava側で組み立てる。 */
  private static String body() {
    return JSON.createObjectNode().put("text", TEXT).toString();
  }

  /**
   * Secret Manager の最新 refresh token から access token を取得する。
   *
   * <p>新しい refresh token が返された場合は、 Vault を更新する前に Secret Manager へ保存する。
   */
  private XTokenRefresher.Tokens mintAccessToken() {
    String currentRefreshToken = refreshTokenStore.load();
    XTokenRefresher.Tokens tokens = refresher.refresh(currentRefreshToken);

    /*
     * refresh token に変更があれば、
     * 先に永続化する。
     */
    refreshTokenStore.saveIfChanged(currentRefreshToken, tokens.refreshToken());
    return tokens;
  }

  /**
   * Environment / Agent / Vault / Credential を作成する。
   *
   * <p>これらは1回だけ作り、 IDを保存して以後使い回す。
   */
  void setup() {
    var environment =
        client
            .beta()
            .environments()
            .create(EnvironmentCreateParams.builder().name("x-posting-environment").build());

    /*
     * bashだけを有効にする。
     */
    var agent =
        client
            .beta()
            .agents()
            .create(
                AgentCreateParams.builder()
                    .name("x-poster")
                    .model(
                        BetaManagedAgentsModelConfigParams.builder()
                            .id(BetaManagedAgentsModel.CLAUDE_SONNET_5)
                            .build())
                    .system(SYSTEM)
                    .addTool(
                        BetaManagedAgentsAgentToolset20260401Params.builder()
                            .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
                            .defaultConfig(
                                BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                                    .enabled(false)
                                    .build())
                            .addConfig(
                                BetaManagedAgentsBashToolConfigParams.builder()
                                    .enabled(true)
                                    .permissionPolicy(
                                        BetaManagedAgentsAlwaysAllowPolicy.builder()
                                            .type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW)
                                            .build())
                                    .build())
                            .build())
                    .build());

    var vault =
        client
            .beta()
            .vaults()
            .create(
                VaultCreateParams.builder()
                    .displayName("fundoshi_y")
                    .metadata(
                        VaultCreateParams.Metadata.builder()
                            .putAdditionalProperty("external_user_id", JsonValue.from("usr_x_bot"))
                            .build())
                    .build());

    /*
     * Secret Manager に保存されている refresh token から
     * 最初の access token を取得する。
     */
    XTokenRefresher.Tokens tokens = mintAccessToken();

    /*
     * access token は environment_variable credential として
     * Vault に保存する。
     *
     * secretName がサンドボックス側の環境変数名。
     *
     * 実値はサンドボックスには置かれず、
     * api.x.com 宛てのヘッダでだけ差し替えられる。
     */
    var credential =
        client
            .beta()
            .vaults()
            .credentials()
            .create(
                CredentialCreateParams.builder()
                    .vaultId(vault.id())
                    .displayName("X access token")
                    .auth(
                        BetaManagedAgentsEnvironmentVariableCreateParams.builder()
                            .type(BetaManagedAgentsEnvironmentVariableCreateParams.Type.ENVIRONMENT_VARIABLE)
                            .secretName(SECRET_NAME)
                            .secretValue(tokens.accessToken())
                            .limitedNetworking(ImmutableList.of(X_API_HOST))
                            .injectionLocation(
                                BetaManagedAgentsInjectionLocationParams.builder()
                                    .header(true)
                                    .build())
                            .build())
                    .build());

    System.out.println("export ANTHROPIC_ENVIRONMENT_ID=\"" + environment.id() + "\"");
    System.out.println("export ANTHROPIC_AGENT_ID=\"" + agent.id() + "\"");
    System.out.println("export ANTHROPIC_VAULT_ID=\"" + vault.id() + "\"");
    System.out.println("export ANTHROPIC_CREDENTIAL_ID=\"" + credential.id() + "\"");
  }

  /** access token を更新してから Session を作成して X に投稿する。 */
  void run(String environmentId, String agentId, String vaultId, String credentialId) {

    /*
     * 1. Secret Managerからrefresh token取得
     * 2. X token endpointでrefresh
     * 3. 新しいrefresh tokenがあればSecret Managerに保存
     */
    XTokenRefresher.Tokens tokens = mintAccessToken();

    /*
     * 4. Vault の access token を更新
     *
     * secret_name は変更しない。
     * 値だけ差し替える。
     */
    client
        .beta()
        .vaults()
        .credentials()
        .update(
            CredentialUpdateParams.builder()
                .vaultId(vaultId)
                .credentialId(credentialId)
                .auth(
                    BetaManagedAgentsEnvironmentVariableUpdateParams.builder()
                        .type(BetaManagedAgentsEnvironmentVariableUpdateParams.Type.ENVIRONMENT_VARIABLE)
                        .secretValue(tokens.accessToken())
                        .build())
                .build());

    /*
     * 5. access token 更新後に Session を作る
     */
    var session =
        client
            .beta()
            .sessions()
            .create(
                SessionCreateParams.builder()
                    .environmentId(environmentId)
                    .agent(agentId)
                    .addVaultId(vaultId)
                    .title("X投稿")
                    .build());

    /*
     * 6. 投稿用JSONを送る
     */
    client
        .beta()
        .sessions()
        .events()
        .send(
            session.id(),
            EventSendParams.builder()
                .addUserMessageEvent(
                    ImmutableList.of(
                        BetaManagedAgentsUserMessageEventParams.Content.ofText(
                            BetaManagedAgentsTextBlock.builder()
                                .type(BetaManagedAgentsTextBlock.Type.TEXT)
                                .text("次のJSONで1件投稿してください: " + body())
                                .build())))
                .build());

    StringBuilder answer = new StringBuilder();

    /*
     * 7. Session完了までイベントを読む
     */
    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.isAgentToolUse()) {

          /*
           * ここに表示されるのは
           * $X_ACCESS_TOKEN というプレースホルダ。
           *
           * 実際の token 値は表示されない。
           */
          var toolUse = event.asAgentToolUse();
          System.out.println("[" + toolUse.name() + "] " + toolUse.input());
        } else if (event.isAgentMessage()) {
          event.asAgentMessage().content().forEach(block -> answer.append(block.text()));
        } else if (event.isSessionError()) {
          throw new IllegalStateException("session error: " + event.asSessionError());
        } else if (event.isSessionStatusIdle()
            && event.asSessionStatusIdle().stopReason().isEndTurn()) {
          break;
        }
      }
    }
    System.out.println();
    System.out.println("A. " + answer.toString().strip());
  }

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