共通エージェント定義をセッション単位で使い分ける運用設計

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
// 土台側で「許可してよい」上限。上書きがこれを超えたら止めます。
const TOOL_ALLOWLIST = new Set([
  "agent_toolset_20260401",
  "mcp_toolset",
]);
const MCP_ALLOWLIST = new Set([
  "mcp-claudelab",
  "mcp-gemilab",
  "mcp-antigravitylab",
  "mcp-rorklab",
]);
 
type SiteProfile = {
  site: string;
  agentId: string;        // 土台は1つ。サイト差は version で指します
  agentVersion?: number;  // 省略時は最新版
  environmentId: string;
  toolTypes: string[];    // そのセッションでの最終形
  mcpServers: { type: "url"; name: string; url: string }[];
};
 
function assertSubset(label: string, given: string[], allow: Set<string>) {
  const stray = given.filter((v) => !allow.has(v));
  if (stray.length > 0) {
    // 想定外の権限拡大は、セッションを起動する前に落とします
    throw new Error(`[guard] ${label} に未許可の項目: ${stray.join(", ")}`);
  }
}
 
export async function startSession(p: SiteProfile) {
  assertSubset("toolTypes", p.toolTypes, TOOL_ALLOWLIST);
  assertSubset("mcpServers", p.mcpServers.map((m) => m.name), MCP_ALLOWLIST);
 
  if (p.toolTypes.length === 0) {
    // 空配列は「ツール無し」を意味します。事故を疑いたいので明示的に残します
    console.warn(`[guard] ${p.site}: toolTypes が空です。意図的か確認してください`);
  }
 
  // 1. セッションはエージェントを「指す」だけ。ここに model や system は書けません
  const session = await client.beta.sessions.create({
    agent: p.agentVersion
      ? { type: "agent", id: p.agentId, version: p.agentVersion }
      : p.agentId,
    environment_id: p.environmentId,
    title: `${p.site} nightly`,
    metadata: { site: p.site },
  });
 
  // 2. ツールと MCP だけは、起動後にセッションローカルで上書きできます
  //    （session が idle のあいだのみ。配列は全置換です）
  await client.beta.sessions.update(session.id, {
    agent: {
      tools: p.toolTypes.map((type) => ({ type })),
      mcp_servers: p.mcpServers,
    },
  });
 
  // 何をどう差し替えたかを一行で残します。あとから挙動を追えます
  console.info(
    `[session] site=${p.site} agent=${p.agentId}@${p.agentVersion ?? "(latest)"} ` +
      `tools=${p.toolTypes.length} mcp=${p.mcpServers.map((m) => m.name).join("+")}`
  );
 
  return session;
}

const SITE_PROFILES: Record<string, SiteProfile> = {
  claudelab: {
    site: "claudelab",
    agentId: "agent_blog_base",
    // version 省略 = 最新版に追随します
    environmentId: "env_blog",
    toolTypes: ["agent_toolset_20260401", "mcp_toolset"],
    mcpServers: [
      { type: "url", name: "mcp-claudelab", url: "https://example.internal/cl/sse" },
    ],
  },
  rorklab: {
    site: "rorklab",
    agentId: "agent_blog_base",
    agentVersion: 1772585501101368014, // 検証中のため版を固定しています
    environmentId: "env_blog",
    toolTypes: ["agent_toolset_20260401", "mcp_toolset"],
    mcpServers: [
      { type: "url", name: "mcp-rorklab", url: "https://example.internal/rl/sse" },
    ],
  },
};
 
async function runFor(site: string) {
  const profile = SITE_PROFILES[site];
  if (!profile) throw new Error(`未定義のサイトです: ${site}`);
  return startSession(profile);
}

type Delta = { add?: string[]; remove?: string[] };
 
// 土台の現在値に足し引きを適用し、「そのフィールドの最終形」と差分を返します
function applyDelta(current: string[], delta: Delta, label = "field") {
  const remove = new Set(delta.remove ?? []);
 
  // 土台側で名前が変わったのに remove 指定が古いまま、という状態を拾います
  const ghosts = [...remove].filter((n) => !current.includes(n));
  if (ghosts.length > 0) {
    console.warn(`[delta] ${label}: 土台に無い項目の remove 指定: ${ghosts.join(", ")}`);
  }
 
  const kept = current.filter((n) => !remove.has(n));
  const appended = (delta.add ?? []).filter((n) => !kept.includes(n));
  const next = [...kept, ...appended];
 
  return { next, diff: diffOf(current, next) };
}
 
function diffOf(before: string[], after: string[]): string[] {
  const b = new Set(before);
  const a = new Set(after);
  return [
    ...before.filter((n) => !a.has(n)).map((n) => `-${n}`),
    ...after.filter((n) => !b.has(n)).map((n) => `+${n}`),
  ];
}

// 土台の現在値は起動時に一度だけ取得します
const base = await client.beta.agents.retrieve("agent_blog_base");
const baseTools = (base.tools ?? []).map((t) => t.type);
 
const { next, diff } = applyDelta(baseTools, { add: ["mcp_toolset"] }, "tools");
console.info(`[delta] tools ${diff.join(" ") || "(変更なし)"} -> ${next.join(", ")}`);
 
// この next を SiteProfile.toolTypes に入れてから startSession へ渡します

検証用に bash を足す  -> [web_search, text_editor, bash] diff=[+bash]
検索を外す            -> [text_editor] diff=[-web_search]
入れ替える            -> [text_editor, bash] diff=[-web_search +bash]
既にある物を足す      -> [web_search, text_editor] diff=[]
[delta] tools: 土台に無い項目の remove 指定: computer
土台に無い物を外す    -> [web_search, text_editor] diff=[]

import { readFileSync } from "node:fs";
 
// [session] 行だけを拾います。先頭の日付は runner が付けても、行内に含めても構いません
const LINE =
  /^(?<ts>\d{4}-\d{2}-\d{2})\S*\s+\[session\]\s+site=(?<site>\S+)\s+agent=(?<agent>\S+)\s+tools=(?<tools>\d+)\s+mcp=(?<mcp>\S+)/;
 
const rows = readFileSync(process.argv[2], "utf8")
  .split("\n")
  .map((l) => l.match(LINE)?.groups)
  .filter(Boolean);
 
const agg = new Map();
for (const r of rows) {
  const key = `${r.ts}\t${r.site}\t${r.agent}`;
  const cur = agg.get(key) ?? { runs: 0, tools: new Set(), mcp: new Set() };
  cur.runs++;
  cur.tools.add(Number(r.tools));            // 同じ日に数が揺れたら列に残ります
  r.mcp.split("+").forEach((m) => cur.mcp.add(m));
  agg.set(key, cur);
}
 
console.log(["date", "site", "agent", "runs", "tools", "mcp"].join("\t"));
for (const [key, v] of [...agg].sort()) {
  const tools = [...v.tools].sort((a, b) => a - b).join("/");
  console.log([key, v.runs, tools, [...v.mcp].join(",")].join("\t"));
}
 
// 最新版に追随したまま走った回数は、土台を更新したときに波及する範囲そのものです
const latest = rows.filter((r) => r.agent.endsWith("@(latest)")).length;
console.log(`\n最新版に追随して走った回数: ${latest} / ${rows.length}`);

date        site        agent                          runs  tools  mcp
2026-09-01  claudelab   agent_blog_base@(latest)       2     1/2    mcp-claudelab
2026-09-01  gemilab     agent_blog_base@(latest)       1     2      mcp-gemilab
2026-09-01  rorklab     agent_blog_base@17725855011…   1     3      mcp-rorklab
2026-09-02  claudelab   agent_blog_base@(latest)       1     2      mcp-claudelab
2026-09-02  gemilab     agent_blog_base@(latest)       1     2      mcp-gemilab,mcp-shared
2026-09-02  rorklab     agent_blog_base@17725855011…   1     3      mcp-rorklab
 
最新版に追随して走った回数: 5 / 7

// フェーズごとの「ツールの最終形」を定義します
const PHASE_TOOLS: Record<"research" | "edit" | "verify", string[]> = {
  research: ["agent_toolset_20260401", "mcp_toolset"],
  edit: ["agent_toolset_20260401"],
  verify: ["agent_toolset_20260401"],
};
 
// 次のフェーズの構成へ切り替えます。境界の判断は起動時と共有します
async function switchPhase(sessionId: string, phase: keyof typeof PHASE_TOOLS) {
  const types = PHASE_TOOLS[phase];
  assertSubset("toolTypes", types, TOOL_ALLOWLIST);
 
  const current = await client.beta.sessions.retrieve(sessionId);
  if (current.status !== "idle") {
    // running のまま投げても通りません。中断してから呼び直します
    throw new Error(`[phase] ${sessionId} は ${current.status} です。idle を待ってください`);
  }
 
  await client.beta.sessions.update(sessionId, {
    agent: { tools: types.map((type) => ({ type })) },
  });
 
  // どの時点で権限が変わったかを、あとから追えるようにしておきます
  console.info(`[phase] ${sessionId} -> ${phase} tools=${types.join(",")}`);
}