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 ${:writeChannel} [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 ${:writeChannel}
    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 {
        if {[dict exists $params tokenUsage total]
            && [dict exists $params threadId]
            && (${:thread} eq "" || [dict get $params threadId] eq ${:thread})} {
            # Ignore late notifications from another turn on this thread.
            if {${:usageActive} && ${:turn} ne "" && [dict exists $params turnId]
                && [dict get $params turnId] ne ${:turn}} {return}
            set counters [::nsmcp::questionUsageCounters [dict get $params tokenUsage total] {
                inputTokens inputTokens cachedInputTokens cachedInputTokens
                cacheWriteInputTokens cacheWriteInputTokens outputTokens outputTokens
                reasoningOutputTokens reasoningOutputTokens totalTokens totalTokens
            }]
            if {$counters ne ""} {
                if {${:usageActive} && ${:turn} eq ""} {
                    # turn/start can emit usage before its RPC reply.
                    set :usagePending [dict create thread [dict get $params threadId] counters $counters]
                    if {[dict exists $params turnId]} {dict set :usagePending turn [dict get $params turnId]}
                } else {
                    :recordUsage [dict get $params threadId] $counters
                }
            }
        }
    }
    turn/completed {set :finished [dict get $params turn]}
}

XQL Not present:

Generic, PostgreSQL, Oracle