Help me with function call for OpenAI realtime preview model

[IU1004]

Body

I'm implementing function call for OpenAI realtime preview model.
Please help me if you have experience with function calling in OpenAI realtime preview model.
After setting tools parameter in OpenAI model, then how can I know if there's function call in model's response.
I'm using realtime preview model for voice.
Please share node.js implementation if you have.
Thanks & Regards.

Guidelines

• I have read and understood this category's guidelines before making this post.

[AniketSainiOp]

Hi @IU1004

In the Realtime Preview model, function calling works via tool events (not function_call like older APIs).

Define tools when creating/updating the session:

{
type: "function",
function: {
name: "getWeather",
parameters: { type: "object", properties: { location: { type: "string" } }, required: ["location"] }
}
}

Check for tool calls in messages from the model:

if (msg.type === "tool") {
const args = JSON.parse(msg.tool.arguments);
// Call your function and send result back
}

Send result back using another tool message:

ws.send(JSON.stringify({
type: "input_audio_buffer.append",
tool: { name: "getWeather", output: { temp: 29 } }
}));

That’s it — watch for tool events, run the function, and return the result.

[MaheshR03]

1.Define tools and tool_choice in your API call.
2.Use streaming (stream: true) to get real-time tokens.
3.Listen for tool_calls in the streamed response.
4.When a tool_calls message arrives, extract the function name + arguments.
5.Invoke your function manually, then send the result back to the model.

Here's a basic implementation using the OpenAI Node.js SDK with a streaming response and tool handling:

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function main() {
  const tools = [
    {
      type: "function",
      function: {
        name: "getWeather",
        description: "Get weather for a location",
        parameters: {
          type: "object",
          properties: {
            location: {
              type: "string",
              description: "City name, e.g., San Francisco",
            },
          },
          required: ["location"],
        },
      },
    },
  ];
const messages = [
    { role: "user", content: "What's the weather like in Paris?" },
  ];

  const stream = await openai.chat.completions.create({
    model: "gpt-4o", // realtime preview model
    stream: true,
    messages,
    tools,
    tool_choice: "auto", // or "required" for strict function call
  });

  for await (const chunk of stream) {
    const toolCalls = chunk.choices?.[0]?.delta?.tool_calls;
    const content = chunk.choices?.[0]?.delta?.content;

    if (content) {
      process.stdout.write(content); // For text response
    }

    if (toolCalls) {
      for (const toolCall of toolCalls) {
        const { name, arguments: argsJSON, id } = toolCall.function;
        const args = JSON.parse(argsJSON);

        console.log(`\nCalling tool: ${name} with args:`, args);

        // Mock function execution
        const toolResponse = await mockToolFunction(name, args);

        // Send tool response back to model
        const followUp = await openai.chat.completions.create({
          model: "gpt-4o",
          messages: [
            ...messages,
            {
              role: "assistant",
              tool_calls: [toolCall],
            },
            {
              role: "tool",
              tool_call_id: id,
              content: toolResponse,
            },
          ],
        });

        console.log("Final model response:", followUp.choices[0].message.content);
      }
    }
  }
}

async function mockToolFunction(name, args) {
  if (name === "getWeather") {
    return `It's sunny and 25°C in ${args.location}.`;
  }
  return "Unknown tool";
}

main();

Note : THIS IS AN LLM GENERATED CODE. MAKE CHANGES THAT SUIT YOUR NEEDS.