Lua Requires Chilkat v11.4.0+

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. Lua

local chilkat = require("chilkat")

local success = false

-- 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"
--           }
--         }
--       }
--     }
--   ]
-- }

local jsonTools = chilkat.JsonObject.new()

local toolIdx = 0

jsonTools.i = toolIdx
jsonTools:update_string("tools[i].name", "get_horoscope")
jsonTools:update_string("tools[i].description", "Get today's horoscope for an astrological sign.")
jsonTools:update_string("tools[i].parameters.properties.sign.type", "string")
jsonTools:update_string("tools[i].parameters.properties.sign.description", "An astrological sign like Taurus or Aquarius")
-- More tools can be added as desired..

jsonTools.emit_compact = false
print(jsonTools:emit())

local ai = chilkat.Ai.new()

-- Register the tools that will be made available to the AI.
ai:register_manual_tools(jsonTools)

-- The provider can be "openai", "google", "claude", "grok", "mistral", "custom", etc.
ai.provider = "openai"
-- Use your provider's API key.
ai.api_key = "MY_API_KEY"
-- Choose a model.
ai.model = "gpt-5.6-luna"

-- Tool function calling must always occur within a conversation.
local conversation_name = "convo_astrology"
local sysMessage = "You are a helpful astrologer"
local devMessage = "Respond only with markdown."
ai:new_convo(conversation_name, sysMessage, devMessage)

-- Provide inputs
ai:input_add_text("What is my horoscope? I am an Aquarius.")

-- Get the response in streaming mode.
ai.streaming = 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.

local sbEventName = chilkat.StringBuilder.new()
local sbDelta = chilkat.StringBuilder.new()
local sbFullResponse = chilkat.StringBuilder.new()

-- 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..
local maxWaitMs = 5000

local jsonFn = chilkat.JsonObject.new()

local finished = false
local numAsks = 0
-- Set a max # of followup Asks to prevent any unexpected infinite looping.
while not finished and (numAsks < 10) do
    -- Send the request to the AI model.
    success = ai:ask("text")
    if not success then
        print(ai.last_error_text)
        return
    end

    local madeFunctionCalls = false
    local streamingDone = false

    while not streamingDone do
        local result = ai:poll_ai(false)
        if result < 0 then
            print(ai.last_error_text)
            print("Failed.")
            return
        end

        if result > 0 then
            -- We have an event..
            success = ai:next_ai_event(maxWaitMs, sbEventName, sbDelta)
            if not success then
                print(ai.last_error_text)
                return
            end

            -- Is this an event where the AI is requesting a function call?
            if sbEventName:contents_equal("function_call", true) then
                jsonFn:load_sb(sbDelta)

                -- 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"
                --       }
                --     }
                --   ]
                -- }

                local numFnCalls = jsonFn:size_of_array("function_call")
                local fn_idx = 0
                while fn_idx < numFnCalls do
                    jsonFn.i = fn_idx

                    local sbFnName = chilkat.StringBuilder.new()
                    jsonFn:string_of_sb("function_call[i].name", sbFnName)
                    local callId = jsonFn:string_of("function_call[i].call_id")

                    if sbFnName:contents_equal("get_horoscope", true) then
                        -- The get_horoscope function (as defined above) has one argument named "sign".
                        local zodiac_sign = jsonFn:string_of("function_call[i].args.sign")
                        print("zodiac_sign = " .. 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:
                        local applicationFnCallResult = "Aquarius: Next Tuesday you will befriend a baby otter."

                        -- Provide the tool call result as an input for the followup Ask.
                        ai:input_add_fn_result(callId, applicationFnCallResult)

                        madeFunctionCalls = true
                    end

                    -- Your application would add code to check for and handle each possible function call.

                    fn_idx = fn_idx + 1
                end
            elseif not sbEventName:contents_equal("empty", true) then
                sbFullResponse:append_sb(sbDelta)

                if sbEventName:contents_equal("null_terminator", true) then
                    streamingDone = true
                end
            end
        else
            -- No event arrived, so wait a short time rather than spin in a loop..
            ai:sleep_ms(100)
        end
    end

    if not madeFunctionCalls then
        finished = true
    end

    numAsks = numAsks + 1
end

print("Full Response:")
print(sbFullResponse:get_as_string())