Alibaba Cloud Model Studio:Pemanggilan fungsi

## Langkah 1: Definisikan fungsi alat

# Tambahkan impor untuk modul random
import random
from datetime import datetime

# Simulasikan alat kueri cuaca. Contoh output: "The weather in Beijing today is rainy."
def get_current_weather(arguments):
    # Definisikan daftar kondisi cuaca alternatif
    weather_conditions = ["Sunny", "Cloudy", "Rainy"]
    # Pilih kondisi cuaca secara acak
    random_weather = random.choice(weather_conditions)
    # Ekstrak informasi lokasi dari JSON
    location = arguments["location"]
    # Kembalikan informasi cuaca yang diformat
    return f"The weather in {location} today is {random_weather}."

# Alat untuk menanyakan waktu saat ini. Contoh output: "Current time: 2024-04-15 17:15:18."
def get_current_time():
    # Dapatkan tanggal dan waktu saat ini
    current_datetime = datetime.now()
    # Format tanggal dan waktu saat ini
    formatted_time = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
    # Kembalikan waktu saat ini yang diformat
    return f"Current time: {formatted_time}."

# Uji fungsi alat dan cetak hasilnya. Anda dapat menghapus empat baris kode uji berikut saat menjalankan langkah-langkah selanjutnya.
print("Menguji output alat:")
print(get_current_weather({"location": "Shanghai"}))
print(get_current_time())
print("\n")

// Langkah 1: Definisikan fungsi alat

// Impor alat kueri waktu
import { format } from 'date-fns';

function getCurrentWeather(args) {
    // Definisikan daftar kondisi cuaca alternatif
    const weatherConditions = ["Sunny", "Cloudy", "Rainy"];
    // Pilih kondisi cuaca secara acak
    const randomWeather = weatherConditions[Math.floor(Math.random() * weatherConditions.length)];
    // Ekstrak informasi lokasi dari JSON
    const location = args.location;
    // Kembalikan informasi cuaca yang diformat
    return `The weather in ${location} today is ${randomWeather}.`;
}

function getCurrentTime() {
    // Dapatkan tanggal dan waktu saat ini
    const currentDatetime = new Date();
    // Format tanggal dan waktu saat ini
    const formattedTime = format(currentDatetime, 'yyyy-MM-dd HH:mm:ss');
    // Kembalikan waktu saat ini yang diformat
    return `Current time: ${formattedTime}.`;
}

// Uji fungsi alat dan cetak hasilnya. Anda dapat menghapus empat baris kode uji berikut saat menjalankan langkah-langkah selanjutnya.
console.log("Menguji output alat:")
console.log(getCurrentWeather({location:"Shanghai"}));
console.log(getCurrentTime());
console.log("\n")

# Tempel kode berikut setelah kode Langkah 1

## Langkah 2: Buat array tools

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "Berguna saat Anda ingin mengetahui waktu saat ini.",
            "parameters": {}
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.",
                    }
                },
                "required": ["location"]
            }
        }
    }
]
tool_name = [tool["function"]["name"] for tool in tools]
print(f"Dibuat {len(tools)} alat: {tool_name}\n")

// Tempel kode berikut setelah kode Langkah 1

// Langkah 2: Buat array tools

const tools = [
    {
      type: "function",
      function: {
        name: "get_current_time",
        description: "Berguna saat Anda ingin mengetahui waktu saat ini.",
        parameters: {}
      }
    },
    {
      type: "function",
      function: {
        name: "get_current_weather",
        description: "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
        parameters: {
          type: "object",
          properties: {
            location: {
              type: "string",
              description: "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.",
            }
          },
          required: ["location"]
        }
      }
    }
  ];

const toolNames = tools.map(tool => tool.function.name);
console.log(`Dibuat ${tools.length} alat: ${toolNames.join(', ')}\n`);

# Langkah 3: Buat array messages
# Tempel kode berikut setelah kode Langkah 2
# Contoh Pesan Pengguna untuk model generasi teks
messages = [
    {
        "role": "system",
        "content": """Anda adalah asisten yang membantu. Jika pengguna bertanya tentang cuaca, panggil fungsi 'get_current_weather';
     jika pengguna bertanya tentang waktu, panggil fungsi 'get_current_time'.
     Harap jawab pertanyaan dengan nada yang ramah.""",
    },
    {
        "role": "user",
        "content": "Cuaca di Shanghai"
    }
]

# Contoh Pesan Pengguna untuk model multimodal
# messages=[
#  {
#         "role": "system",
#         "content": """Anda adalah asisten yang membantu. Jika pengguna bertanya tentang cuaca, panggil fungsi 'get_current_weather';
#      jika pengguna bertanya tentang waktu, panggil fungsi 'get_current_time'.
#      Harap jawab pertanyaan dengan nada yang ramah.""",
#     },
#     {"role": "user",
#      "content": [{"type": "image_url","image_url": {"url": "https://img.alicdn.com/imgextra/i2/O1CN01FbTJon1ErXVGMRdsN_!!6000000000405-0-tps-1024-683.jpg"}},
#                  {"type": "text", "text": "Tanyakan cuaca saat ini untuk lokasi dalam gambar"}]},
# ]

print("array messages dibuat\n")

// Langkah 3: Buat array messages
// Tempel kode berikut setelah kode Langkah 2
const messages = [
    {
        role: "system",
        content: "Anda adalah asisten yang membantu. Jika pengguna bertanya tentang cuaca, panggil fungsi 'get_current_weather'; jika pengguna bertanya tentang waktu, panggil fungsi 'get_current_time'. Harap jawab pertanyaan dengan nada yang ramah.",
    },
    {
        role: "user",
        content: "Cuaca di Shanghai"
    }
];
// Contoh Pesan Pengguna untuk model multimodal,
// const messages: [{
//     role: "user",
//     content: [{type: "image_url", image_url: {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}},
//               {type: "text", text: "Apa yang digambarkan dalam gambar?"}]
//   }];

console.log("array messages dibuat\n");

# Langkah 4: Lakukan pemanggilan fungsi
# Tempel kode berikut setelah kode Langkah 3
from openai import OpenAI
import os

client = OpenAI(
    // Kunci API berbeda-beda berdasarkan wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
    // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan Kunci API Model Studio Anda: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    // Wilayah Singapura. Ganti {WorkspaceId} dengan ID Ruang Kerja aktual Anda. URL berbeda-beda berdasarkan wilayah.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

def function_calling():
    completion = client.chat.completions.create(
        // Contoh ini menggunakan qwen3.8-max. Anda dapat mengubah nama model sesuai kebutuhan. Untuk daftar model, lihat https://www.alibabacloud.com/help/en/model-studio/getting-started/models
        model="qwen3.8-max",
        extra_body={"enable_thinking": False},
        messages=messages,
        tools=tools
    )
    print("Objek yang dikembalikan:")
    print(completion.choices[0].message.model_dump_json())
    print("\n")
    return completion

print("Melakukan pemanggilan fungsi...")
completion = function_calling()

// Langkah 4: Lakukan pemanggilan fungsi
// Tempel kode berikut setelah kode Langkah 3
import OpenAI from "openai";
const openai = new OpenAI(
    {
        // Kunci API berbeda-beda berdasarkan wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
        // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan Kunci API Model Studio Anda: apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Wilayah Singapura. Ganti {WorkspaceId} dengan ID Ruang Kerja aktual Anda. URL berbeda-beda berdasarkan wilayah.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
    }
);

async function functionCalling() {
    const completion = await openai.chat.completions.create({
        model: "qwen3.8-max",  // Contoh ini menggunakan qwen3.8-max. Anda dapat mengubah nama model sesuai kebutuhan. Untuk daftar model, lihat https://www.alibabacloud.com/help/en/model-studio/getting-started/models
        enable_thinking: false,
        messages: messages,
        tools: tools
    });
    console.log("Objek yang dikembalikan:");
    console.log(JSON.stringify(completion.choices[0].message));
    console.log("\n");
    return completion;
}

const completion = await functionCalling();

# Langkah 5: Jalankan fungsi alat
# Tempelkan kode berikut setelah kode Langkah 4
import json

print("Menjalankan fungsi alat...")
# Dapatkan nama fungsi dan parameter input dari hasil yang dikembalikan
function_name = completion.choices[0].message.tool_calls[0].function.name
arguments_string = completion.choices[0].message.tool_calls[0].function.arguments

# Gunakan modul json untuk mengurai string parameter
arguments = json.loads(arguments_string)
# Buat tabel pemetaan fungsi
function_mapper = {
    "get_current_weather": get_current_weather,
    "get_current_time": get_current_time
}
# Dapatkan entitas fungsi
function = function_mapper[function_name]
# Jika parameter input kosong, panggil fungsi secara langsung
if arguments == {}:
    function_output = function()
# Jika tidak, teruskan parameter lalu panggil fungsi
else:
    function_output = function(arguments)
# Cetak output alat
print(f"Output fungsi alat: {function_output}\n")

// Langkah 5: Jalankan fungsi alat
// Tempel kode berikut setelah kode Langkah 4

console.log("Menjalankan fungsi alat...");
const function_name = completion.choices[0].message.tool_calls[0].function.name;
const arguments_string = completion.choices[0].message.tool_calls[0].function.arguments;

// Gunakan modul JSON untuk mengurai string parameter
const args = JSON.parse(arguments_string);

// Buat tabel pemetaan fungsi
const functionMapper = {
    "get_current_weather": getCurrentWeather,
    "get_current_time": getCurrentTime
};

// Dapatkan entitas fungsi
const func = functionMapper[function_name];

// Jika parameter input kosong, panggil fungsi langsung
let functionOutput;
if (Object.keys(args).length === 0) {
    functionOutput = func();
} else {
    // Jika tidak, teruskan parameter lalu panggil fungsi
    functionOutput = func(args);
}

// Cetak output alat
console.log(`Output fungsi alat: ${functionOutput}\n`);

# Langkah 6: Kirim output alat ke LLM
# Tempel kode berikut setelah kode Langkah 5

messages.append(completion.choices[0].message)
print("Pesan asisten ditambahkan")
messages.append({"role": "tool", "content": function_output, "tool_call_id": completion.choices[0].message.tool_calls[0].id})
print("Pesan alat ditambahkan\n")

// Langkah 6: Kirim output alat ke LLM
// Tempel kode berikut setelah kode Langkah 5

messages.push(completion.choices[0].message);
console.log("Pesan asisten ditambahkan")
messages.push({
    "role": "tool",
    "content": functionOutput,
    "tool_call_id": completion.choices[0].message.tool_calls[0].id
});
console.log("Pesan alat ditambahkan\n");

# Langkah 7: Biarkan LLM merangkum output alat
# Tempel kode berikut setelah kode Langkah 6
print("Merangkum output alat...")
completion = function_calling()

// Langkah 7: Biarkan LLM merangkum output alat
// Tempel kode berikut setelah kode Langkah 6

console.log("Merangkum output alat...");
const completion_1 = await functionCalling();

def function_calling():
    completion = client.chat.completions.create(
        model="qwen3.8-max",  // Contoh ini menggunakan qwen3.8-max. Anda dapat mengubah nama model sesuai kebutuhan.
        extra_body={"enable_thinking": False},
        messages=messages,
        tools=tools,
        // Parameter baru
        parallel_tool_calls=True
    )
    print("Objek yang dikembalikan:")
    print(completion.choices[0].message.model_dump_json())
    print("\n")
    return completion

print("Melakukan pemanggilan fungsi...")
completion = function_calling()

async function functionCalling() {
    const completion = await openai.chat.completions.create({
        model: "qwen3.8-max",  // Contoh ini menggunakan qwen3.8-max. Anda dapat mengubah nama model sesuai kebutuhan.
        enable_thinking: false,
        messages: messages,
        tools: tools,
        parallel_tool_calls: true
    });
    console.log("Objek yang dikembalikan:");
    console.log(JSON.stringify(completion.choices[0].message));
    console.log("\n");
    return completion;
}

const completion = await functionCalling();

def function_calling():
    completion = client.chat.completions.create(
        model="qwen3.8-max",
        extra_body={"enable_thinking": False},
        messages=messages,
        tools=tools,
        tool_choice="required"
    )
    print(completion.model_dump_json())

function_calling()

async function functionCalling() {
    const completion = await openai.chat.completions.create({
        model: "qwen3.8-max",
        enable_thinking: false,
        messages: messages,
        tools: tools,
        tool_choice: "required"
    });
    console.log("Objek yang dikembalikan:");
    console.log(JSON.stringify(completion.choices[0].message));
    console.log("\n");
    return completion;
}

const completion = await functionCalling();

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    // Wilayah Singapura. Ganti {WorkspaceId} dengan ID Ruang Kerja aktual Anda. URL berbeda-beda berdasarkan wilayah.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.",
                    }
                },
                "required": ["location"],
            },
        },
    },
]

stream = client.chat.completions.create(
    model="qwen3.8-max",
    extra_body={"enable_thinking": False},
    messages=[{"role": "user", "content": "Cuaca di Hangzhou?"}],
    tools=tools,
    stream=True
)

for chunk in stream:
    delta = chunk.choices[0].delta
    print(delta.tool_calls)

import { OpenAI } from "openai";

const openai = new OpenAI(
    {
        // Kunci API berbeda-beda berdasarkan wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
        // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan Kunci API Model Studio Anda: apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Wilayah Tiongkok (Beijing). Ganti {WorkspaceId} dengan ID Ruang Kerja aktual Anda. URL berbeda-beda berdasarkan wilayah.
        baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
    }
);
const tools = [
    {
        "type": "function",
        "function": {
            "name": "getCurrentWeather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang."
                    }
                },
                "required": ["location"]
            }
        }
    }
];

const stream = await openai.chat.completions.create({
    model: "qwen3.8-max",
    enable_thinking: false,
    messages: [{ role: "user", content: "Cuaca di Beijing" }],
    tools: tools,
    stream: true,
});

for await (const chunk of stream) {
    const delta = chunk.choices[0].delta;
    console.log(delta.tool_calls);
}

tool_calls = {}
for response_chunk in stream:
    delta_tool_calls = response_chunk.choices[0].delta.tool_calls
    if delta_tool_calls:
        for tool_call_chunk in delta_tool_calls:
            call_index = tool_call_chunk.index
            tool_call_chunk.function.arguments = tool_call_chunk.function.arguments or ""
            if call_index not in tool_calls:
                tool_calls[call_index] = tool_call_chunk
            else:
                tool_calls[call_index].function.arguments += tool_call_chunk.function.arguments
print(tool_calls[0].model_dump_json())

const toolCalls = {};
for await (const responseChunk of stream) {
  const deltaToolCalls = responseChunk.choices[0]?.delta?.tool_calls;
  if (deltaToolCalls) {
    for (const toolCallChunk of deltaToolCalls) {
      const index = toolCallChunk.index;
      toolCallChunk.function.arguments = toolCallChunk.function.arguments || "";
      if (!toolCalls[index]) {
        toolCalls[index] = { ...toolCallChunk };
        if (!toolCalls[index].function) {
            toolCalls[index].function = { name: '', arguments: '' };
        }
      }
      else if (toolCallChunk.function?.arguments) {
        toolCalls[index].function.arguments += toolCallChunk.function.arguments;
      }
    }
  }
}
console.log(JSON.stringify(toolCalls[0]));

from openai import OpenAI
import json
import os
import random

// Inisialisasi klien
client = OpenAI(
    // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan Kunci API Model Studio Anda: api_key="sk-xxx",
    // Kunci API berbeda-beda berdasarkan wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
// Simulasikan pertanyaan pengguna
USER_QUESTION = "Bagaimana cuaca di Singapura?"
// Definisikan daftar alat
tools = [
    {
        "type": "function",
        "name": "get_current_weather",
        "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "Kota atau distrik, seperti Singapura atau London.",
                }
            },
            "required": ["location"],
        },
    }
]

// Simulasikan alat kueri cuaca
def get_current_weather(arguments):
    weather_conditions = ["Sunny", "Cloudy", "Rainy"]
    random_weather = random.choice(weather_conditions)
    location = arguments["location"]
    return f"The weather in {location} today is {random_weather}."

// Enkapsulasi fungsi respons model
def get_response(input_data):
    response = client.responses.create(
        model="qwen3.8-max",
        extra_body={"enable_thinking": False},
        input=input_data,
        tools=tools,
    )
    return response

// Pertahankan konteks percakapan
conversation = [{"role": "user", "content": USER_QUESTION}]

response = get_response(conversation)
function_calls = [item for item in response.output if item.type == "function_call"]
// Jika tidak diperlukan pemanggilan alat, cetak konten secara langsung
if not function_calls:
    print(f"Respons akhir Asisten: {response.output_text}")
else:
    // Masuk ke loop pemanggilan alat
    while function_calls:
        for fc in function_calls:
            func_name = fc.name
            arguments = json.loads(fc.arguments)
            print(f"Memanggil alat [{func_name}], argumen: {arguments}")
            // Jalankan alat
            tool_result = get_current_weather(arguments)
            print(f"Alat mengembalikan: {tool_result}")
            // Tambahkan pasangan pemanggilan dan hasil alat ke konteks
            conversation.append(
                {
                    "type": "function_call",
                    "name": fc.name,
                    "arguments": fc.arguments,
                    "call_id": fc.call_id,
                }
            )
            conversation.append(
                {
                    "type": "function_call_output",
                    "call_id": fc.call_id,
                    "output": tool_result,
                }
            )
        // Panggil model lagi dengan konteks lengkap
        response = get_response(conversation)
        function_calls = [
            item for item in response.output if item.type == "function_call"
        ]
    print(f"Respons akhir Asisten: {response.output_text}")

import OpenAI from "openai";

// Inisialisasi klien
const openai = new OpenAI({
  // Kunci API bervariasi menurut Wilayah. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
  // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan kunci API Model Studio Anda: apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL:
    "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
});

// Tentukan daftar alat
const tools = [
  {
    type: "function",
    name: "get_current_weather",
    description: "Useful for when you want to query the weather in a specific city.",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "A city or district, such as Singapore or London.",
        },
      },
      required: ["location"],
    },
  },
];

// Simulasikan alat kueri cuaca
const getCurrentWeather = (args) => {
  const weatherConditions = ["Sunny", "Cloudy", "Rainy"];
  const randomWeather =
    weatherConditions[Math.floor(Math.random() * weatherConditions.length)];
  const location = args.location;
  return `The weather in ${location} today is ${randomWeather}.`;
};

// Enkapsulasi fungsi tanggapan model
const getResponse = async (inputData) => {
  const response = await openai.responses.create({
    model: "qwen3.8-max",
    enable_thinking: false,
    input: inputData,
    tools: tools,
  });
  return response;
};

const main = async () => {
  const userQuestion = "Weather in Singapore";

  // Pertahankan konteks percakapan
  const conversation = [{ role: "user", content: userQuestion }];

  let response = await getResponse(conversation);
  let functionCalls = response.output.filter(
    (item) => item.type === "function_call"
  );
  // Jika tidak ada pemanggilan alat yang diperlukan, cetak konten secara langsung
  if (functionCalls.length === 0) {
    console.log(`Assistant's final response: ${response.output_text}`);
  } else {
    // Masuk ke loop pemanggilan alat
    while (functionCalls.length > 0) {
      for (const fc of functionCalls) {
        const funcName = fc.name;
        const args = JSON.parse(fc.arguments);
        console.log(`Calling tool [${funcName}], arguments:`, args);
        // Jalankan alat
        const toolResult = getCurrentWeather(args);
        console.log(`Tool returns: ${toolResult}`);
        // Tambahkan pemanggilan alat dan hasilnya sebagai pasangan ke konteks
        conversation.push({
          type: "function_call",
          name: fc.name,
          arguments: fc.arguments,
          call_id: fc.call_id,
        });
        conversation.push({
          type: "function_call_output",
          call_id: fc.call_id,
          output: toolResult,
        });
      }
      // Panggil model lagi dengan konteks lengkap
      response = await getResponse(conversation);
      functionCalls = response.output.filter(
        (item) => item.type === "function_call"
      );
    }
    console.log(`Assistant's final response: ${response.output_text}`);
  }
};

// Mulai program
main().catch(console.error);

from openai import OpenAI
import os

client = OpenAI(
    // Kunci API berbeda-beda berdasarkan wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    // Wilayah Singapura. Ganti {WorkspaceId} dengan ID Ruang Kerja aktual Anda. URL berbeda-beda berdasarkan wilayah.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.",
                    }
                },
                "required": ["location"],
            },
        },
    },
]

completion = client.chat.completions.create(
    model="qwen3.5-omni-plus",
    messages=[{"role": "user", "content": "Cuaca di Hangzhou?"}],

    // Atur modalitas data output. Nilai yang valid: ["text"], ["text","audio"]. Kami merekomendasikan mengaturnya ke ["text"].
    modalities=["text"],

    // stream harus diatur ke True, jika tidak akan terjadi error.
    stream=True,
    tools=tools
)

for chunk in completion:
    // Jika output mencakup modalitas audio, ubah kondisi berikut menjadi: if chunk.choices and not hasattr(chunk.choices[0].delta, "audio"):
    if chunk.choices:
        delta = chunk.choices[0].delta
        print(delta.tool_calls)

import { OpenAI } from "openai";

const openai = new OpenAI(
    {
        // Kunci API berbeda-beda berdasarkan wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
        // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan Kunci API Model Studio Anda: apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Wilayah Singapura. Ganti {WorkspaceId} dengan ID Ruang Kerja aktual Anda. URL berbeda-beda berdasarkan wilayah.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
    }
);
const tools = [
    {
        "type": "function",
        "function": {
            "name": "getCurrentWeather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang."
                    }
                },
                "required": ["location"]
            }
        }
    }
];

const stream = await openai.chat.completions.create({
    model: "qwen3-omni-flash",
    messages: [
        {
            "role": "user",
            "content": "Cuaca di Hangzhou"
        }],
    stream: true,
    // Atur modalitas data output. Nilai yang valid: ["text"], ["text","audio"]. Kami merekomendasikan mengaturnya ke ["text"].
    modalities: ["text"],
    tools:tools
});

for await (const chunk of stream) {
    // Jika output mencakup audio, ganti pernyataan kondisional dengan: if (chunk.choices?.length && chunk.choices[0].delta && !('audio' in chunk.choices[0].delta))
    if (chunk.choices?.length){
    const delta = chunk.choices[0].delta;
    console.log(delta.tool_calls);
}}

import os
import uuid
import threading
import traceback
import json
import base64
import signal
import sys
import time
from typing import Dict, Any, Optional, List
import pyaudio
import queue
import contextlib
import dashscope
from dashscope.audio.qwen_omni import *

# ==================== Definisi Konstanta ====================
VOICE = 'Tina'
MODEL = "qwen3.5-omni-plus-realtime"
# Untuk mengakses wilayah Beijing, ganti WS_URL dengan: wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/realtime
WS_URL = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime"
# Konfigurasikan kunci API. Jika Anda belum mengatur variabel lingkungan, ganti baris berikut dengan kunci API Anda: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.getenv('DASHSCOPE_API_KEY')
AUDIO_SAMPLE_RATE = 16000
AUDIO_CHUNK_SIZE = 3200
OUTPUT_AUDIO_SAMPLE_RATE = 24000

# ==================== Definisi Alat (Tool) ====================
def get_train_price(src: str, dst: str) -> str:
    """Kueri harga tiket kereta"""
    return f"The train ticket price from {src} to {dst} is 100-200 CNY."

def get_flight_price(src: str, dst: str) -> str:
    """Kueri harga tiket pesawat"""
    return f"The flight ticket price from {src} to {dst} is 200-300 USD."

def get_current_weather(location: str) -> str:
    """Kueri cuaca di kota tertentu"""
    return f"The weather in {location} today is changing from haze to sunny, with a temperature of 4/-4°C and a light breeze."

# Definisi alat (tool) format OpenAI terpadu
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Sebuah kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.",
                    }
                },
                "required": ["location"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_flight_price",
            "description": "Berguna saat Anda ingin menanyakan harga tiket pesawat.",
            "parameters": {
                "type": "object",
                "properties": {
                    "src": {
                        "type": "string",
                        "description": "Kota keberangkatan penerbangan, seperti Beijing atau Hangzhou.",
                    },
                    "dst": {
                        "type": "string",
                        "description": "Kota kedatangan penerbangan, seperti Beijing atau Hangzhou.",
                    },
                },
                "required": ["src", "dst"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_train_price",
            "description": "Berguna saat Anda ingin menanyakan harga tiket kereta.",
            "parameters": {
                "type": "object",
                "properties": {
                    "src": {
                        "type": "string",
                        "description": "Kota keberangkatan kereta, seperti Beijing atau Hangzhou.",
                    },
                    "dst": {
                        "type": "string",
                        "description": "Kota kedatangan kereta, seperti Beijing atau Hangzhou.",
                    },
                },
                "required": ["src", "dst"],
            },
        },
    },
]

# Pemetaan nama alat (tool) ke fungsi
TOOL_FUNCTIONS = {
    "get_current_weather": get_current_weather,
    "get_flight_price": get_flight_price,
    "get_train_price": get_train_price,
}

# ==================== Penanganan Panggilan Alat (Tool Call) ====================
def handle_tool_call(tool_call_response: Dict[str, Any]) -> Dict[str, Any]:
    """
    Menangani permintaan panggilan alat (tool call)

    Args:
        tool_call_response: Informasi panggilan alat yang berisi nama, argumen, dan call_id

    Returns:
        Respons panggilan alat yang diperbarui yang berisi bidang output
    """
    try:
        function_name = tool_call_response['name']
        tool_call_arguments = json.loads(tool_call_response['arguments'])

        print(f'[Tool Call] Start processing: name={function_name}, args={tool_call_arguments}')

        # Temukan fungsi yang sesuai
        if function_name not in TOOL_FUNCTIONS:
            tool_call_response['output'] = f"Client did not find the tool: {function_name}"
            print(f'[Tool Call] Error: Tool not found {function_name}')
            return tool_call_response

        # Panggil fungsi
        func = TOOL_FUNCTIONS[function_name]
        result = func(**tool_call_arguments)
        tool_call_response['output'] = result

        print(f'[Tool Call] Completed: {result}')
        return tool_call_response

    except Exception as e:
        error_msg = f"Tool call failed: {str(e)}"
        tool_call_response['output'] = error_msg
        print(f'[Tool Call] Exception: {error_msg}')
        traceback.print_exc()
        return tool_call_response

def send_tool_call_response(conversation: OmniRealtimeConversation, response: Dict[str, Any]) -> None:
    """Mengirimkan hasil panggilan alat (tool call) ke server"""
    conversation.create_item({
        "id": 'item_' + uuid.uuid4().hex,
        "type": "function_call_output",
        "call_id": response['call_id'],
        "output": response["output"],
    })

# ==================== Pemutar Audio PCM ====================
class PCMPlayer:
    """
    Pemutar Audio PCM

    Menggunakan arsitektur dual-thread untuk pemutaran audio real-time:
    - Thread decoding: Mendekode data audio yang dienkode base64 menjadi data PCM mentah
    - Thread pemutaran: Menulis data PCM ke perangkat output audio

    Mendukung penambahan data audio secara dinamis, pembatalan pemutaran, penyimpanan file audio, dll.
    """

    def __init__(self, pya: pyaudio.PyAudio, sample_rate=24000, chunk_size_ms=100, save_file=False):
        """
        Menginisialisasi pemutar PCM

        Args:
            pya: Instans pyaudio.PyAudio
            sample_rate: Laju pengambilan sampel audio (Hz), default 24000
            chunk_size_ms: Ukuran chunk audio (milidetik), memengaruhi latensi pembatalan pemutaran, default 100ms
            save_file: Apakah akan menyimpan audio yang diputar ke file (result.pcm), default False
        """

        self.pya = pya
        self.sample_rate = sample_rate
        self.chunk_size_bytes = chunk_size_ms * sample_rate * 2 // 1000
        self.player_stream = pya.open(format=pyaudio.paInt16,
                                       channels=1,
                                       rate=sample_rate,
                                       output=True)

        self.raw_audio_buffer: queue.Queue = queue.Queue()
        self.b64_audio_buffer: queue.Queue = queue.Queue()
        self.status_lock = threading.Lock()
        self.status = 'playing'
        self.decoder_thread = threading.Thread(target=self.decoder_loop)
        self.player_thread = threading.Thread(target=self.player_loop)
        self.decoder_thread.start()
        self.player_thread.start()
        self.complete_event: threading.Event = None
        self.save_file = save_file
        if self.save_file:
            self.out_file = open('result.pcm', 'wb')

    def decoder_loop(self):
        """Thread decoding: Mendekode data audio base64 menjadi data PCM mentah"""
        while self.status != 'stop':
            recv_audio_b64 = None
            with contextlib.suppress(queue.Empty):
                recv_audio_b64 = self.b64_audio_buffer.get(timeout=0.1)
            if recv_audio_b64 is None:
                continue
            recv_audio_raw = base64.b64decode(recv_audio_b64)
            # dorong data audio mentah ke antrian per chunk
            for i in range(0, len(recv_audio_raw), self.chunk_size_bytes):
                chunk = recv_audio_raw[i:i + self.chunk_size_bytes]
                self.raw_audio_buffer.put(chunk)
                if self.save_file:
                    self.out_file.write(chunk)

    def player_loop(self):
        """Thread pemutaran: Menulis data PCM ke perangkat output audio"""
        while self.status != 'stop':
            recv_audio_raw = None
            with contextlib.suppress(queue.Empty):
                recv_audio_raw = self.raw_audio_buffer.get(timeout=0.1)
            if recv_audio_raw is None:
                if self.complete_event:
                    self.complete_event.set()
                continue
            # tulis chunk ke pemutar audio pyaudio, tunggu hingga selesai memutar chunk ini.
            self.player_stream.write(recv_audio_raw)

    def cancel_playing(self):
        """Batalkan pemutaran: Kosongkan semua antrian buffer"""
        self.b64_audio_buffer.queue.clear()
        self.raw_audio_buffer.queue.clear()

    def add_data(self, data):
        """Tambahkan data audio yang dienkode base64 ke antrian pemutaran"""
        self.b64_audio_buffer.put(data)

    def wait_for_complete(self):
        """Tunggu hingga pemutaran selesai"""
        self.complete_event = threading.Event()
        self.complete_event.wait()
        self.complete_event = None

    def shutdown(self):
        """Matikan pemutar dan lepaskan sumber daya"""
        self.status = 'stop'
        self.decoder_thread.join()
        self.player_thread.join()
        self.player_stream.close()
        if self.save_file:
            self.out_file.close()

# ==================== Manajer Audio ====================
class AudioManager:
    """Mengelola sumber daya input dan output audio"""

    def __init__(self):
        self.pya: Optional[pyaudio.PyAudio] = None
        self.mic_stream: Optional[pyaudio.Stream] = None
        self.player: Optional[PCMPlayer] = None

    def initialize(self) -> None:
        """Inisialisasi perangkat audio"""
        print('Initializing audio devices...')
        self.pya = pyaudio.PyAudio()
        self.mic_stream = self.pya.open(
            format=pyaudio.paInt16,
            channels=1,
            rate=AUDIO_SAMPLE_RATE,
            input=True
        )
        self.player = PCMPlayer(self.pya, sample_rate=OUTPUT_AUDIO_SAMPLE_RATE)
        print('Audio devices initialized')

    def read_audio_chunk(self) -> Optional[bytes]:
        """Baca sebuah chunk data audio"""
        if not self.mic_stream:
            return None
        try:
            return self.mic_stream.read(AUDIO_CHUNK_SIZE, exception_on_overflow=False)
        except Exception as e:
            print(f'[Error] Failed to read audio data: {e}')
            return None

    def cleanup(self) -> None:
        """Bersihkan sumber daya audio"""
        print('Cleaning up audio resources...')
        if self.player:
            self.player.shutdown()
        if self.mic_stream:
            self.mic_stream.close()
        if self.pya:
            self.pya.terminate()
        print('Audio resources cleaned up')

# ==================== Penangan Callback ====================
class OmniCallback(OmniRealtimeCallback):
    """Penangan callback percakapan real-time Omni"""

    def __init__(self, audio_manager: AudioManager):
        self.audio_manager = audio_manager
        self.tool_calls: Dict[str, Dict[str, Any]] = {}
        self.all_response_text: str = ''
        self.last_package_time: float = 0
        self.is_first_text: bool = True
        self.is_first_audio: bool = True
        self.conversation: Optional[OmniRealtimeConversation] = None

    def set_conversation(self, conversation: OmniRealtimeConversation) -> None:
        """Atur referensi instans percakapan"""
        self.conversation = conversation

    def on_open(self) -> None:
        """Callback saat koneksi terjalin"""
        print('Connection established')
        self.audio_manager.initialize()
        self.last_package_time = time.time() * 1000
        self.is_first_text = True
        self.is_first_audio = True
        self.tool_calls = {}
        self.all_response_text = ''

    def on_close(self, close_status_code: int, close_msg: str) -> None:
        """Callback saat koneksi ditutup"""
        print(f'Connection closed: code={close_status_code}, msg={close_msg}')
        self.audio_manager.cleanup()
        sys.exit(0)

    def on_event(self, response: Dict[str, Any]) -> None:
        """Tangani callback event"""
        try:
            event_type = response.get('type', '')

            # Sesi dibuat
            if event_type == 'session.created':
                print(f'Session started: {response["session"]["id"]}')

            # Speech-to-text selesai
            elif event_type == 'conversation.item.input_audio_transcription.completed':
                print(f'User question: {response.get("transcript", "")}')

            # Respons teks inkremental
            elif event_type in ('response.audio_transcript.delta', 'response.text.delta'):
                if self.is_first_text:
                    self.is_first_text = False
                    latency = time.time() * 1000 - self.last_package_time
                    print(f'Time to first token (VAD end): {latency:.0f} ms')

                text = response.get('delta', '')
                self.all_response_text += text

            # Respons audio inkremental
            elif event_type == 'response.audio.delta':
                if self.is_first_audio:
                    self.is_first_audio = False
                    latency = time.time() * 1000 - self.last_package_time
                    print(f'Time to first audio (VAD end): {latency:.0f} ms')

                audio_interval = time.time() * 1000 - self.last_package_time
                print(f'Audio interval: {audio_interval:.0f} ms')
                self.last_package_time = time.time() * 1000

                recv_audio_b64 = response.get('delta', '')
                if self.audio_manager.player:
                    self.audio_manager.player.add_data(recv_audio_b64)

            # VAD mendeteksi awal ucapan
            elif event_type == 'input_audio_buffer.speech_started':
                print('====== VAD detected speech start ======')
                if self.audio_manager.player:
                    self.audio_manager.player.cancel_playing()

            # VAD mendeteksi akhir ucapan
            elif event_type == 'input_audio_buffer.speech_stopped':
                print('====== VAD detected speech end ======')
                self.last_package_time = time.time() * 1000
                self.is_first_text = True
                self.is_first_audio = True
                self.tool_calls = {}

            # Argumen panggilan fungsi selesai
            elif event_type == 'response.function_call_arguments.done':
                print('====== Received tool call request ======')
                call_id = response.get('call_id', '')
                self.tool_calls[call_id] = response.copy()
                self.tool_calls[call_id]['processed'] = False

            # Respons selesai
            elif event_type == 'response.done':
                print('====== Response completed ======')
                print(f'Full response: {self.all_response_text}')

                if self.conversation:
                    response_id = self.conversation.get_last_response_id()
                    text_delay = self.conversation.get_last_first_text_delay()
                    audio_delay = self.conversation.get_last_first_audio_delay()

                    # Cetak metrik terperinci hanya jika semua tersedia
                    if response_id is not None and text_delay is not None and audio_delay is not None:
                        print(f'[Metric] Response ID: {response_id}, '
                              f'Time to first token: {text_delay:.0f}ms, '
                              f'Time to first audio: {audio_delay:.0f}ms')
                    else:
                        print('[Metrik] Informasi metrik untuk sementara tidak tersedia (kemungkinan respons setelah panggilan alat)')

                self.all_response_text = ''

        except Exception as e:
            print(f'[Error] Exception handling event: {e}')
            traceback.print_exc()

    def process_pending_tool_calls(self) -> bool:
        """
        Memproses panggilan alat (tool call) yang tertunda

        Returns:
            Apakah ada panggilan alat baru yang memerlukan respons
        """
        has_pending = False

        for call_id, tool_call in self.tool_calls.items():
            if not tool_call.get('processed', False):
                has_pending = True
                tool_call['processed'] = True

                # Tangani panggilan alat (tool call)
                result = handle_tool_call(tool_call)

                # Kirim hasilnya ke server
                if self.conversation:
                    send_tool_call_response(self.conversation, result)

        return has_pending

# ==================== Program Utama ====================
def main():
    """Fungsi utama"""
    print('Initializing Omni real-time conversation...')

    # Buat manajer audio
    audio_manager = AudioManager()

    # Buat penangan callback
    callback = OmniCallback(audio_manager)

    # Buat instans percakapan
    conversation = OmniRealtimeConversation(
        api_key=dashscope.api_key,
        url=WS_URL,
        model=MODEL,
        callback=callback,
    )

    # Atur referensi percakapan di callback
    callback.set_conversation(conversation)

    # Buat koneksi
    conversation.connect()

    # Konfigurasikan parameter sesi
    omni_output_modalities = [MultiModality.AUDIO, MultiModality.TEXT]

    conversation.update_session(
        output_modalities=omni_output_modalities,
        voice=VOICE,
        input_audio_format=AudioFormat.PCM_16000HZ_MONO_16BIT,
        output_audio_format=AudioFormat.PCM_24000HZ_MONO_16BIT,
        enable_input_audio_transcription=True,
        enable_turn_detection=True,
        turn_detection_type='server_vad',
        tools=TOOLS,
    )

    # Siapkan penanganan sinyal
    def signal_handler(sig, frame):
        print('\nMenerima Ctrl+C, menghentikan...')
        conversation.close()
        audio_manager.cleanup()
        print('Percakapan real-time Omni dihentikan')
        sys.exit(0)

    signal.signal(signal.SIGINT, signal_handler)
    print("Tekan Ctrl+C untuk menghentikan percakapan...\n")

    # Loop utama: terus-menerus mengirim audio dan memeriksa panggilan alat (tool call)
    try:
        while True:
            # Proses panggilan alat (tool call) yang tertunda
            has_tool_calls = callback.process_pending_tool_calls()

            if has_tool_calls:
                print("*** Panggilan alat selesai, membuat respons baru ***")
                conversation.create_response(
                    instructions=None,
                    output_modalities=omni_output_modalities
                )
                print('====== Pemrosesan panggilan alat selesai ======\n')

            # Baca dan kirim data audio
            audio_data = audio_manager.read_audio_chunk()
            if audio_data:
                audio_b64 = base64.b64encode(audio_data).decode('ascii')
                conversation.append_audio(audio_b64)
            else:
                break

    except KeyboardInterrupt:
        signal_handler(signal.SIGINT, None)
    except Exception as e:
        print(f'[Error] Main loop exception: {e}')
        traceback.print_exc()
    finally:
        conversation.close()
        audio_manager.cleanup()

if __name__ == '__main__':
    main()

import com.alibaba.dashscope.audio.omni.*;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import javax.sound.sampled.*;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;

public class Main {

    public static void main(String[] args) {
        try {
            // Inisialisasi komponen
            AudioPlayer audioPlayer = new AudioPlayer();
            ToolRegistry toolRegistry = new ToolRegistry();
            ConversationHandler handler = new ConversationHandler(audioPlayer, toolRegistry);

            // Buat dan konfigurasi sesi
            OmniRealtimeParam param = OmniRealtimeParam.builder()
                    .model("qwen3.5-omni-plus-realtime")
                    .apikey(System.getenv("DASHSCOPE_API_KEY"))
                    // Untuk mengakses wilayah Beijing, ganti url dengan: wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/realtime
                    .url("wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime")
                    .build();

            OmniRealtimeConversation conversation = new OmniRealtimeConversation(param, handler);
            conversation.connect();

            // Konfigurasi parameter sesi
            configureSession(conversation, toolRegistry);

            // Mulai pengambilan audio
            startAudioCapture(conversation, handler);

            // Bersihkan sumber daya
            cleanup(conversation, audioPlayer);

        } catch (NoApiKeyException e) {
            System.err.println("KUNCI API tidak ditemukan: Harap atur variabel lingkungan DASHSCOPE_API_KEY");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void configureSession(OmniRealtimeConversation conversation, ToolRegistry toolRegistry) {
        HashMap<String, Object> additionalConfig = new HashMap<>();
        additionalConfig.put("tools", toolRegistry.buildToolsDefinition());

        conversation.updateSession(OmniRealtimeConfig.builder()
                .modalities(Arrays.asList(OmniRealtimeModality.AUDIO, OmniRealtimeModality.TEXT))
                .voice("Tina")
                .enableTurnDetection(true)
                .enableInputAudioTranscription(true)
                .parameters(additionalConfig)
                .build());

        System.out.println("Pemanggilan alat diaktifkan. Silakan mulai berbicara (Tekan Ctrl+C untuk keluar)...");
    }

    private static void startAudioCapture(OmniRealtimeConversation conversation, ConversationHandler handler)
            throws LineUnavailableException {
        AudioFormat format = new AudioFormat(16000, 16, 1, true, false);
        TargetDataLine mic = AudioSystem.getTargetDataLine(format);
        mic.open(format);
        mic.start();

        ByteBuffer buffer = ByteBuffer.allocate(3200);
        while (!handler.getShouldStop().get()) {
            int bytesRead = mic.read(buffer.array(), 0, buffer.capacity());
            if (bytesRead > 0) {
                conversation.appendAudio(Base64.getEncoder().encodeToString(buffer.array()));

                // Periksa dan proses pemanggilan alat yang tertunda
                if (handler.hasPendingToolCalls()) {
                    System.out.println("*** buat respons setelah memanggil alat");
                    handler.processPendingToolCalls(conversation);
                    conversation.createResponse(null, Arrays.asList(OmniRealtimeModality.AUDIO, OmniRealtimeModality.TEXT));
                    System.out.println("======PEMANGGILAN ALAT SELESAI======");
                }
            }
            try {
                Thread.sleep(20);
            } catch (InterruptedException ignored) {}
        }

        mic.close();
    }

    private static void cleanup(OmniRealtimeConversation conversation, AudioPlayer audioPlayer) {
        try {
            conversation.close(1000, "Keluar normal");
            audioPlayer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Pemutar Audio - Bertanggung jawab atas pemutaran berurutan data audio
     */
    static class AudioPlayer {
        private final SourceDataLine line;
        private final Queue<byte[]> audioQueue = new ConcurrentLinkedQueue<>();
        private final Thread playerThread;
        private final AtomicBoolean shouldStop = new AtomicBoolean(false);

        public AudioPlayer() throws LineUnavailableException {
            AudioFormat format = new AudioFormat(24000, 16, 1, true, false);
            line = AudioSystem.getSourceDataLine(format);
            line.open(format);
            line.start();

            playerThread = new Thread(this::playLoop, "PemutarAudio");
            playerThread.start();
        }

        private void playLoop() {
            while (!shouldStop.get()) {
                byte[] audio = audioQueue.poll();
                if (audio != null) {
                    line.write(audio, 0, audio.length);
                } else {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException ignored) {}
                }
            }
        }

        public void play(String base64Audio) {
            audioQueue.add(Base64.getDecoder().decode(base64Audio));
        }

        public void close() {
            shouldStop.set(true);
            try {
                playerThread.join(1000);
            } catch (InterruptedException ignored) {}
            line.drain();
            line.close();
        }
    }

    /**
     * Registry Alat - Mengelola alat yang tersedia dan implementasinya
     */
    static class ToolRegistry {
        private final Map<String, Function<JsonObject, String>> tools = new ConcurrentHashMap<>();
        private final Map<String, JsonObject> pendingToolCalls = new ConcurrentHashMap<>();

        public ToolRegistry() {
            registerDefaultTools();
        }

        private void registerDefaultTools() {
            registerTool("get_current_weather", this::getCurrentWeather);
            registerTool("get_flight_price", this::getFlightPrice);
            registerTool("get_train_price", this::getTrainPrice);
        }

        public void registerTool(String name, Function<JsonObject, String> handler) {
            tools.put(name, handler);
        }

        /**
         * Bangun definisi alat (format OpenAI)
         */
        public List<Map<String, Object>> buildToolsDefinition() {
            List<Map<String, Object>> definitions = new ArrayList<>();

            definitions.add(createFunctionDefinition(
                    "get_current_weather",
                    "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
                    createParamsSchema(
                            Collections.singletonMap("location",
                                    createProperty("string", "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.")),
                            Collections.singletonList("location")
                    )
            ));

            Map<String, Object> flightProps = new HashMap<>();
            flightProps.put("src", createProperty("string", "Kota keberangkatan penerbangan, seperti Beijing atau Hangzhou."));
            flightProps.put("dst", createProperty("string", "Kota kedatangan penerbangan, seperti Beijing atau Hangzhou."));
            definitions.add(createFunctionDefinition(
                    "get_flight_price",
                    "Berguna saat Anda ingin menanyakan harga tiket penerbangan.",
                    createParamsSchema(flightProps, Arrays.asList("src", "dst"))
            ));

            Map<String, Object> trainProps = new HashMap<>();
            trainProps.put("src", createProperty("string", "Kota keberangkatan kereta, seperti Beijing atau Hangzhou."));
            trainProps.put("dst", createProperty("string", "Kota kedatangan kereta, seperti Beijing atau Hangzhou."));
            definitions.add(createFunctionDefinition(
                    "get_train_price",
                    "Berguna saat Anda ingin menanyakan harga tiket kereta.",
                    createParamsSchema(trainProps, Arrays.asList("src", "dst"))
            ));

            return definitions;
        }

        private Map<String, Object> createFunctionDefinition(String name, String description, Map<String, Object> parameters) {
            Map<String, Object> function = new HashMap<>();
            function.put("name", name);
            function.put("description", description);
            function.put("parameters", parameters);

            Map<String, Object> tool = new HashMap<>();
            tool.put("type", "function");
            tool.put("function", function);
            return tool;
        }

        private Map<String, Object> createParamsSchema(Map<String, Object> properties, List<String> required) {
            Map<String, Object> schema = new HashMap<>();
            schema.put("type", "object");
            schema.put("properties", properties);
            schema.put("required", required);
            return schema;
        }

        private Map<String, Object> createProperty(String type, String description) {
            Map<String, Object> prop = new HashMap<>();
            prop.put("type", type);
            prop.put("description", description);
            return prop;
        }

        /**
         * Tambahkan pemanggilan alat ke antrian tertunda
         */
        public void addPendingToolCall(String callId, JsonObject toolCall) {
            pendingToolCalls.put(callId, toolCall);
        }

        /**
         * Periksa apakah ada pemanggilan alat yang tertunda
         */
        public boolean hasPendingToolCalls() {
            return !pendingToolCalls.isEmpty();
        }

        /**
         * Proses semua pemanggilan alat yang tertunda
         */
        public void processPendingToolCalls(OmniRealtimeConversation conversation) {
            if (pendingToolCalls.isEmpty()) {
                return;
            }

            for (Map.Entry<String, JsonObject> entry : pendingToolCalls.entrySet()) {
                String callId = entry.getKey();
                JsonObject toolCall = entry.getValue();

                String result = executeTool(toolCall);
                sendToolResult(conversation, callId, result);
            }

            pendingToolCalls.clear();
        }

        private String executeTool(JsonObject toolCall) {
            String functionName = toolCall.get("name").getAsString();
            JsonObject arguments = new Gson().fromJson(
                    toolCall.get("arguments").getAsString(),
                    JsonObject.class
            );

            System.out.println("[Pemanggilan Alat] mulai menangani: " + functionName + ", args: " + arguments);

            Function<JsonObject, String> handler = tools.get(functionName);
            if (handler == null) {
                return "Klien tidak menemukan alat ini. Pemanggilan gagal.";
            }

            String result = handler.apply(arguments);
            System.out.println("[Pemanggilan Alat] respons: " + result);
            return result;
        }

        private void sendToolResult(OmniRealtimeConversation conversation, String callId, String output) {
            JsonObject item = new JsonObject();
            item.addProperty("id", "item_" + UUID.randomUUID().toString().replace("-", ""));
            item.addProperty("type", "function_call_output");
            item.addProperty("call_id", callId);
            item.addProperty("output", output);

            conversation.createItem(item);
        }

        // ===== Implementasi Alat =====

        private String getCurrentWeather(JsonObject args) {
            String location = args.get("location").getAsString();
            return "Cuaca di " + location + " hari ini berubah dari berkabut menjadi cerah, dengan suhu 4/-4°C dan angin sepoi-sepoi.";
        }

        private String getFlightPrice(JsonObject args) {
            String src = args.get("src").getAsString();
            String dst = args.get("dst").getAsString();
            return "Harga tiket penerbangan dari " + src + " ke " + dst + " adalah 200-300 USD.";
        }

        private String getTrainPrice(JsonObject args) {
            String src = args.get("src").getAsString();
            String dst = args.get("dst").getAsString();
            return "kesalahan kunci api tidak valid";
        }
    }

    /**
     * Handler Percakapan - Menangani event WebSocket
     */
    static class ConversationHandler extends OmniRealtimeCallback {
        private final AudioPlayer audioPlayer;
        private final ToolRegistry toolRegistry;
        private final AtomicBoolean shouldStop = new AtomicBoolean(false);
        private final AtomicReference<StringBuilder> responseTextRef = new AtomicReference<>(new StringBuilder());

        private long lastPackageTime = 0;
        private boolean isFirstText = true;
        private boolean isFirstAudio = true;

        public ConversationHandler(AudioPlayer audioPlayer, ToolRegistry toolRegistry) {
            this.audioPlayer = audioPlayer;
            this.toolRegistry = toolRegistry;
        }

        public AtomicBoolean getShouldStop() {
            return shouldStop;
        }

        @Override
        public void onOpen() {
            System.out.println("Koneksi terbentuk");
        }

        @Override
        public void onClose(int code, String reason) {
            System.out.println("Koneksi ditutup");
            shouldStop.set(true);
        }

        @Override
        public void onEvent(JsonObject message) {
            String type = message.get("type").getAsString();

            switch (type) {
                case "session.created":
                    handleSessionCreated(message);
                    break;
                case "conversation.item.input_audio_transcription.completed":
                    handleTranscriptionCompleted(message);
                    break;
                case "response.audio_transcript.delta":
                case "response.text.delta":
                    handleTextDelta(message);
                    break;
                case "response.audio.delta":
                    handleAudioDelta(message);
                    break;
                case "input_audio_buffer.speech_started":
                    handleSpeechStarted();
                    break;
                case "input_audio_buffer.speech_stopped":
                    handleSpeechStopped();
                    break;
                case "response.function_call_arguments.done":
                    handleFunctionCall(message);
                    break;
                case "response.done":
                    handleResponseDone();
                    break;
                default:
                    break;
            }
        }

        private void handleSessionCreated(JsonObject message) {
            String sessionId = message.get("session").getAsJsonObject().get("id").getAsString();
            System.out.println("mulai sesi: " + sessionId);
        }

        private void handleTranscriptionCompleted(JsonObject message) {
            System.out.println("pertanyaan: " + message.get("transcript").getAsString());
        }

        private void handleTextDelta(JsonObject message) {
            if (isFirstText) {
                isFirstText = false;
                System.out.println("latensi teks pertama dari akhir vad: " +
                        (System.currentTimeMillis() - lastPackageTime) + " ms");
            }
            String text = message.get("delta").getAsString();
            responseTextRef.get().append(text);
        }

        private void handleAudioDelta(JsonObject message) {
            if (isFirstAudio) {
                isFirstAudio = false;
                System.out.println("latensi audio pertama dari akhir vad: " +
                        (System.currentTimeMillis() - lastPackageTime) + " ms");
            }
            System.out.println("interval audio: " + (System.currentTimeMillis() - lastPackageTime) + " ms");
            lastPackageTime = System.currentTimeMillis();
            audioPlayer.play(message.get("delta").getAsString());
        }

        private void handleSpeechStarted() {
            System.out.println("======VAD Awal Ucapan======");
        }

        private void handleSpeechStopped() {
            System.out.println("======VAD Akhir Ucapan======");
            lastPackageTime = System.currentTimeMillis();
            isFirstText = true;
            isFirstAudio = true;
        }

        private void handleFunctionCall(JsonObject message) {
            System.out.println("======PEMANGGILAN ALAT======");
            String callId = message.get("call_id").getAsString();
            toolRegistry.addPendingToolCall(callId, message);
        }

        private void handleResponseDone() {
            System.out.println("======RESPONS SELESAI======");
            System.out.println("semua teks respons: " + responseTextRef.get());
            responseTextRef.set(new StringBuilder());
        }

        /**
         * Periksa apakah ada pemanggilan alat yang tertunda
         */
        public boolean hasPendingToolCalls() {
            return toolRegistry.hasPendingToolCalls();
        }

        /**
         * Proses semua pemanggilan alat yang tertunda
         */
        public void processPendingToolCalls(OmniRealtimeConversation conversation) {
            toolRegistry.processPendingToolCalls(conversation);
        }
    }
}

import asyncio
import json
import base64
import os
import pyaudio
import websockets

// ==================== Definisi Konstanta ====================
API_KEY = os.getenv("DASHSCOPE_API_KEY")
// Untuk mengakses wilayah Beijing, ganti dengan:
// wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/realtime
URL = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime"
MODEL = "qwen3.5-omni-plus-realtime"
VOICE = "Ethan"

// ==================== Definisi Alat ====================
def get_current_weather(location):
    """Tanyakan cuaca di kota tertentu"""
    return f"Cuaca di {location} hari ini berubah dari berkabut menjadi cerah, dengan suhu 4/-4°C dan angin sepoi-sepoi."

def get_flight_price(src, dst):
    """Tanyakan harga tiket penerbangan"""
    return f"Harga tiket penerbangan dari {src} ke {dst} adalah 200-300 USD."

def get_train_price(src, dst):
    """Tanyakan harga tiket kereta"""
    return f"Harga tiket kereta dari {src} ke {dst} adalah 100-200 CNY."

// Pemetaan nama alat ke fungsi
TOOL_FUNCTIONS = {
    "get_current_weather": get_current_weather,
    "get_flight_price": get_flight_price,
    "get_train_price": get_train_price,
}

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Berguna saat Anda ingin menanyakan cuaca di kota tertentu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Kota atau distrik, seperti Beijing, Hangzhou, atau Yuhang.",
                    }
                },
                "required": ["location"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_flight_price",
            "description": "Berguna saat Anda ingin menanyakan harga tiket penerbangan.",
            "parameters": {
                "type": "object",
                "properties": {
                    "src": {
                        "type": "string",
                        "description": "Kota keberangkatan penerbangan, seperti Beijing atau Hangzhou.",
                    },
                    "dst": {
                        "type": "string",
                        "description": "Kota kedatangan penerbangan, seperti Beijing atau Hangzhou.",
                    },
                },
                "required": ["src", "dst"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_train_price",
            "description": "Berguna saat Anda ingin menanyakan harga tiket kereta.",
            "parameters": {
                "type": "object",
                "properties": {
                    "src": {
                        "type": "string",
                        "description": "Kota keberangkatan kereta, seperti Beijing atau Hangzhou.",
                    },
                    "dst": {
                        "type": "string",
                        "description": "Kota kedatangan kereta, seperti Beijing atau Hangzhou.",
                    },
                },
                "required": ["src", "dst"],
            },
        },
    },
]

// ==================== Penanganan Pemanggilan Alat ====================
def handle_tool_call(name, arguments_str):
    """
    Menangani permintaan pemanggilan alat

    Args:
        name: Nama fungsi alat
        arguments_str: String parameter input dalam format JSON

    Returns:
        String hasil eksekusi alat
    """
    try:
        arguments = json.loads(arguments_str)
        print(f'[Pemanggilan Alat] Mulai memproses: name={name}, args={arguments}')

        func = TOOL_FUNCTIONS.get(name)
        if func is None:
            result = f"Klien tidak menemukan alat: {name}"
            print(f'[Pemanggilan Alat] Error: {result}')
            return result

        result = func(**arguments)
        print(f'[Pemanggilan Alat] Selesai: {result}')
        return result

    except Exception as e:
        error_msg = f"Pemanggilan alat gagal: {str(e)}"
        print(f'[Pemanggilan Alat] Pengecualian: {error_msg}')
        return error_msg

// ==================== Program Utama ====================
async def main():
    """Fungsi utama: Membentuk koneksi WebSocket dan melakukan percakapan suara"""
    pya = pyaudio.PyAudio()
    speaker = pya.open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)

    // Bentuk koneksi WebSocket
    headers = {
        "Authorization": f"bearer {API_KEY}",
        "X-DashScope-OmniRealtime": "true",
    }
    async with websockets.connect(
        f"{URL}?model={MODEL}", additional_headers=headers,
    ) as ws:
        await ws.recv()

        // Konfigurasi parameter sesi
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "modalities": ["text", "audio"],
                "voice": VOICE,
                "input_audio_format": "pcm16",
                "output_audio_format": "pcm16",
                "instructions": "Anda adalah asisten pribadi bernama Xiaoyun",
                "turn_detection": {"type": "server_vad"},
                "input_audio_transcription": {"model": "qwen3-asr-flash-realtime"},
                "tools": TOOLS,
            },
        }))
        await ws.recv()

        // Korutin pengambilan audio
        async def send_audio():
            mic = pya.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True)
            try:
                while True:
                    data = mic.read(3200, exception_on_overflow=False)
                    await ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": base64.b64encode(data).decode(),
                    }))
                    await asyncio.sleep(0.01)
            except asyncio.CancelledError:
                mic.close()

        pending = {}
        all_response_text = ""
        send_task = asyncio.create_task(send_audio())
        print("Pemanggilan alat diaktifkan. Berbicaralah ke mikrofon (Ctrl+C untuk keluar)...")

        // Loop penanganan event
        async for raw in ws:
            msg = json.loads(raw)
            t = msg["type"]

            // Sesi dibuat
            if t == "session.created":
                print(f"Sesi dimulai: {msg['session']['id']}")

            // Putar audio
            elif t == "response.audio.delta":
                speaker.write(base64.b64decode(msg["delta"]))

            // Respons teks inkremental
            elif t in ("response.audio_transcript.delta", "response.text.delta"):
                all_response_text += msg.get("delta", "")

            // Transkripsi ucapan pengguna
            elif t == "conversation.item.input_audio_transcription.completed":
                print(f"[Pengguna] {msg['transcript']}")

            // VAD mendeteksi awal ucapan
            elif t == "input_audio_buffer.speech_started":
                print("====== VAD mendeteksi awal ucapan ======")

            // VAD mendeteksi akhir ucapan
            elif t == "input_audio_buffer.speech_stopped":
                print("====== VAD mendeteksi akhir ucapan ======")

            // Menerima permintaan pemanggilan alat
            elif t == "response.function_call_arguments.done":
                print("====== Menerima permintaan pemanggilan alat ======")
                pending[msg["call_id"]] = {
                    "name": msg["name"],
                    "arguments": msg["arguments"],
                }

            // Respons selesai
            elif t == "response.done":
                if pending:
                    // Jalankan pemanggilan alat yang tertunda
                    for cid, info in pending.items():
                        result = handle_tool_call(info["name"], info["arguments"])
                        // Kirim hasil eksekusi alat
                        await ws.send(json.dumps({
                            "type": "conversation.item.create",
                            "item": {
                                "type": "function_call_output",
                                "call_id": cid,
                                "output": result,
                            },
                        }))
                    pending.clear()
                    // Picu server untuk terus menghasilkan respons
                    await ws.send(json.dumps({
                        "type": "response.create",
                        "response": {"modalities": ["text", "audio"]},
                    }))
                    print("====== Pemrosesan pemanggilan alat selesai ======")
                else:
                    // Respons normal selesai, cetak respons lengkap
                    if all_response_text:
                        print(f"[Model] {all_response_text}")
                    all_response_text = ""

        send_task.cancel()
        speaker.close()
        pya.terminate()

asyncio.run(main())