Toolها (ابزارها) در هوش مصنوعی

import { OpenAI } from "openai";

const openai = new OpenAI({
baseURL: '<baseUrl>',
apiKey: '<LIARA_API_KEY>',
});

function getCurrentWeather(location, unit = "celsius") {
return {
  location: location,
  temperature: unit === "celsius" ? 35 : 68, // Celsius or Fahrenheit
  unit: unit,
  condition: "Sunny"
};
}

const tools = [{
  "type": "function",
  "function": {
      "name": "getCurrentWeather",
      "description": "Get current temperature for a given location.",
      "parameters": {
          "type": "object",
          "properties": {
              "location": {
                  "type": "string",
                  "description": "City and country e.g. Bogotá, Colombia"
              },
              "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
          },
          "required": [
              "location"
          ],  
      },
  }
}];

"function": {
"name": "getCurrentWeather",
"description": "Get current temperature for a given location.",
"parameters": {
    "type": "object",
    "properties": {
        "location": {
            "type": "string",
            "description": "City and country e.g. Bogotá, Colombia"
        },
        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
    },
    "required": [
        "location"
    ],  
},
}

"parameters": {
"type": "object",
"properties": {
  "location": {
    "type": "string",
    "description": "The city and state, e.g. San Francisco, CA",
  },
  "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
},
"required": ["location"],
},

const messages = [{ role: "user", content: "What is the weather like in Paris today?" }];

const completion = await openai.chat.completions.create({
  model: "openai/gpt-4.1",
  messages: messages,
  tools,
  tool_choice: "auto",
});

console.log(JSON.stringify(completion, null, 2));

{
"id": "6834381c546e1efa313fa872",
"model": "openai/gpt-4.1",
"object": "chat.completion",
"created": 1748252700,
"choices": [
  {
    "logprobs": null,
    "finish_reason": "tool_calls",
    "native_finish_reason": "tool_calls",
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "",
      "refusal": null,
      "reasoning": null,
      "tool_calls": [
        {
          "index": 0,
          "id": "call_DzeyygbKgYRe6gYvk73fv152",
          "type": "function",
          "function": {
            "name": "getCurrentWeather",
            "arguments": "{"location":"Paris, France"}"
          }
        }
      ]
    }
  }
],
"usage": {
  "prompt_tokens": 77,
  "completion_tokens": 17,
  "total_tokens": 94,
  "prompt_tokens_details": {
    "cached_tokens": 0
  },
  "completion_tokens_details": {
    "reasoning_tokens": 0
  }
}
}

const argsRaw = completion.choices[0].message.tool_calls[0].function.arguments;
const args = JSON.parse(argsRaw);
console.log(args);

{ location: 'Paris, France' }

const weather = getCurrentWeather(
args["location"],
args["unit"] || "celsius"
);

console.log(`The current weather in ${args.location} is ${weather.temperature}°${weather.unit === "celsius" ? "C" : "F"} and ${weather.condition}.`);

The current weather in Paris, France is 35°C and Sunny.

import { OpenAI } from "openai";

const openai = new OpenAI({
baseURL: '<baseUrl>',
apiKey: '<LIARA_API_KEY>',
});

function getCurrentWeather(location, unit = "celsius") {
return {
  location: location,
  temperature: unit === "celsius" ? 35 : 68, // Celsius or Fahrenheit
  unit: unit,
  condition: "Sunny"
};
}

const tools = [{
  "type": "function",
  "function": {
      "name": "getCurrentWeather",
      "description": "Get current temperature for a given location.",
      "parameters": {
          "type": "object",
          "properties": {
              "location": {
                  "type": "string",
                  "description": "City and country e.g. Bogotá, Colombia"
              },
              "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
          },
          "required": [
              "location"
          ],  
      },
  }
}];



const messages = [{ role: "user", content: "What is the weather like in Paris today?" }];

const completion = await openai.chat.completions.create({
  model: "openai/gpt-4.1",
  messages: messages,
  tools,
  tool_choice: "auto",
});

const argsRaw = completion.choices[0].message.tool_calls[0].function.arguments;
const args = JSON.parse(argsRaw);

const weather = getCurrentWeather(
args["location"],
args["unit"] || "celsius"
);

console.log(`The current weather in ${args.location} is ${weather.temperature}°${weather.unit === "celsius" ? "C" : "F"} and ${weather.condition}.`);

<?php

require 'vendor/autoload.php';

use OpenAI\Laravel\Facades\OpenAI;

// Your API setup
$yourApiKey = '<LIARA_API_KEY>'; 
$baseUrl = '<baseUrl>'; 
$model = 'openai/gpt-4.1';

// Initialize OpenAI client
$client = \OpenAI::factory()
  ->withApiKey($yourApiKey)
  ->withBaseUri($baseUrl)
  ->make();

function get_current_weather($location, $unit = 'celsius') {
  return [
      'location' => $location,
      'temperature' => $unit === 'celsius' ? 35 : 68,
      'unit' => $unit,
      'condition' => 'Sunny',
  ];
}

$tools = [
  [
  'type' => 'function',
  'function' => [
      'name' => 'get_current_weather',
      'description' => 'Get the current weather in a given location',
      'parameters' => [
          'type' => 'object',
          'properties' => [
              'location' => [
                  'type' => 'string',
                  'description' => 'The city and state, e.g. San Francisco, CA',
              ],
              'unit' => [
                  'type' => 'string',
                  'enum' => ['celsius', 'fahrenheit']
              ],
          ],
          'required' => ['location'],
      ],
  ],
  ]
];

'function' => [
'name' => 'get_current_weather',
'description' => 'Get the current weather in a given location',
'parameters' => [
    'type' => 'object',
    'properties' => [
        'location' => [
            'type' => 'string',
            'description' => 'The city and state, e.g. San Francisco, CA',
        ],
        'unit' => [
            'type' => 'string',
            'enum' => ['celsius', 'fahrenheit']
        ],
    ],
    'required' => ['location'],
],
],

'parameters' => [
  'type' => 'object',
  'properties' => [
      'location' => [
          'type' => 'string',
          'description' => 'The city and state, e.g. San Francisco, CA',
      ],
      'unit' => [
          'type' => 'string',
          'enum' => ['celsius', 'fahrenheit']
      ],
  ],
  'required' => ['location'],
],

$messages = [
  ['role' => 'user', 'content' => "What's the weather like in Tehran today?"]
];

$response = $client->chat()->create([
  'model' => $model,
  'messages' => $messages,
  'tools' => $tools,
  'tool_choice' => 'auto',
]);

echo json_encode($response->toArray(), JSON_PRETTY_PRINT) . "\n";

{
"id": "68359ca09a98cc66d17bc882",
"object": "chat.completion",
"created": 1748343967,
"model": "openai/gpt-4.1",
"choices": [
  {
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "",
      "tool_calls": [
        {
          "id": "call_jIn62y3nyFa6z9AskOoskFmC",
          "type": "function",
          "function": {
            "name": "get_current_weather",
            "arguments": "{"location":"Tehran"}"
          }
        }
      ]
    },
    "logprobs": null,
    "finish_reason": "tool_calls"
  }
],
"usage": {
  "prompt_tokens": 80,
  "completion_tokens": 16,
  "total_tokens": 96,
  "prompt_tokens_details": {
    "cached_tokens": 0
  },
  "completion_tokens_details": {
    "reasoning_tokens": 0
  }
}
}

$args = json_decode($response->choices[0]->message->toolCalls[0]->function->arguments, true);
print_r($args);

Array ( [location] => Tehran )

$weather = get_current_weather(
  $args['location'],
  $args['unit'] ?? 'celsius'
);

echo "The weather in {$weather['location']} is {$weather['temperature']}°" .
  strtoupper(substr($weather['unit'], 0, 1)) . " and {$weather['condition']}.";

The weather in Tehran is 35°C and Sunny.

<?php

require 'vendor/autoload.php';

use OpenAI\Laravel\Facades\OpenAI;

$yourApiKey = '<LIARA_API_KEY>'; 
$baseUrl = '<baseUrl>';
$model = 'openai/gpt-4.1';

$client = \OpenAI::factory()
  ->withApiKey($yourApiKey)
  ->withBaseUri($baseUrl)
  ->make();

function get_current_weather($location, $unit = 'celsius') {
  return [
      'location' => $location,
      'temperature' => $unit === 'celsius' ? 35 : 68,
      'unit' => $unit,
      'condition' => 'Sunny',
  ];
}

$tools = [
  [
  'type' => 'function',
  'function' => [
      'name' => 'get_current_weather',
      'description' => 'Get the current weather in a given location',
      'parameters' => [
          'type' => 'object',
          'properties' => [
              'location' => [
                  'type' => 'string',
                  'description' => 'The city and state, e.g. San Francisco, CA',
              ],
              'unit' => [
                  'type' => 'string',
                  'enum' => ['celsius', 'fahrenheit']
              ],
          ],
          'required' => ['location'],
      ],
  ],
  ]
];

$messages = [
  ['role' => 'user', 'content' => "What's the weather like in Tehran today?"]
];

$response = $client->chat()->create([
  'model' => $model,
  'messages' => $messages,
  'tools' => $tools,
  'tool_choice' => 'auto',
]);


$args = json_decode($response->choices[0]->message->toolCalls[0]->function->arguments, true);

$weather = get_current_weather(
  $args['location'],
  $args['unit'] ?? 'celsius'
);

echo "The weather in {$weather['location']} is {$weather['temperature']}°" .
  strtoupper(substr($weather['unit'], 0, 1)) . " and {$weather['condition']}.";

from openai import OpenAI

client = OpenAI(
base_url="<baseUrl>",
api_key="<LIARA_API_KEY>",
)

def get_current_weather(location, unit="celsius"):
  
return {
    "location": location,
    "temperature": unit == "celsius" and 35 or 68,  # Celsius or Fahrenheit
    "unit": unit,
    "condition": "Sunny"
  }

tools = [
{
  "type": "function",
  "function": {
    "name": "get_current_weather",
    "description": "Get the current weather in a given location",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "The city and state, e.g. San Francisco, CA",
        },
        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
      },
      "required": ["location"],
    },
  }
}
]

"function": {
  "name": "get_current_weather",
  "description": "Get the current weather in a given location",
  "parameters": {
  "type": "object",
  "properties": {
      "location": {
      "type": "string",
      "description": "The city and state, e.g. San Francisco, CA",
      },
      "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
  },
  "required": ["location"],
  },
}

"parameters": {
"type": "object",
"properties": {
  "location": {
    "type": "string",
    "description": "The city and state, e.g. San Francisco, CA",
  },
  "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
},
"required": ["location"],
},

messages = [{"role": "user", "content": "What's the weather in fahrenheit in Tehran today?"}]

completion = client.chat.completions.create(
model="openai/gpt-4.1",
messages=messages,
tools=tools,
tool_choice="auto"
)

import json

print(json.dumps(completion.model_dump(), indent=2))

{
"id": "68340a90546e1efa313fa724",
"choices": [
  {
    "finish_reason": "tool_calls",
    "index": 0,
    "logprobs": null,
    "message": {
      "content": "",
      "refusal": null,
      "role": "assistant",
      "annotations": null,
      "audio": null,
      "function_call": null,
      "tool_calls": [
        {
          "id": "call_IGlizOLwLJWLUT4uXv60pW9P",
          "function": {
            "arguments": "{"location":"Tehran","unit":"fahrenheit"}",
            "name": "get_current_weather"
          },
          "type": "function",
          "index": 0
        }
      ],
      "reasoning": null
    },
    "native_finish_reason": "tool_calls"
  }
],
"created": 1748241039,
"model": "openai/gpt-4.1",
"object": "chat.completion",
"service_tier": null,
"system_fingerprint": null,
"usage": {
  "completion_tokens": 21,
  "prompt_tokens": 83,
  "total_tokens": 104,
  "completion_tokens_details": {
    "accepted_prediction_tokens": null,
    "audio_tokens": null,
    "reasoning_tokens": 0,
    "rejected_prediction_tokens": null
  },
  "prompt_tokens_details": {
    "audio_tokens": null,
    "cached_tokens": 0
  }
}
}

args = json.loads(completion.choices[0].message.tool_calls[0].function.arguments)
print(args)

{'location': 'Tehran', 'unit': 'fahrenheit'}

weather = get_current_weather(
  location=args["location"],
  unit=args.get("unit", "celsius")
)

print(f"The weather in {weather['location']} is {weather['temperature']}°{weather['unit'][0].upper()} and {weather['condition']}.")

The weather in Tehran is 68°F and Sunny.

from openai import OpenAI
import json

client = OpenAI(
base_url="<LIARA_API_KEY>",
api_key="<baseUrl>",
)

def get_current_weather(location, unit="celsius"):
  return {
      "location": location,
      "temperature": unit == "celsius" and 35 or 68,  # Celsius or Fahrenheit
      "unit": unit,
      "condition": "Sunny"
  }

tools = [
{
  "type": "function",
  "function": {
    "name": "get_current_weather",
    "description": "Get the current weather in a given location",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "The city and state, e.g. San Francisco, CA",
        },
        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
      },
      "required": ["location"],
    },
  }
}
]

messages = [{"role": "user", "content": "What's the weather in fahrenheit like in Tehran today?"}]

completion = client.chat.completions.create(
model="openai/gpt-4.1",
messages=messages,
tools=tools,
tool_choice="auto"
)

args = json.loads(completion.choices[0].message.tool_calls[0].function.arguments)
print(args)

weather = get_current_weather(
  location=args["location"],
  unit=args.get("unit", "celsius")
)

print(f"The weather in {weather['location']} is {weather['temperature']}°{weather['unit'][0].upper()} and {weather['condition']}.")

string apiKey = "<LIARA_API_KEY>"; 
string baseUrl = "<baseUrl>";
OpenAIClientOptions open_options = new OpenAIClientOptions
{
  Endpoint = new Uri(baseUrl)
};
ChatClient client = new(model: "openai/gpt-4.1-mini", credential: new ApiKeyCredential(apiKey), options: open_options);

public class WeatherInfo
{
  public required string Location { get; set; }
  public int Temperature { get; set; }
  public required string Unit { get; set; }
  public required string Condition { get; set; }
}

public WeatherInfo GetCurrentWeather(string location, string unit = "celsius")
{
  int temperature = unit.ToLower() == "celsius" ? 35 : 68;

  return new WeatherInfo
  {
      Location = location,
      Temperature = temperature,
      Unit = unit,
      Condition = "Sunny"
  };
}

private static readonly ChatTool getCurrentWeatherTool = ChatTool.CreateFunctionTool(
functionName: nameof(GetCurrentWeather),
functionDescription: "Get the current weather in a given location",
functionParameters: BinaryData.FromBytes("""
    {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "The city and state, e.g. Boston, MA"
            },
            "unit": {
                "type": "string",
                "enum": [ "celsius", "fahrenheit" ],
                "description": "The temperature unit to use. Infer this from the specified location."
            }
        },
        "required": [ "location" ]
    }
    """u8.ToArray())
);

functionName: nameof(GetCurrentWeather),
functionDescription: "Get the current weather in a given location",
functionParameters: BinaryData.FromBytes("""
  {
      "type": "object",
      "properties": {
          "location": {
              "type": "string",
              "description": "The city and state, e.g. Boston, MA"
          },
          "unit": {
              "type": "string",
              "enum": [ "celsius", "fahrenheit" ],
              "description": "The temperature unit to use. Infer this from the specified location."
          }
      },
      "required": [ "location" ]
  }
  """u8.ToArray())

functionParameters: BinaryData.FromBytes("""
  {
      "type": "object",
      "properties": {
          "location": {
              "type": "string",
              "description": "The city and state, e.g. Boston, MA"
          },
          "unit": {
              "type": "string",
              "enum": [ "celsius", "fahrenheit" ],
              "description": "The temperature unit to use. Infer this from the specified location."
          }
      },
      "required": [ "location" ]
  }
  """u8.ToArray())

List<ChatMessage> messages = new()
{
  new UserChatMessage("What's weather like in Tehran")
};

ChatCompletionOptions options = new()
{
  Tools = { getCurrentWeatherTool },       
};

ChatCompletion completion = client.CompleteChat(messages, options);

Console.WriteLine(JsonSerializer.Serialize(completion, new JsonSerializerOptions { WriteIndented = true }));

{
"CreatedAt": "2025-05-28T10:20:11+00:00",
"FinishReason": 3,
"ContentTokenLogProbabilities": [],
"RefusalTokenLogProbabilities": [],
"Role": 2,
"Content": [
  {
    "Kind": 0,
    "Text": "",
    "ImageUri": null,
    "ImageBytes": null,
    "ImageBytesMediaType": null,
    "ImageDetailLevel": null,
    "Refusal": null
  }
],
"ToolCalls": [
  {
    "Kind": 0,
    "FunctionName": "GetCurrentWeather",
    "FunctionArguments": {},
    "Id": "call_wGFfwR2FWACyMDM4rJMoKyiv"
  }
],
"Refusal": null,
"FunctionCall": null,
"Id": "6836e35c3a1fce8fd74032c4",
"Model": "openai/gpt-4.1-mini",
"SystemFingerprint": null,
"Usage": {
  "OutputTokenCount": 16,
  "InputTokenCount": 89,
  "TotalTokenCount": 105,
  "OutputTokenDetails": {
    "ReasoningTokenCount": 0,
    "AudioTokenCount": 0
  },
  "InputTokenDetails": {
    "AudioTokenCount": 0,
    "CachedTokenCount": 0
  }
}
}

if (completion.FinishReason == ChatFinishReason.Stop)
{
messages.Add(new AssistantChatMessage(completion));
Console.WriteLine("Final response: " + completion.Content[0].Text);
}

else if (completion.FinishReason == ChatFinishReason.ToolCalls)
{

  messages.Add(new AssistantChatMessage(completion.ToolCalls));
  foreach (ChatToolCall toolCall in completion.ToolCalls)
  {
      
  }
}

else
{
  throw new NotImplementedException($"Unhandled finish reason: {completion.FinishReason}");
}

if (toolCall.FunctionName == nameof(GetCurrentWeather))
{

  using JsonDocument argsJson = JsonDocument.Parse(toolCall.FunctionArguments);
  if (!argsJson.RootElement.TryGetProperty("location", out JsonElement location))
      throw new ArgumentNullException(nameof(location), "location is required");

  bool hasUnit = argsJson.RootElement.TryGetProperty("unit", out JsonElement unit);

  string locationStr = location.GetString() ?? "Unknown";
  string unitStr = hasUnit ? unit.GetString() ?? "celsius" : "celsius";

  Program p = new Program();
  WeatherInfo info = p.GetCurrentWeather(locationStr, unitStr);

  Console.WriteLine($"The weather in {info.Location} is {info.Temperature}° {info.Unit}, {info.Condition}.");
  return;

}

The weather in Tehran is 35° celsius, Sunny.

using System.Text.Json;
using System.ClientModel;

using OpenAI;
using OpenAI.Chat;

class Program
{

  public class WeatherInfo
  {
      public required string Location { get; set; }
      public int Temperature { get; set; }
      public required string Unit { get; set; }
      public required string Condition { get; set; }
  }

  public WeatherInfo GetCurrentWeather(string location, string unit = "celsius")
  {
      int temperature = unit.ToLower() == "celsius" ? 35 : 68;

      return new WeatherInfo
      {
          Location = location,
          Temperature = temperature,
          Unit = unit,
          Condition = "Sunny"
      };
  }
  

  private static readonly ChatTool getCurrentWeatherTool = ChatTool.CreateFunctionTool(
      functionName: nameof(GetCurrentWeather),
      functionDescription: "Get the current weather in a given location",
      functionParameters: BinaryData.FromBytes("""
          {
              "type": "object",
              "properties": {
                  "location": {
                      "type": "string",
                      "description": "The city and state, e.g. Boston, MA"
                  },
                  "unit": {
                      "type": "string",
                      "enum": [ "celsius", "fahrenheit" ],
                      "description": "The temperature unit to use. Infer this from the specified location."
                  }
              },
              "required": [ "location" ]
          }
          """u8.ToArray())
  );

  static void Main()
  {
      string apiKey = "<LIARA_API_KEY>";
      string baseUrl = "<baseUrl>";

      OpenAIClientOptions open_options = new OpenAIClientOptions
      {
          Endpoint = new Uri(baseUrl)
      };

      ChatClient client = new(model: "openai/gpt-4.1-mini", credential: new ApiKeyCredential(apiKey), options: open_options);

      List<ChatMessage> messages = new()
      {
          new UserChatMessage("What's weather like in Tehran")
      };


      ChatCompletionOptions options = new()
      {
          Tools = { getCurrentWeatherTool },       
      };

      ChatCompletion completion = client.CompleteChat(messages, options);

      // Console.WriteLine(JsonSerializer.Serialize(completion, new JsonSerializerOptions { WriteIndented = true }));


      if (completion.FinishReason == ChatFinishReason.Stop)
      {
          messages.Add(new AssistantChatMessage(completion));
          Console.WriteLine("Final response: " + completion.Content[0].Text);
      }
      
      else if (completion.FinishReason == ChatFinishReason.ToolCalls)
      {

          messages.Add(new AssistantChatMessage(completion.ToolCalls));
          foreach (ChatToolCall toolCall in completion.ToolCalls)
          {
              if (toolCall.FunctionName == nameof(GetCurrentWeather))
              {

                  using JsonDocument argsJson = JsonDocument.Parse(toolCall.FunctionArguments);
                  if (!argsJson.RootElement.TryGetProperty("location", out JsonElement location))
                      throw new ArgumentNullException(nameof(location), "location is required");

                  bool hasUnit = argsJson.RootElement.TryGetProperty("unit", out JsonElement unit);

                  string locationStr = location.GetString() ?? "Unknown";
                  string unitStr = hasUnit ? unit.GetString() ?? "celsius" : "celsius";

                  Program p = new Program();
                  WeatherInfo info = p.GetCurrentWeather(locationStr, unitStr);

                  Console.WriteLine($"The weather in {info.Location} is {info.Temperature}° {info.Unit}, {info.Condition}.");
                  return;

              }
          }
      }

      else
      {
          throw new NotImplementedException($"Unhandled finish reason: {completion.FinishReason}");
      }
  }
}

client := openai.NewClient(
option.WithAPIKey("<LIARA_API_KEY>"),
option.WithBaseURL("<baseUrl>"),
)

type WeatherData struct {
Location    string `json:"location"`
Temperature int    `json:"temperature"`
Unit        string `json:"unit"`
Condition   string `json:"condition"`
}

func getWeather(location, unit string) WeatherData {
if unit == "" {
	unit = "celsius"
}

temp := 35
if unit == "fahrenheit" {
	temp = 68
}

return WeatherData{
	Location:    location,
	Temperature: temp,
	Unit:        unit,
	Condition:   "Sunny",
}
}

question := "What's the weather like in Tehran today?"

weatherTool := openai.ChatCompletionToolParam{
Function: openai.FunctionDefinitionParam{
	Name:        "getWeather",
	Description: openai.String("Get the current weather in a given location"),
	Parameters: openai.FunctionParameters{
		"type": "object",
		"properties": map[string]interface{}{
			"location": map[string]string{
				"type":        "string",
				"description": "The city and state, e.g. San Francisco, CA",
			},
			"unit": map[string]interface{}{
				"type": "string",
				"enum": []string{"celsius", "fahrenheit"},
			},
		},
		"required": []string{"location"},
	},
},
}

Function: openai.FunctionDefinitionParam{
Name:        "getWeather",
Description: openai.String("Get the current weather in a given location"),
Parameters: openai.FunctionParameters{
  "type": "object",
  "properties": map[string]interface{}{
    "location": map[string]string{
      "type":        "string",
      "description": "The city and state, e.g. San Francisco, CA",
    },
    "unit": map[string]interface{}{
      "type": "string",
      "enum": []string{"celsius", "fahrenheit"},
    },
  },
  "required": []string{"location"},
},
},

Parameters: openai.FunctionParameters{
"type": "object",
"properties": map[string]interface{}{
  "location": map[string]string{
    "type":        "string",
    "description": "The city and state, e.g. San Francisco, CA",
  },
  "unit": map[string]interface{}{
    "type": "string",
    "enum": []string{"celsius", "fahrenheit"},
  },
},
"required": []string{"location"},
},

const model = "openai/gpt-4.1"
params := openai.ChatCompletionNewParams{
Model: model,
Messages: []openai.ChatCompletionMessageParamUnion{
  openai.UserMessage(question),
},
Tools: []openai.ChatCompletionToolParam{
  weatherTool, 
},
ToolChoice: openai.ChatCompletionToolChoiceOptionUnionParam{
  OfAuto: openai.String("auto"),
},
}

ctx := context.Background()
completion, err := client.Chat.Completions.New(ctx, params)
if err != nil {
	log.Fatal(err)
}

prettyJSON, err := json.MarshalIndent(completion, "", "  ")
if err != nil {
log.Fatal("Failed to generate JSON:", err)
}
fmt.Println(string(prettyJSON))

{
"id": "68381af41a5970e5b082e94c",
"choices": [
  {
    "finish_reason": "tool_calls",
    "index": 0,
    "logprobs": {
      "content": null,
      "refusal": null
    },
    "message": {
      "content": "",
      "refusal": "",
      "role": "assistant",
      "annotations": null,
      "audio": {
        "id": "",
        "data": "",
        "expires_at": 0,
        "transcript": ""
      },
      "function_call": {
        "arguments": "",
        "name": ""
      },
      "tool_calls": [
        {
          "id": "call_2Cqfe9YMVNSP0QFRBoxglI7n",
          "function": {
            "arguments": "{"location":"Tehran"}",
            "name": "getWeather"
          },
          "type": "function"
        }
      ]
    }
  }
],
"created": 1748507379,
"model": "openai/gpt-4.1",
"object": "chat.completion",
"service_tier": "",
"system_fingerprint": "",
"usage": {
  "completion_tokens": 15,
  "prompt_tokens": 79,
  "total_tokens": 94,
  "completion_tokens_details": {
    "accepted_prediction_tokens": 0,
    "audio_tokens": 0,
    "reasoning_tokens": 0,
    "rejected_prediction_tokens": 0
  },
  "prompt_tokens_details": {
    "audio_tokens": 0,
    "cached_tokens": 0
  }
}
}

toolCalls := completion.Choices[0].Message.ToolCalls
if len(toolCalls) == 0 {
fmt.Println("No function call made.")
return
}

prettyJSON, err := json.MarshalIndent(toolCalls, "", "  ")
if err != nil {
log.Fatal("Failed to generate JSON:", err)
}
fmt.Println(string(prettyJSON))

[
{
  "id": "call_5ZSh2tTARuletbd9sRinPTTL",
  "function": {
    "arguments": "{"location":"Tehran"}",
    "name": "getWeather"
  },
  "type": "function"
}
]

for _, toolCall := range toolCalls {
if toolCall.Function.Name == "getWeather" {
  var args map[string]interface{}
  err := json.Unmarshal([]byte(toolCall.Function.Arguments), &args)
  if err != nil {
    log.Fatal(err)
  }

  location := args["location"].(string)
  unit := "celsius" 
  if u, ok := args["unit"].(string); ok && u != "" {
    unit = u
  }

  weather := getWeather(location, unit)

  fmt.Printf("The weather in %s is %d°%s and %s.
",
    weather.Location,
    weather.Temperature,
    string(weather.Unit[0]-32), 
    weather.Condition,
  )

  data, _ := json.Marshal(weather)
  params.Messages = append(params.Messages, openai.ToolMessage(string(data), toolCall.ID))
}
}

The weather in Tehran is 35°C and Sunny.

package main

import (
"context"
"encoding/json"
"fmt"
"log"

"github.com/openai/openai-go"
"github.com/openai/openai-go/option"
)

type WeatherData struct {
Location    string `json:"location"`
Temperature int    `json:"temperature"`
Unit        string `json:"unit"`
Condition   string `json:"condition"`
}

func getWeather(location, unit string) WeatherData {
if unit == "" {
	unit = "celsius"
}

temp := 35
if unit == "fahrenheit" {
	temp = 68
}

return WeatherData{
	Location:    location,
	Temperature: temp,
	Unit:        unit,
	Condition:   "Sunny",
}
}

func main() {


client := openai.NewClient(
	option.WithAPIKey("<LIARA_API_KEY>"),
	option.WithBaseURL("<baseUrl>"),
)

ctx := context.Background()

question := "What's the weather like in Tehran today?"

weatherTool := openai.ChatCompletionToolParam{
	Function: openai.FunctionDefinitionParam{
		Name:        "getWeather",
		Description: openai.String("Get the current weather in a given location"),
		Parameters: openai.FunctionParameters{
			"type": "object",
			"properties": map[string]interface{}{
				"location": map[string]string{
					"type":        "string",
					"description": "The city and state, e.g. San Francisco, CA",
				},
				"unit": map[string]interface{}{
					"type": "string",
					"enum": []string{"celsius", "fahrenheit"},
				},
			},
			"required": []string{"location"},
		},
	},
}

const model = "openai/gpt-4.1"

params := openai.ChatCompletionNewParams{
	Model: model,
	Messages: []openai.ChatCompletionMessageParamUnion{
		openai.UserMessage(question),
	},
	Tools: []openai.ChatCompletionToolParam{
		weatherTool, 
	},
	ToolChoice: openai.ChatCompletionToolChoiceOptionUnionParam{
		OfAuto: openai.String("auto"),
	},
}

completion, err := client.Chat.Completions.New(ctx, params)
if err != nil {
	log.Fatal(err)
}

toolCalls := completion.Choices[0].Message.ToolCalls
if len(toolCalls) == 0 {
	fmt.Println("No function call made.")
	return
}

for _, toolCall := range toolCalls {
	if toolCall.Function.Name == "getWeather" {
		var args map[string]interface{}
		err := json.Unmarshal([]byte(toolCall.Function.Arguments), &args)
		if err != nil {
			log.Fatal(err)
		}

		location := args["location"].(string)
		unit := "celsius" 
		if u, ok := args["unit"].(string); ok && u != "" {
			unit = u
		}

		weather := getWeather(location, unit)

		fmt.Printf("The weather in %s is %d°%s and %s.
",
			weather.Location,
			weather.Temperature,
			string(weather.Unit[0]-32), 
			weather.Condition,
		)

		data, _ := json.Marshal(weather)
		params.Messages = append(params.Messages, openai.ToolMessage(string(data), toolCall.ID))
	}
}
}