OpenAI Responses API 互換で実現する OpenAI / ローカルLLM 切り替えチュートリアル

# （ターミナル）
ollama pull llama3.2:3b
ollama run llama3.2:3b

# openai / ollama
LLM_PROVIDER=ollama
# 1回の起動あたりの最大ターン数
MAX_TURNS=20
# リクエスト間の最小間隔（ミリ秒）
MIN_REQUEST_INTERVAL_MS=1200
# 時刻表示のタイムゾーン（必要に応じて変更）
# TIME_ZONE=Asia/Tokyo
# ツール実行ログを出す場合は 1
LOG_TOOLS=1

# OpenAI
OPENAI_API_KEY=xxxx
OPENAI_MODEL=gpt-4o-mini

# Ollama
OLLAMA_BASE_URL=http://localhost:11434/v1
OLLAMA_MODEL=llama3.2:3b
# コンテキスト長を制限（M2 / RAM 8GBでは非常に重要）
OLLAMA_NUM_CTX=2048</code>

responses-api-llm-providers/
  package.json
  .env.example
  .env
  index.mjs
  agent.mjs
  tools.mjs
  providers/
    README.md
    openai.mjs
    ollama.mjs

// agent.mjs
export async function runAgent({ session, runTool, userText }) {
  let step = await session.sendUser(userText);

  while (true) {
    if (step.type === "final") {
      return step.text;
    }

    const results = [];
    for (const call of step.tool_calls) {
      const output = await runTool(call.name, call.args);
      results.push({
        call_id: call.call_id,
        name: call.name,
        output,
      });
    }

    step = await session.sendToolResults(results);
  }
}

// tools.mjs
export const TOOL_SPECS = [
  {
    type: "function",
    name: "get_time",
    description: "Return the current time in UTC and local time.",
    parameters: {
      type: "object",
      properties: {},
      additionalProperties: false,
    },
    strict: true,
  },
];

export async function runTool(name, args) {
  if (process.env.LOG_TOOLS === "1") {
    console.log(`[tool] ${name} args=${JSON.stringify(args)}`);
  }

  switch (name) {
    case "get_time": {
      const now = new Date();
      const timeZone =
        process.env.TIME_ZONE || Intl.DateTimeFormat().resolvedOptions().timeZone;
      const local = new Intl.DateTimeFormat("ja-JP", {
        timeZone,
        year: "numeric",
        month: "2-digit",
        day: "2-digit",
        hour: "2-digit",
        minute: "2-digit",
        second: "2-digit",
        hour12: false,
      }).format(now);
      return {
        utc_iso: now.toISOString(),
        local,
        time_zone: timeZone,
      };
    }
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
}

// providers/openai.mjs
import OpenAI from "openai";

export function createOpenAISession({ model, toolSpecs }) {
  const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
  let previous = null;

  async function call(input) {
    const r = await client.responses.create({
      model,
      input,
      tools: toolSpecs,
      tool_choice: "auto",
      store: true,
      ...(previous ? { previous_response_id: previous } : {}),
    });

    previous = r.id;

    const calls = r.output
      .filter(i => i.type === "function_call")
      .map(i => ({
        call_id: i.call_id,
        name: i.name,
        args: JSON.parse(i.arguments),
      }));

    if (calls.length) return { type: "tool_calls", tool_calls: calls };
    return { type: "final", text: r.output_text };
  }

  return {
    sendUser: (t) => call(t),
    sendToolResults: (items) =>
      call(items.map(r => ({
        type: "function_call_output",
        call_id: r.call_id,
        output: JSON.stringify(r.output),
      }))),
  };
}

// providers/ollama.mjs
import OpenAI from "openai";

export function createOllamaSession({ model, toolSpecs }) {
  const client = new OpenAI({
    baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
    apiKey: "ollama",
  });

  const history = [];

  async function call() {
    const r = await client.responses.create({
      model,
      input: history,
      tools: toolSpecs,
      tool_choice: "auto",
    });

    const calls = r.output
      .filter(i => i.type === "function_call")
      .map(i => ({
        call_id: i.call_id,
        name: i.name,
        args: JSON.parse(i.arguments),
      }));

    if (calls.length) return { type: "tool_calls", tool_calls: calls };
    return { type: "final", text: r.output_text };
  }

  return {
    async sendUser(text) {
      history.push({ role: "user", content: text });
      const step = await call();
      if (step.type === "final") {
        history.push({ role: "assistant", content: step.text });
      }
      return step;
    },

    async sendToolResults(results) {
      history.push(...results.map(r => ({
        type: "function_call_output",
        call_id: r.call_id,
        output: JSON.stringify(r.output),
      })));
      const step = await call();
      if (step.type === "final") {
        history.push({ role: "assistant", content: step.text });
      }
      return step;
    },
  };
}

// index.mjs
import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";
import { runAgent } from "./agent.mjs";
import { runTool, TOOL_SPECS } from "./tools.mjs";
import { createOpenAISession } from "./providers/openai.mjs";
import { createOllamaSession } from "./providers/ollama.mjs";

const provider = (process.env.LLM_PROVIDER || "ollama").toLowerCase();

let session;
if (provider === "openai") {
  session = createOpenAISession({
    model: process.env.OPENAI_MODEL || "gpt-4o-mini",
    toolSpecs: TOOL_SPECS,
  });
} else if (provider === "ollama") {
  session = createOllamaSession({
    model: process.env.OLLAMA_MODEL || "llama3.2:3b",
    toolSpecs: TOOL_SPECS,
  });
} else {
  throw new Error(`Unsupported LLM_PROVIDER: ${provider}`);
}

const MAX_TURNS = Number(process.env.MAX_TURNS || 20);
const MIN_REQUEST_INTERVAL_MS = Number(process.env.MIN_REQUEST_INTERVAL_MS || 1200);

const rl = readline.createInterface({ input, output });
let turns = 0;
let lastRequestAt = 0;

console.log("Type 'exit' or 'quit' to stop.");

while (true) {
  const userText = await rl.question("You> ");
  const trimmed = userText.trim();
  if (!trimmed || trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
    break;
  }

  if (turns >= MAX_TURNS) {
    console.log(`Reached MAX_TURNS=${MAX_TURNS}. Set MAX_TURNS to continue.`);
    break;
  }

  const now = Date.now();
  const waitMs = Math.max(0, MIN_REQUEST_INTERVAL_MS - (now - lastRequestAt));
  if (waitMs > 0) {
    await new Promise(resolve => setTimeout(resolve, waitMs));
  }
  lastRequestAt = Date.now();

  const answer = await runAgent({
    session,
    runTool,
    userText: trimmed,
  });
  console.log(`AI> ${answer}`);
  turns += 1;
}

rl.close();

# OpenAI を使う場合
export LLM_PROVIDER=openai
node index.mjs

# Ollama を使う場合（別ターミナルで ollama run を起動）
export LLM_PROVIDER=ollama
node index.mjs