nsmcp::ChatCompletionsRun method event (protected)

 <instance of nsmcp::ChatCompletionsRun> event data

Defined in /usr/local/ns/tcl/nsmcp/question-chat-completions.tcl

Parameters:

data (required)

Testcases:

No testcase defined.

Source code:

if {${:done}} {return}
if {$data eq "\[DONE\]"} {set :done true; return}
if {[catch {ns_json parse -maxdepth 64 -maxstring 1048576 -maxcontainer 100000 -- $data} event]} {
    error "Malformed JSON in API event stream"
}
if {[dict exists $event model] && ![ns_json isnull [dict get $event model]]} {
    :emit [dict create type model model [string range [dict get $event model] 0 255]]
}
if {[dict exists $event error]} {error "Provider reported an error in its API stream"}
if {[dict exists $event usage] && ![ns_json isnull [dict get $event usage]]} {
    set counters [::nsmcp::questionUsageCounters [dict get $event usage] {
        prompt_tokens inputTokens completion_tokens outputTokens total_tokens totalTokens
        prompt_cache_hit_tokens cachedInputTokens prompt_cache_miss_tokens uncachedInputTokens
    }]
    if {[dict exists $event usage completion_tokens_details reasoning_tokens]} {
        set counters [dict merge $counters [::nsmcp::questionUsageCounters  [dict get $event usage completion_tokens_details] {reasoning_tokens reasoningOutputTokens}]]
    }
    if {[dict exists $event usage prompt_tokens_details cached_tokens]} {
        set counters [dict merge $counters [::nsmcp::questionUsageCounters  [dict get $event usage prompt_tokens_details] {cached_tokens cachedInputTokens}]]
    }
    if {$counters ne ""} {
        if {${:requestUsage} eq ""} {incr :requestsWithUsage}
        dict for {key n} ${:requestUsage} {dict incr :usageTotals $key [expr {-$n}]}
        dict for {key n} $counters {dict incr :usageTotals $key $n}
        set :requestUsage $counters
        :emit [dict create type usage usage [dict merge ${:usageTotals}  [dict create scope turn source chat-completions apiRequests ${:requestsStarted}  requestsWithUsage ${:requestsWithUsage} complete [expr {${:requestsStarted} == ${:requestsWithUsage}}]]]]
    }
}
if {![dict exists $event choices]} {error "API stream event has no choices"}
foreach choice [dict get $event choices] {
    if {[dict get $choice index] != 0} {error "Expected one API completion choice"}
    set reason [:text $choice finish_reason]
    if {$reason ne ""} {set :finish $reason}
    if {![dict exists $choice delta]} {continue}
    set delta [dict get $choice delta]
    set text [:text $delta content]
    if {$text ne ""} {
        append :content $text
        :emit [dict create type text text $text]
    }
    # Preserve provider reasoning for subsequent tool rounds/history,
    # but do not publish it as an answer or tool result.
    if {[dict exists $delta reasoning_content] && ![ns_json isnull [dict get $delta reasoning_content]]} {
        set :hasReasoning true
        append :reasoning [dict get $delta reasoning_content]
    }
    if {![dict exists $delta tool_calls] || [ns_json isnull [dict get $delta tool_calls]]} {continue}
    foreach fragment [dict get $delta tool_calls] {
        set index [dict get $fragment index]
        if {![string is integer -strict $index] || $index < 0 || $index >= [${:backend} cget -maxToolCalls]} {
            error "Invalid API tool-call index"
        }
        if {![dict exists ${:calls} $index]} {dict set :calls $index {id {} name {} arguments {} type function}}
        set call [dict get ${:calls} $index]
        if {[dict exists $fragment type] && [:text $fragment type] ne ""} {dict set call type [dict get $fragment type]}
        dict append call id [:text $fragment id]
        if {[dict exists $fragment function]} {
            dict append call name [:text [dict get $fragment function] name]
            dict append call arguments [:text [dict get $fragment function] arguments]
        }
        dict set :calls $index $call
    }
}

XQL Not present:

Generic, PostgreSQL, Oracle