واجهة Responses API من OpenAI: بناء وكلاء ذكاء اصطناعي بالأدوات في TypeScript

npm install openai

OPENAI_API_KEY=sk-proj-مفتاحك-هنا

import OpenAI from "openai";
 
export const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  maxRetries: 3,
});

import { openai } from "@/lib/openai";
import { NextResponse } from "next/server";
 
export async function POST(req: Request) {
  const { message } = await req.json();
 
  const response = await openai.responses.create({
    model: "gpt-4.5",
    instructions: "أنت مساعد بحث مفيد.",
    input: message,
  });
 
  return NextResponse.json({ text: response.output_text });
}

const response = await openai.responses.create({
  model: "gpt-4.5",
  input: [
    { role: "user", content: "ما هي عاصمة تونس؟" },
    { role: "assistant", content: "عاصمة تونس هي مدينة تونس." },
    { role: "user", content: "ما هو عدد سكانها؟" },
  ],
});

for (const item of response.output) {
  if (item.type === "message") {
    for (const part of item.content) {
      if (part.type === "output_text") {
        console.log(part.text);
      }
    }
  }
}

const response = await openai.responses.create({
  model: "gpt-4.5",
  instructions: "أنت مساعد بحث. اذكر مصادرك دائماً.",
  input: "ما هي أبرز مميزات Responses API من OpenAI الصادرة في 2026؟",
  tools: [{ type: "web_search_preview" }],
});
 
console.log(response.output_text);

for (const item of response.output) {
  if (item.type === "message") {
    for (const part of item.content) {
      if (part.type === "output_text" && part.annotations) {
        for (const ann of part.annotations) {
          if (ann.type === "url_citation") {
            console.log(`المصدر: ${ann.title} — ${ann.url}`);
          }
        }
      }
    }
  }
}

const response = await openai.responses.create({
  model: "gpt-4.5",
  instructions: "أنت محلل بيانات. اعرض دائماً عملك بالكود.",
  input: "احسب الفائدة المركبة على 10,000 دولار بمعدل 7% سنوياً لمدة 10 سنوات. اعرض كل سنة.",
  tools: [
    {
      type: "code_interpreter",
      container: { type: "auto" },
    },
  ],
});
 
console.log(response.output_text);

const getWeatherTool = {
  type: "function" as const,
  name: "get_weather",
  description: "الحصول على أحوال الطقس الحالية لمدينة ما.",
  parameters: {
    type: "object",
    properties: {
      city: { type: "string", description: "اسم المدينة، مثل تونس" },
      unit: {
        type: "string",
        enum: ["celsius", "fahrenheit"],
        description: "وحدة درجة الحرارة",
      },
    },
    required: ["city"],
    additionalProperties: false,
  },
  strict: true,
};

import type OpenAI from "openai";
 
async function runAgent(userMessage: string): Promise<string> {
  let input: string | OpenAI.Responses.InputItem[] = userMessage;
 
  while (true) {
    const response = await openai.responses.create({
      model: "gpt-4.5",
      input,
      tools: [getWeatherTool],
    });
 
    const functionCall = response.output.find(
      (item): item is OpenAI.Responses.FunctionCallItem =>
        item.type === "function_call"
    );
 
    if (!functionCall) {
      return response.output_text;
    }
 
    const args = JSON.parse(functionCall.arguments) as {
      city: string;
      unit?: string;
    };
    const weather = await fetchWeather(args.city, args.unit ?? "celsius");
 
    // أضف نتيجة الدالة وأعد الحلقة
    input = [
      { role: "user", content: userMessage },
      ...response.output,
      {
        type: "function_call_output" as const,
        call_id: functionCall.call_id,
        output: JSON.stringify(weather),
      },
    ];
  }
}
 
async function fetchWeather(city: string, unit: string) {
  // استدع واجهة طقس حقيقية هنا في الإنتاج
  return { city, temperature: 24, unit, condition: "مشمس" };
}

// app/api/chat/stream/route.ts
import { openai } from "@/lib/openai";
 
export const runtime = "nodejs";
 
export async function POST(req: Request) {
  const { message } = await req.json();
 
  const encoder = new TextEncoder();
 
  const readable = new ReadableStream({
    async start(controller) {
      const stream = openai.responses.stream({
        model: "gpt-4.5",
        instructions: "أنت مساعد مفيد.",
        input: message,
        tools: [{ type: "web_search_preview" }],
      });
 
      for await (const event of stream) {
        if (
          event.type === "response.output_text.delta" &&
          event.delta
        ) {
          controller.enqueue(encoder.encode(event.delta));
        }
      }
 
      controller.close();
    },
  });
 
  return new Response(readable, {
    headers: {
      "Content-Type": "text/plain; charset=utf-8",
      "Cache-Control": "no-cache",
    },
  });
}

"use client";
import { useState } from "react";
 
export function ChatBox() {
  const [output, setOutput] = useState("");
 
  async function ask(message: string) {
    setOutput("");
    const res = await fetch("/api/chat/stream", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ message }),
    });
 
    const reader = res.body!.getReader();
    const decoder = new TextDecoder();
 
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      setOutput((prev) => prev + decoder.decode(value));
    }
  }
 
  return (
    <div className="p-4">
      <button
        className="px-4 py-2 bg-blue-600 text-white rounded"
        onClick={() => ask("ما آخر المستجدات في الذكاء الاصطناعي؟")}
      >
        اسأل
      </button>
      <p className="mt-4 whitespace-pre-wrap">{output}</p>
    </div>
  );
}

export async function POST(req: Request) {
  const { message, previousResponseId } = await req.json();
 
  const response = await openai.responses.create({
    model: "gpt-4.5",
    input: message,
    previous_response_id: previousResponseId ?? undefined,
    tools: [{ type: "web_search_preview" }],
  });
 
  return NextResponse.json({
    text: response.output_text,
    responseId: response.id,
  });
}

// app/api/agent/route.ts
import { openai } from "@/lib/openai";
import { NextResponse } from "next/server";
import type OpenAI from "openai";
 
export const runtime = "nodejs";
 
const searchTool: OpenAI.Responses.Tool = { type: "web_search_preview" };
const codeTool: OpenAI.Responses.Tool = {
  type: "code_interpreter",
  container: { type: "auto" },
};
 
export async function POST(req: Request) {
  const {
    message,
    previousResponseId,
    enableSearch = true,
    enableCode = false,
  } = await req.json();
 
  const tools: OpenAI.Responses.Tool[] = [
    ...(enableSearch ? [searchTool] : []),
    ...(enableCode ? [codeTool] : []),
  ];
 
  try {
    const response = await openai.responses.create({
      model: "gpt-4.5",
      instructions:
        "أنت مساعد بحث متخصص للمطورين في منطقة الشرق الأوسط وشمال أفريقيا. " +
        "استشهد بالمصادر عند استخدام البحث على الويب. اعرض الكود عند تحليل البيانات.",
      input: message,
      tools: tools.length > 0 ? tools : undefined,
      previous_response_id: previousResponseId ?? undefined,
    });
 
    return NextResponse.json({
      text: response.output_text,
      responseId: response.id,
      usage: {
        inputTokens: response.usage?.input_tokens,
        outputTokens: response.usage?.output_tokens,
        cachedTokens: response.usage?.input_tokens_details?.cached_tokens,
      },
    });
  } catch (error) {
    if (error instanceof OpenAI.APIError) {
      return NextResponse.json(
        { error: error.message },
        { status: error.status ?? 500 }
      );
    }
    throw error;
  }
}

const assistant = await openai.beta.assistants.create({
  name: "Research Bot",
  instructions: "أنت مساعد بحث.",
  tools: [{ type: "web_search" }],
  model: "gpt-4-turbo",
});
 
const thread = await openai.beta.threads.create();
await openai.beta.threads.messages.create(thread.id, {
  role: "user",
  content: userMessage,
});
 
let run = await openai.beta.threads.runs.create(thread.id, {
  assistant_id: assistant.id,
});
 
while (run.status !== "completed") {
  await new Promise((r) => setTimeout(r, 1000));
  run = await openai.beta.threads.runs.retrieve(thread.id, run.id);
}
 
const messages = await openai.beta.threads.messages.list(thread.id);
const text = messages.data[0].content[0].text.value;

const response = await openai.responses.create({
  model: "gpt-4.5",
  instructions: "أنت مساعد بحث.",
  input: userMessage,
  tools: [{ type: "web_search_preview" }],
});
 
const text = response.output_text;