Chat CompletionsからResponses APIへ関数呼び出しを移行：call_idと承認の実装

{
  "type": "function_call",
  "id": "fc_demo_7",
  "call_id": "call_demo_42",
  "name": "book_room",
  "arguments": "{\"room\":\"nagoya-a\",\"slot\":\"2026-10-09T10:00+09:00\"}"
}

{
  "type": "function_call_output",
  "call_id": "call_demo_42",
  "output": "{\"ok\":true,\"data\":{\"reservationId\":\"demo-1\"}}"
}

import assert from "node:assert/strict";

export const tools = [{
  type: "function",
  name: "book_room",
  description: "承認された部屋と時間で、会議室を予約する",
  strict: true,
  parameters: {
    type: "object",
    properties: {
      room: { type: "string", enum: ["nagoya-a", "nagoya-b"] },
      slot: { type: "string", enum: ["2026-10-09T10:00+09:00"] }
    },
    required: ["room", "slot"],
    additionalProperties: false
  }
}];

// 架空の承認。実際には認証済みサーバー状態から渡す。
export const approval = Object.freeze({
  tenant: "demo-company", approvalId: "approval-42", approved: true,
  expiresAt: Date.parse("2026-10-09T09:00+09:00"),
  room: "nagoya-a", slot: "2026-10-09T10:00+09:00"
});

class Blocked extends Error {}

export function createBookingApp(trusted, clock = () => Date.now()) {
  const calls = new Map();
  const operations = new Map();
  let writes = 0;

  async function bookRoom(args) {
    const key = JSON.stringify([
      trusted.tenant, trusted.approvalId, args.room, args.slot
    ]);
    if (!operations.has(key)) {
      // Promiseをawaitする前に登録する。架空DBへの書込みは1回。
      operations.set(key, Promise.resolve().then(() => {
        writes += 1;
        return { reservationId: `demo-${writes}`, ...args };
      }));
    }
    return operations.get(key);
  }

  const handlers = new Map([["book_room", bookRoom]]);

  function validate(call) {
    if (!handlers.has(call.name)) throw new Blocked("unknown_function");
    let args;
    try { args = JSON.parse(call.arguments); }
    catch { throw new Blocked("invalid_json"); }
    if (!args || typeof args !== "object" || Array.isArray(args) ||
        Object.keys(args).sort().join(",") !== "room,slot" ||
        !["nagoya-a", "nagoya-b"].includes(args.room) ||
        args.slot !== "2026-10-09T10:00+09:00") {
      throw new Blocked("invalid_arguments");
    }
    if (!trusted.approved || clock() >= trusted.expiresAt ||
        args.room !== trusted.room || args.slot !== trusted.slot) {
      throw new Blocked("approval_mismatch_or_expired");
    }
    return args;
  }

  async function execute(responseId, call) {
    if (typeof call.call_id !== "string" || !call.call_id ||
        typeof call.name !== "string" || typeof call.arguments !== "string") {
      throw new Error("invalid_call_item");
    }
    if ((call.status && call.status !== "completed") || call.async ||
        call.namespace != null || call.caller != null) {
      throw new Error("unsupported_call_variant");
    }
    const key = JSON.stringify([responseId, call.call_id]);
    const fingerprint = JSON.stringify([call.name, call.arguments]);
    const old = calls.get(key);
    if (old) {
      if (old.fingerprint !== fingerprint) throw new Error("call_id_conflict");
      return old.pending;
    }
    const pending = Promise.resolve().then(async () => {
      try {
        const args = validate(call);
        const data = await handlers.get(call.name)(args);
        return { ok: true, data };
      } catch (error) {
        if (error instanceof Blocked) return { ok: false, code: error.message };
        // 実backendのtimeout等は結果不明。成功にも未実行にも変換しない。
        throw error;
      }
    });
    calls.set(key, { fingerprint, pending });
    return pending;
  }
  return { execute, writeCount: () => writes };
}

export async function runMigration({ createResponse, replayOutput, app, model }) {
  const input = [{ role: "user", content: "承認済みの名古屋Aを予約してください。" }];
  const instructions = "book_roomで予約し、結果が拒否なら予約済みと説明しないこと。";
  const receipts = new Map();
  for (let round = 0; round < 6; round += 1) {
    const response = await createResponse({
      model, instructions, input: structuredClone(input), tools,
      parallel_tool_calls: false, store: false
    });
    if (response.status !== "completed" || !Array.isArray(response.output)) {
      throw new Error(`response_not_completed:${response.status}`);
    }
    if (response.output.some(item => item.type === "message" &&
        item.content?.some(part => part.type === "refusal"))) {
      throw new Error("model_refusal");
    }
    const functionCalls = response.output.filter(item => item.type === "function_call");
    input.push(...replayOutput(response.output));
    if (functionCalls.length === 0) {
      const text = response.output.filter(item => item.type === "message" &&
        item.role === "assistant" && (!item.phase || item.phase === "final_answer"))
        .flatMap(item => item.content ?? [])
        .filter(part => part.type === "output_text").map(part => part.text).join("\n");
      const results = [...receipts.values()];
      if (!text.trim() || results.length === 0 || results.some(result => !result.ok)) {
        throw new Error("no_confirmed_booking_or_final_answer");
      }
      return { text, receipts: results, writes: app.writeCount() };
    }
    const sent = new Set();
    for (const call of functionCalls) {
      const result = await app.execute(response.id, call);
      const key = JSON.stringify([response.id, call.call_id]);
      receipts.set(key, result);
      if (!sent.has(call.call_id)) {
        input.push({ type: "function_call_output", call_id: call.call_id,
          output: JSON.stringify(result) });
        sent.add(call.call_id);
      }
    }
  }
  throw new Error("round_limit_reached");
}

const makeCall = (callId, overrides = {}) => ({
  type: "function_call", id: `item-${callId}`, call_id: callId,
  name: "book_room", arguments: JSON.stringify({ room: approval.room, slot: approval.slot }),
  ...overrides
});

async function selfTest() {
  const app = createBookingApp(approval, () => Date.parse("2026-10-07T12:00+09:00"));
  let requests = 0;
  const createResponse = async request => {
    requests += 1;
    if (requests === 1) return {
      id: "response-demo-1", status: "completed", output: [
        { type: "reasoning", id: "reasoning-demo", encrypted_content: "synthetic" },
        makeCall("call-demo-1")
      ]
    };
    const result = request.input.find(item => item.type === "function_call_output");
    assert.equal(result.call_id, "call-demo-1");
    assert.notEqual(result.call_id, "item-call-demo-1");
    assert.equal(JSON.parse(result.output).data.reservationId, "demo-1");
    assert(request.input.some(item => item.type === "reasoning"));
    assert(request.instructions);
    return { id: "response-demo-2", status: "completed", output: [{
      type: "message", role: "assistant", phase: "final_answer",
      content: [{ type: "output_text", text: "予約番号demo-1を確認しました。" }]
    }] };
  };
  const result = await runMigration({ createResponse, replayOutput: structuredClone,
    app, model: "offline-fixture" });
  assert.equal(result.writes, 1);
  const replay = await Promise.all([
    app.execute("response-demo-1", makeCall("call-demo-1")),
    app.execute("response-demo-1", makeCall("call-demo-1")),
    app.execute("response-demo-3", makeCall("call-demo-3"))
  ]);
  assert(replay.every(item => item.ok));
  assert.equal(app.writeCount(), 1);
  const denied = await app.execute("response-demo-4", makeCall("call-denied", {
    arguments: JSON.stringify({ room: "nagoya-b", slot: approval.slot })
  }));
  assert.equal(denied.ok, false);
  assert.equal(app.writeCount(), 1);
  const invalid = await app.execute("response-demo-5", makeCall("call-bad", {
    arguments: "{"
  }));
  assert.equal(invalid.code, "invalid_json");
  await assert.rejects(app.execute("response-demo-1", makeCall("call-demo-1", {
    arguments: "{}"
  })), /call_id_conflict/);
  console.log("PASS: offline loop / call_id / replay / approval / invalid JSON");
}

if (process.argv.includes("--self-test")) {
  await selfTest();
} else if (process.argv.includes("--api")) {
  // この分岐だけが実APIへ接続する。自己テストではimportも初期化もしない。
  const { default: OpenAI } = await import("openai");
  const { toResponseInputItems } = await import("openai/lib/responses/ResponseInputItems");
  const model = process.env.OPENAI_MODEL;
  if (!model) throw new Error("OPENAI_MODEL is required");
  const client = new OpenAI();
  const app = createBookingApp(approval);
  const result = await runMigration({
    createResponse: request => client.responses.create(request),
    replayOutput: toResponseInputItems, app, model
  });
  console.log(JSON.stringify(result, null, 2));
}

node --check booking-loop.mjs
node booking-loop.mjs --self-test

OPENAI_MODEL="利用環境で確認したモデルID" node booking-loop.mjs --api

export async function completedStream(events) {
  const pending = new Map();
  const sequences = new Map();
  let completed;
  for await (const event of events) {
    const serial = JSON.stringify(event);
    if (sequences.has(event.sequence_number)) {
      if (sequences.get(event.sequence_number) !== serial) {
        throw new Error("stream_sequence_conflict");
      }
      continue;
    }
    sequences.set(event.sequence_number, serial);
    if (["error", "response.failed", "response.incomplete"].includes(event.type)) {
      throw new Error(`stream_stopped:${event.type}`);
    }
    if (event.type === "response.output_item.added" && event.item.type === "function_call") {
      if (!event.item.id || !event.item.call_id || pending.has(event.item.id)) {
        throw new Error("invalid_stream_call");
      }
      pending.set(event.item.id, {
        callId: event.item.call_id, name: event.item.name,
        index: event.output_index, args: null, item: null
      });
    }
    if (event.type === "response.function_call_arguments.done") {
      const entry = pending.get(event.item_id);
      if (!entry || entry.index !== event.output_index) throw new Error("unmatched_arguments");
      entry.args = event.arguments;
    }
    if (event.type === "response.output_item.done" && event.item.type === "function_call") {
      const entry = pending.get(event.item.id);
      if (!entry || entry.index !== event.output_index || entry.args === null ||
          entry.callId !== event.item.call_id || entry.name !== event.item.name ||
          entry.args !== event.item.arguments ||
          (event.item.status && event.item.status !== "completed")) {
        throw new Error("inconsistent_completed_item");
      }
      entry.item = event.item;
    }
    if (event.type === "response.completed") {
      if (completed || event.response.status !== "completed") throw new Error("invalid_completion");
      const calls = event.response.output.filter(item => item.type === "function_call");
      if (calls.length !== pending.size || calls.some(call => {
        const entry = pending.get(call.id);
        return !entry?.item || entry.callId !== call.call_id ||
          entry.name !== call.name || entry.args !== call.arguments;
      })) throw new Error("incomplete_call_collection");
      completed = event.response;
    }
  }
  if (!completed) throw new Error("stream_ended_without_completion");
  return completed;
}