Zig Requires Chilkat v11.4.0+
Zig
Streaming AI with Manual AI Tool Function Calling
See more AI Examples
Demonstrates how to get AI responses in streaming mode, including manual tool function calls.Chilkat Zig Downloads
const std = @import("std");
const chilkat = @import("chilkat");
pub fn main(init: std.process.Init) !void {
const alloc = init.arena.allocator();
// Create the following JSON to define tool functions available for the AI to use.
// Note: You'll use the following JSON format regardless of the AI provider, whether
// it be ChatGPT, Gemini, Claude, Grok, etc. Chilkat automatically converts to the required
// format needed for a given AI provider.
// In this example, the application is providing a single function the AI may choose to call.
// {
// "tools": [
// {
// "name": "get_horoscope",
// "description": "Get today's horoscope for an astrological sign.",
// "parameters": {
// "properties": {
// "sign": {
// "type": "string",
// "description": "An astrological sign like Taurus or Aquarius"
// }
// }
// }
// }
// ]
// }
const json_tools = try chilkat.JsonObject.init();
defer json_tools.deinit();
const tool_idx = 0;
json_tools.setI(tool_idx);
json_tools.updateString("tools[i].name", "get_horoscope") catch {};
json_tools.updateString("tools[i].description", "Get today's horoscope for an astrological sign.") catch {};
json_tools.updateString("tools[i].parameters.properties.sign.type", "string") catch {};
json_tools.updateString("tools[i].parameters.properties.sign.description", "An astrological sign like Taurus or Aquarius") catch {};
// More tools can be added as desired..
json_tools.setEmitCompact(false);
std.debug.print("{s}\n", .{try json_tools.emit(alloc)});
const ai = try chilkat.Ai.init();
defer ai.deinit();
// Register the tools that will be made available to the AI.
ai.registerManualTools(json_tools) catch {};
// The provider can be "openai", "google", "claude", "grok", "mistral", "custom", etc.
ai.setProvider("openai");
// Use your provider's API key.
ai.setApiKey("MY_API_KEY");
// Choose a model.
ai.setModel("gpt-5.6-luna");
// Tool function calling must always occur within a conversation.
const conversation_name = "convo_astrology";
const sys_message = "You are a helpful astrologer";
const dev_message = "Respond only with markdown.";
ai.newConvo(conversation_name, sys_message, dev_message) catch {};
// Provide inputs
ai.inputAddText("What is my horoscope? I am an Aquarius.") catch {};
// Get the response in streaming mode.
ai.setStreaming(true);
// In streaming mode, if we receive an AI event that is a request for tool use,
// we'll need to make the call to the JavaScript and then continue with a followup Ask,
// until the final response is received.
const sb_event_name = try chilkat.StringBuilder.init();
defer sb_event_name.deinit();
const sb_delta = try chilkat.StringBuilder.init();
defer sb_delta.deinit();
const sb_full_response = try chilkat.StringBuilder.init();
defer sb_full_response.deinit();
// When PollAi returns with an event, it's highly unlikely the
// call to NextAiEvent does not immediately return. Setting a max
// timeout is just a precaution..
const max_wait_ms = 5000;
const json_fn = try chilkat.JsonObject.init();
defer json_fn.deinit();
var finished: bool = false;
var num_asks: i32 = 0;
// Set a max # of followup Asks to prevent any unexpected infinite looping.
while (!finished and (num_asks < 10)) {
// Send the request to the AI model.
ai.ask("text") catch {
std.debug.print("{s}\n", .{try ai.getLastErrorText(alloc)});
return;
};
var made_function_calls: bool = false;
var streaming_done: bool = false;
while (!streaming_done) {
const result = ai.pollAi(false);
if (result < 0) {
std.debug.print("{s}\n", .{try ai.getLastErrorText(alloc)});
std.debug.print("Failed.\n", .{});
return;
}
if (result > 0) {
// We have an event..
ai.nextAiEvent(max_wait_ms, sb_event_name, sb_delta) catch {
std.debug.print("{s}\n", .{try ai.getLastErrorText(alloc)});
return;
};
// Is this an event where the AI is requesting a function call?
if (sb_event_name.contentsEqual("function_call", true)) {
json_fn.loadSb(sb_delta) catch {};
// Note: Chilkat will convert responses from all AI providers to this format:
// {
// "function_call": [
// {
// "name": "get_horoscope",
// "call_id": "call_RYmeysYQFocFc7Z2ofkv61dW",
// "arguments": "{\"sign\":\"Aquarius\"}",
// "args": {
// "sign": "Aquarius"
// }
// }
// ]
// }
const num_fn_calls = json_fn.sizeOfArray("function_call");
var fn_idx: i32 = 0;
while (fn_idx < num_fn_calls) {
json_fn.setI(fn_idx);
const sb_fn_name = try chilkat.StringBuilder.init();
defer sb_fn_name.deinit();
json_fn.stringOfSb("function_call[i].name", sb_fn_name) catch {};
const call_id = try json_fn.stringOf(alloc, "function_call[i].call_id");
if (sb_fn_name.contentsEqual("get_horoscope", true)) {
// The get_horoscope function (as defined above) has one argument named "sign".
const zodiac_sign = try json_fn.stringOf(alloc, "function_call[i].args.sign");
std.debug.print("zodiac_sign = {s}\n", .{zodiac_sign});
// Insert application code here to call your app's get_horoscope function, passing the zodiac_sign to it..
// For this example, we'll pretend the app's get_horoscope function returned the following:
const application_fn_call_result = "Aquarius: Next Tuesday you will befriend a baby otter.";
// Provide the tool call result as an input for the followup Ask.
ai.inputAddFnResult(call_id, application_fn_call_result) catch {};
made_function_calls = true;
}
// Your application would add code to check for and handle each possible function call.
fn_idx = fn_idx + 1;
}
} else {
if (!sb_event_name.contentsEqual("empty", true)) {
sb_full_response.appendSb(sb_delta) catch {};
if (sb_event_name.contentsEqual("null_terminator", true)) {
streaming_done = true;
}
}
}
} else {
// No event arrived, so wait a short time rather than spin in a loop..
ai.sleepMs(100);
}
}
if (!made_function_calls) {
finished = true;
}
num_asks = num_asks + 1;
}
std.debug.print("Full Response:\n", .{});
std.debug.print("{s}\n", .{try sb_full_response.getAsString(alloc)});
}