nsmcp::CodexQuestionRun method receive (protected)

 <instance of nsmcp::CodexQuestionRun> receive

Defined in /usr/local/ns/tcl/nsmcp/question-backend.tcl

Testcases:

No testcase defined.

Source code:

while {1} {
    if {[clock milliseconds] >= ${:deadline}} {error "Question backend timed out"}
    if {![:emit {type check}] && !${:cancelled}} {
        set :cancelled true
        if {${:turn} eq ""} {error "Question cancelled"}
        :send turn/interrupt [list threadId string ${:thread} turnId string ${:turn}]
        set :deadline [expr {min(${:deadline},[clock milliseconds]+10000)}]
    }
    set n [gets ${:channel} line]
    if {$n >= 0} {break}
    if {[eof ${:channel}]} {error "Codex App Server closed its connection"}
    if {[string bytelength $line] > 8388608} {error "Question backend event is too large"}
    ns_sleep 0.05
}
if {[string bytelength $line] > 8388608} {error "Question backend event is too large"}
set message [ns_json parse -maxdepth 64 -maxstring 8388608 -maxcontainer 100000 -- $line]
if {![dict exists $message method]} {
    if {[dict exists $message id]} {dict set :replies [dict get $message id] $message}
    return
}
set method [dict get $message method]
if {[dict exists $message id]} {
    set raw [ns_json parse -output triples -- $line]
    set idType [ns_json triples gettype -path id -- $raw]
    puts ${:channel} [ns_json value -- [list {} object [list id $idType [dict get $message id]  error object {code number -32601 message string {Interactive requests are unavailable in this diagnostics interface}}]]]
    flush ${:channel}
    return
}
set params [dict get $message params]
switch -- $method {
    item/agentMessage/delta {
        :emit [dict create type text text [dict get $params delta]]
    }
    item/completed {
        set item [dict get $params item]
        if {[dict get $item type] eq "agentMessage"} {
            :emit [dict create type text text "\n\n"]
        }
        if {[dict get $item type] eq "mcpToolCall"} {
            incr :tools
            if {${:tools} > 32} {error "Question tool-call limit reached"}
            set arguments {}
            # Keep the complete JSON type information in the result.
            set triple [ns_json parse -maxdepth 64 -maxstring 8388608 -maxcontainer 100000 -output triples -- $line]
            set arguments [ns_json value -- [list {} [ns_json triples gettype -path {params item arguments} -- $triple] [ns_json triples getvalue -output triples -path {params item arguments} -- $triple]]]
            set itemTriple [list {} object [ns_json triples getvalue -output triples -path {params item} -- $triple]]
            set result [${:backend} toolCallResult $itemTriple]
            set truncated false
            if {[string bytelength $result] > [${:backend} cget -maxResultBytes]} {
                set result {Result omitted from this page because it exceeds the configured display limit.}
                set truncated true
            }
            :emit [dict create type tool name [dict get $item tool] status [dict get $item status]  arguments $arguments result $result truncated $truncated]
        }
    }
    thread/tokenUsage/updated {
        # App Server totals are conversation-cumulative, not a new
        # charge for each notification or follow-up. Preserve that scope.
        if {[dict exists $params tokenUsage total]} {
            set counters [::nsmcp::questionUsageCounters [dict get $params tokenUsage total] {
                inputTokens inputTokens cachedInputTokens cachedInputTokens
                cacheWriteInputTokens cacheWriteInputTokens outputTokens outputTokens
                reasoningOutputTokens reasoningOutputTokens totalTokens totalTokens
            }]
            if {$counters ne ""} {
                :emit [dict create type usage usage [dict merge $counters {scope conversation-cumulative source codex}]]
            }
        }
    }
    turn/completed {set :finished [dict get $params turn]}
}

XQL Not present:

Generic, PostgreSQL, Oracle