diff options
| author | t <t@tjp.lol> | 2026-11-17 00:53:11 -0700 |
|---|---|---|
| committer | t <t@tjp.lol> | 2026-11-17 15:42:02 -0700 |
| commit | 413d9a4b241a0f4111e39fdc0059ac15069d034f (patch) | |
| tree | 55f416467d7d1f1c6a36e875c3dd60e14874a1b0 /panto_mcp/http.lua | |
Diffstat (limited to 'panto_mcp/http.lua')
| -rw-r--r-- | panto_mcp/http.lua | 680 |
1 files changed, 680 insertions, 0 deletions
diff --git a/panto_mcp/http.lua b/panto_mcp/http.lua new file mode 100644 index 0000000..206e2d5 --- /dev/null +++ b/panto_mcp/http.lua @@ -0,0 +1,680 @@ +local json = require('panto').ext.json +local async = require('panto_mcp.async') +local M = {} +local Transport = {}; Transport.__index = Transport +local MAX_BODY,MAX_ERROR_BODY,FIRE_TIMEOUT_MS=16*1024*1024,1024,10000 +local method_support=setmetatable({}, {__mode='k'}) + +local function cancel_handle(handle) + if handle and type(handle.cancel)=='function' then pcall(handle.cancel,handle) end +end +local function newer_error() + return 'URL MCP servers require a newer panto with HTTP POST and streaming support' +end +M.newer_error=newer_error +function M.methods_supported(request_fn) + if type(request_fn)~='function' then return false end + local cached=method_support[request_fn] + if cached~=nil then return cached end + -- A supported API rejects OPTIONS during parsing, before opening a socket. + local ok,handle,err=pcall(request_fn,{url='http://127.0.0.1:1/',method='OPTIONS',timeout_ms=1},function() end) + local supported=ok and not handle and type(err)=='string' and err:find('invalid HTTP request options',1,true)~=nil + if handle then cancel_handle(handle) end + method_support[request_fn]=not not supported + return not not supported +end + +local function header_value(headers,name) + local value=headers and headers[name:lower()] + if type(value)=='table' then return value[1] end + return value +end +local function set_header(out,lower,name,value) + local key=name:lower() + if lower[key] then out[lower[key]]=nil end + lower[key]=name; out[name]=value +end +local function remove_header(out,lower,name) + local key=name:lower() + if lower[key] then out[lower[key]]=nil; lower[key]=nil end +end +local function b64(value) + local alphabet='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' + local out={} + for i=1,#value,3 do + local a,b,c=value:byte(i,i+2); b=b or 0; c=c or 0 + local n=(a<<16)|(b<<8)|c + out[#out+1]=alphabet:sub(((n>>18)&63)+1,((n>>18)&63)+1) + out[#out+1]=alphabet:sub(((n>>12)&63)+1,((n>>12)&63)+1) + out[#out+1]=i+1<=#value and alphabet:sub(((n>>6)&63)+1,((n>>6)&63)+1) or '=' + out[#out+1]=i+2<=#value and alphabet:sub((n&63)+1,(n&63)+1) or '=' + end + return table.concat(out) +end +local function encode_value(value) + local safe=not (value:match('^[ \t]') or value:match('[ \t]$') or + (value:sub(1,9)=='=?base64?' and value:sub(-2)=='?=')) + if safe then + for i=1,#value do local b=value:byte(i); if not (b==9 or b==32 or (b>=33 and b<=126)) then safe=false; break end end + end + if safe then return value end + return '=?base64?'..b64(value)..'?=' +end +M.encode_header_value=encode_value + +local tchar={} +for c in ('!#$%&\'*+-.^_`|~'):gmatch('.') do tchar[c]=true end +local function valid_token(value) + if type(value)~='string' or value=='' then return false end + for i=1,#value do + local b=value:byte(i) + if not ((b>=48 and b<=57) or (b>=65 and b<=90) or (b>=97 and b<=122) or tchar[value:sub(i,i)]) then return false end + end + return true +end +function M.validate_param_headers(schema) + local found,seen,reason={}, {}, nil + local total,reachable=0,0 + local instance_data={enum=true,const=true,default=true,examples=true} + local function reject(text) reason=reason or text end + local function count(value) + if type(value)~='table' then return end + if value['x-mcp-header']~=nil then total=total+1 end + for key,child in pairs(value) do + if key=='properties' or key=='patternProperties' or key=='dependentSchemas' or key=='dependencies' or key=='$defs' or key=='definitions' then + if type(child)=='table' then for _,nested in pairs(child) do count(nested) end end + elseif not instance_data[key] then count(child) end + end + end + local function get_type(value) + local types={} + if type(value)=='string' then types[1]=value + elseif type(value)=='table' then + local n=0 + for k,t in pairs(value) do + if type(k)~='number' or k<1 or k%1~=0 or type(t)~='string' then return nil end + n=n+1; types[#types+1]=t + end + if n~=#value then return nil end + else return nil end + local base + for _,t in ipairs(types) do + if t~='null' then + if base then return nil end + base=t + end + end + if base=='string' or base=='integer' or base=='boolean' then return base end + return nil + end + local function walk(node,path,reachable_path) + if type(node)~='table' then return end + local name=node['x-mcp-header'] + if name~=nil and reachable_path then + reachable=reachable+1 + local primitive=get_type(node.type) + if #path==0 then reject('x-mcp-header must annotate a parameter property') + elseif not valid_token(name) then reject('x-mcp-header must be an HTTP token') + elseif not primitive then reject('x-mcp-header requires string, integer, or boolean') + else + local key=name:lower() + if seen[key] then reject('x-mcp-header names must be case-insensitively unique') + else seen[key]=true; found[#found+1]={name=name,path=path,type=primitive} end + end + end + local properties=node.properties + if type(properties)=='table' then + for property,child in pairs(properties) do + if type(property)=='string' and type(child)=='table' then + local nested={}; for i,v in ipairs(path) do nested[i]=v end; nested[#nested+1]=property + walk(child,nested,reachable_path) + elseif type(child)=='table' then walk(child,path,false) end + end + end + end + count(schema); walk(schema,{},true) + if total~=reachable then reject('x-mcp-header is not statically reachable through properties') end + if reason then return nil,reason end + return found +end +function M.filter_tools(tools,server,quiet) + local filtered,headers=json.array({}),{} + for _,tool in ipairs(tools or {}) do + local annotations,why=M.validate_param_headers(type(tool)=='table' and tool.inputSchema or nil) + if annotations then + filtered[#filtered+1]=tool + if #annotations>0 and type(tool)=='table' and type(tool.name)=='string' then headers[tool.name]=annotations end + else + local name=type(tool)=='table' and tostring(tool.name or '?') or '?' + name=name:gsub('[%z\1-\31\127]','?'):sub(1,100) + if not quiet then io.stderr:write('panto-mcp: ',tostring(server),': excluded tool ',name,': invalid x-mcp-header (',why,')\n') end + end + end + return filtered,headers +end +local function param_value(spec,arguments) + local value=arguments + for _,key in ipairs(spec.path) do if type(value)~='table' then return nil end; value=value[key] end + if value==nil or value==json.null then return nil end + if spec.type=='string' then + if type(value)~='string' then return nil,'must be a string' end + elseif spec.type=='boolean' then + if type(value)~='boolean' then return nil,'must be a boolean' end + value=value and 'true' or 'false' + elseif spec.type=='integer' then + if type(value)~='number' or value%1~=0 or math.abs(value)>9007199254740991 then return nil,'must be a safe integer' end + value=string.format('%.0f',value) + else return nil,'has an unsupported annotated type' end + return encode_value(value) +end +M.parameter_value=param_value +function M.headers(cfg,opts,session_id) + opts=opts or {} + local out,lower={},{} + for name,value in pairs(cfg.headers or {}) do set_header(out,lower,name,value) end + set_header(out,lower,'Accept','application/json, text/event-stream') + set_header(out,lower,'Content-Type','application/json') + if opts.era=='modern' then + remove_header(out,lower,'Mcp-Session-Id') + set_header(out,lower,'MCP-Protocol-Version',opts.protocol_version or '2026-07-28') + set_header(out,lower,'Mcp-Method',opts.method or '') + remove_header(out,lower,'Mcp-Name') + if opts.method=='tools/call' or opts.method=='resources/read' or opts.method=='prompts/get' then + if type(opts.name)~='string' then return nil,'Mcp-Name requires a string value' end + set_header(out,lower,'Mcp-Name',encode_value(opts.name)) + end + if opts.method=='tools/call' then + for _,spec in ipairs(opts.param_headers or {}) do + local value,err=param_value(spec,opts.arguments) + if err then return nil,'annotated parameter '..table.concat(spec.path,'.')..' '..err end + if value~=nil then set_header(out,lower,'Mcp-Param-'..spec.name,value) end + end + end + elseif opts.initial then + remove_header(out,lower,'MCP-Protocol-Version'); remove_header(out,lower,'Mcp-Session-Id') + remove_header(out,lower,'Mcp-Method'); remove_header(out,lower,'Mcp-Name') + else + remove_header(out,lower,'Mcp-Method'); remove_header(out,lower,'Mcp-Name') + set_header(out,lower,'MCP-Protocol-Version',opts.protocol_version or '2025-11-25') + if session_id then set_header(out,lower,'Mcp-Session-Id',session_id) end + end + return out +end + +-- Processes each input byte once; only the current line and event are retained. +function M.sse_parser(on_event,max_bytes) + local line_parts,data_lines,line_bytes,event_bytes= {},{},0,0 + local event_type,skip_lf,bom_started,bom_pending=nil,false,false,'' + max_bytes=max_bytes or MAX_BODY + local function append_line(part) + if part~='' then line_parts[#line_parts+1]=part; line_bytes=line_bytes+#part end + if line_bytes>max_bytes then error('SSE line exceeds size limit',0) end + end + local function dispatch_event() + if #data_lines>0 then + local data=table.concat(data_lines,'\n') + if data~='' and (event_type==nil or event_type=='' or event_type=='message') then on_event(data,event_type) end + end + data_lines={}; event_type=nil; event_bytes=0 + end + local function process_line() + local value=table.concat(line_parts); line_parts={}; line_bytes=0 + if value=='' then dispatch_event(); return end + if value:sub(1,1)==':' then return end + local colon=value:find(':',1,true); local field,content + if colon then field,content=value:sub(1,colon-1),value:sub(colon+1); if content:sub(1,1)==' ' then content=content:sub(2) end + else field,content=value,'' end + if field=='data' then + event_bytes=event_bytes+#content+1 + if event_bytes>max_bytes then error('SSE event exceeds size limit',0) end + data_lines[#data_lines+1]=content + elseif field=='event' then event_type=content end + end + local function process(chunk) + local i=1 + if skip_lf then + if chunk=='' then return end + if chunk:sub(1,1)=='\n' then i=2 end + skip_lf=false + end + while i<=#chunk do + local at=chunk:find('[\r\n]',i) + if not at then append_line(chunk:sub(i)); break end + append_line(chunk:sub(i,at-1)) + local is_cr=chunk:sub(at,at)=='\r' + if is_cr and chunk:sub(at+1,at+1)=='\n' then i=at+2 + else i=at+1; if is_cr and i>#chunk then skip_lf=true end end + process_line() + end + end + local parser={} + function parser:feed(chunk) + if type(chunk)~='string' then return nil,'invalid SSE chunk' end + if not bom_started then + bom_pending=bom_pending..chunk + if #bom_pending<3 then return true end + if bom_pending:sub(1,3)=='\239\187\191' then bom_pending=bom_pending:sub(4) end + chunk=bom_pending; bom_pending=''; bom_started=true + end + local ok,err=pcall(process,chunk); if not ok then return nil,err end + return true + end + function parser:finish() + if not bom_started then + local chunk=bom_pending; bom_pending=''; bom_started=true + if chunk:sub(1,3)=='\239\187\191' then chunk=chunk:sub(4) end + local ok,err=pcall(process,chunk); if not ok then return nil,err end + end + if #line_parts>0 then local ok,err=pcall(process_line); if not ok then return nil,err end end + local ok,err=pcall(dispatch_event); if not ok then return nil,err end + return true + end + return parser +end + +local function decode_message(body) + if not body or body=='' then return nil end + local ok,msg=pcall(json.decode,body) + if ok and type(msg)=='table' then return msg end + return nil +end +local function is_sse(headers) + local value=header_value(headers,'content-type') + return type(value)=='string' and value:lower():match('^%s*text/event%-stream')~=nil +end +local function escaped_pattern(value) return value:gsub('([^%w])','%%%1') end +local function redact(text,headers) + text=text or '' + for name,value in pairs(headers or {}) do + if type(value)=='string' and value~='' then + text=text:gsub(escaped_pattern(value),'[redacted]') + if name:lower()=='authorization' then + local token=value:match('^%s*%S+%s+(%S+)%s*$') + if token and token~='' then text=text:gsub(escaped_pattern(token),'[redacted]') end + end + end + end + return text:sub(1,MAX_ERROR_BODY) +end +local function prefix_error(server,method,text) + return tostring(server)..' '..tostring(method or 'HTTP')..': '..tostring(text) +end +local function failure_kind(err) + local text=tostring(err or '') + if text:match('^on_head callback failed:') or text:match('^on_data callback failed:') then return 'callback' end + if text=='timeout' then return 'timeout' end + if text=='idle timeout' then return 'idle_timeout' end + return 'transport' +end +M.failure_kind=failure_kind +function M.should_fallback(err) + if type(err)=='table' then + local data=type(err.data)=='table' and err.data or {} + if data.session_expired or data.auth_error or data.http_status==401 or data.http_status==403 then return false end + if err.code==-32020 or err.code==-32021 or err.code==-32022 or data.supported then return false end + if data.http_status then return data.transport_fallback==true end + if data.transport_error=='timeout' or data.transport_error=='idle_timeout' then return true end + return false + end + local kind=failure_kind(err) + return kind=='timeout' or kind=='idle_timeout' or (type(err)=='string' and + (err:match('^request timed out:')~=nil or err:match('^[^%s]+ [^:]+: request timed out:')~=nil)) +end +function M.new(cfg,settings,opts) + opts=opts or {}; settings=settings or {} + local request_fn=opts.request_fn + if not request_fn then + local ext=require('panto').ext + request_fn=ext and ext.http_request + if type(request_fn)~='function' or not M.methods_supported(request_fn) then return nil,newer_error() end + end + return setmetatable({cfg=cfg,settings=settings,request_fn=request_fn, + timer_factory=opts.timer_factory or async.timer,active={},sequence=0,closed=false, + session_id=nil,protocol_version=nil,era=nil,session_generation=0,initialize_params=nil, + on_message=nil,on_error=nil,oauth=opts.oauth, + on_notification_stream_end=opts.on_notification_stream_end},Transport) +end +function Transport:set_callbacks(message,err) self.on_message=message; self.on_error=err end +function Transport:auth_name() + if self.oauth then return self.oauth:request_auth() end + return self.cfg.auth +end + +function Transport:_clear_state(state) + if state.done then return end + state.done=true; self.active[state.key]=nil + local op=state.op + if op then async.close(op.idle_timer); async.close(op.fire_timer) end +end +function Transport:_log_failure(text) + self.stderr_tail=((self.stderr_tail or '')..text..'\n'):sub(-8192) + io.stderr:write('panto-mcp: ',text,'\n') +end +function Transport:_finish_handshake(state,ok,err) + if state.handshake_future and not state.handshake_future.done then state.handshake_future:resolve(ok,err) end +end +function Transport:_emit_error(state,message,text,data) + if state.done or state.cancelled then return end + local method=(message and message.method) or state.opts.method + text=redact(prefix_error(self.cfg.name,method,text),self.cfg.headers) + self:_clear_state(state) + if state.fire_and_forget then + if state.handshake_notification then self:_finish_handshake(state,nil,text) else self:_log_failure(text) end + elseif message and message.id~=nil then + if self.on_message then self.on_message({jsonrpc='2.0',id=message.id,error={code=-32000,message=text,data=data}}) end + else self:_log_failure(text) end +end +function Transport:_deliver(state,message) + if type(message)~='table' or message.jsonrpc~='2.0' then + self:_emit_error(state,state.message,'invalid JSON-RPC message'); return + end + if type(message.error)=='table' and type(message.error.message)=='string' then + message.error.message=redact(message.error.message,self.cfg.headers) + if not state.fire_and_forget then message.error.message=prefix_error(self.cfg.name,state.opts.method,message.error.message) end + end + if state.fire_and_forget then + if message.error then self:_emit_error(state,state.message,message.error.message or 'JSON-RPC error on fire-and-forget POST') end + return + end + if message.method==nil and message.error~=nil and (message.id==nil or message.id==json.null) and state.message.id~=nil then + message.id=state.message.id + end + local is_response=message.method==nil and message.id~=nil and message.id==state.message.id + if is_response and message.result==nil and message.error==nil then + self:_emit_error(state,state.message,'malformed JSON-RPC response'); return + end + if is_response then state.got_response=true end + if self.on_message then self.on_message(message) end + if state.got_response then + local handle=state.op and state.op.handle + self:_clear_state(state); cancel_handle(handle) + end +end +function Transport:_delete_session(session_id) + if not session_id then return end + local headers=M.headers(self.cfg,{era='legacy',protocol_version=self.protocol_version or '2025-11-25'},session_id) + pcall(self.request_fn,{url=self.cfg.url,method='DELETE',auth=self:auth_name(),headers=headers,timeout_ms=1000,max_bytes=1024},function() end) +end +function Transport:_session_expired(state,message,session_id,generation) + if self.session_id==session_id then self.session_id=nil end + self:_emit_error(state,message,'session expired',{session_expired=true,http_status=404,session_generation=generation}) +end +function Transport:_start_http(state,message,opts,on_done) + if state.cancelled or state.done or self.closed then return end + local initial=opts.era=='legacy' and message.method=='initialize' + local session_id=initial and nil or self.session_id + local headers,header_err=M.headers(self.cfg,{era=opts.era,protocol_version=opts.protocol_version, + method=message.method or opts.method,name=(message.params and (message.params.name or message.params.uri)) or opts.name, + param_headers=opts.param_headers,arguments=message.params and message.params.arguments,initial=initial},session_id) + if not headers then self:_emit_error(state,message,header_err); return end + local op={body_parts={},body_len=0,sse=false,parser=nil,handle=nil,headers={},status=0, + session_id=session_id,session_generation=self.session_generation or 0,idle_timer=nil,fire_timer=nil} + state.op=op + local request_options={url=self.cfg.url,method='POST',body=json.encode(message),auth=self:auth_name(),headers=headers, + timeout_ms=0,idle_timeout_ms=0,max_bytes=MAX_BODY} + op.auth_used=request_options.auth~=nil + local function reset_idle() + async.close(op.idle_timer); op.idle_timer=nil + local idle=self.settings.idle_timeout_ms or 60000 + if idle>0 and op.sse and op.status>=200 and op.status<300 and not state.done and not state.cancelled then + op.idle_timer=self.timer_factory(idle,function() + cancel_handle(op.handle) + self:_emit_error(state,message,'idle timeout',{transport_error='idle_timeout',idle_timeout=true}) + end) + end + end + request_options.on_head=function(head) + if state.cancelled or state.done or self.closed then cancel_handle(op.handle); return end + op.status=head.status or 0; op.headers=head.headers or {}; op.sse=is_sse(op.headers) + if opts.era=='legacy' and message.method=='initialize' then + self.session_id=header_value(op.headers,'mcp-session-id') + self.protocol_version=opts.protocol_version + self.session_generation=(self.session_generation or 0)+1 + end + if op.sse then + op.parser=M.sse_parser(function(data) + local msg=decode_message(data) + if not msg then self:_emit_error(state,message,'invalid JSON in SSE event'); return end + self:_deliver(state,msg) + end,MAX_BODY) + reset_idle() + end + end + request_options.on_data=function(chunk) + if state.done or state.cancelled or self.closed then return end + if op.sse and op.parser and op.status>=200 and op.status<300 then + reset_idle() + local ok,err=op.parser:feed(chunk) + if not ok then self:_emit_error(state,message,err); cancel_handle(op.handle) end + else + if op.body_len+#chunk>MAX_BODY then + if op.status>=400 then self:_http_failure(state,message,op.status,table.concat(op.body_parts),nil,opts) + else self:_emit_error(state,message,'HTTP response exceeds size limit') end + cancel_handle(op.handle); return + end + op.body_parts[#op.body_parts+1]=chunk; op.body_len=op.body_len+#chunk + end + end + local function complete(response,request_error) + if state.done or state.cancelled or state.op~=op then return end + async.close(op.idle_timer); op.idle_timer=nil; async.close(op.fire_timer); op.fire_timer=nil + if request_error then on_done(nil,nil,tostring(request_error),op); return end + if response then + op.status=response.status or op.status; op.headers=response.headers or op.headers + if response.body and response.body~='' then op.body_parts[#op.body_parts+1]=response.body; op.body_len=op.body_len+#response.body end + end + if op.sse and op.parser then + local ok,err=op.parser:finish() + if not ok then op.parse_error=err end + end + local body=table.concat(op.body_parts) + local msg + if not op.sse or op.status<200 or op.status>=300 then msg=decode_message(body) end + if msg and not state.fire_and_forget and op.status>=200 and op.status<300 and msg.id==message.id then self:_deliver(state,msg) end + on_done({status=op.status,headers=op.headers,body=body},msg,op.parse_error,op) + end + local ok,handle,err=pcall(self.request_fn,request_options,complete) + if not ok then complete(nil,handle); return end + if not handle then complete(nil,err or 'HTTP request could not start'); return end + op.handle=handle + if state.op==op and not state.done and not state.cancelled then + if state.fire_and_forget then + op.fire_timer=self.timer_factory(FIRE_TIMEOUT_MS,function() + cancel_handle(op.handle); self:_emit_error(state,message,'request timed out',{transport_error='timeout'}) + end) + end + else cancel_handle(handle) end +end +function Transport:_http_failure(state,message,status,body,jsonrpc_error,opts) + if status==401 or status==403 then + if self.oauth then + local op=state.op or {} + local text=status==403 and 'Forbidden (HTTP 403); check server permissions' or + (self.cfg.auth and self.oauth:configured_error() or self.oauth:login_error()) + self:_emit_error(state,message,text,{http_status=status,auth_error=true, + challenge=require('panto_mcp.oauth').challenge(header_value(op.headers,'www-authenticate')),auth_used=op.auth_used}) + return + end + local text=status==403 and 'Forbidden (HTTP 403); check server permissions' or + string.format('requires authentication (HTTP 401); configure auth = "<session>" in [mcp.servers.%s]',self.cfg.name) + self:_emit_error(state,message,text,{http_status=status,auth_error=true}); return + end + if status==404 and opts and opts.era=='legacy' and not state.fire_and_forget and message.method and state.op and state.op.session_id then + self:_session_expired(state,message,state.op.session_id,state.op.session_generation); return + end + if jsonrpc_error then + local error_text=state.op and state.op.auth_used and ('HTTP '..status..' JSON-RPC error') or jsonrpc_error.message + if state.fire_and_forget then self:_emit_error(state,message,error_text or 'HTTP JSON-RPC error',{http_status=status}); return end + local data=type(jsonrpc_error.data)=='table' and jsonrpc_error.data or {} + data.http_status=status + data.transport_fallback=(status==400 or status==404 or status==405) and + jsonrpc_error.code~=-32020 and jsonrpc_error.code~=-32021 and jsonrpc_error.code~=-32022 and + not (status==404 and jsonrpc_error.code==-32601 and message.method~='server/discover') + local text=redact(error_text or 'HTTP JSON-RPC error',self.cfg.headers) + self:_clear_state(state) + if self.on_message then self.on_message({jsonrpc='2.0',id=message.id,error={code=jsonrpc_error.code,message=prefix_error(self.cfg.name,message.method or state.opts.method,text),data=data}}) end + return + end + local body_text=state.op and state.op.auth_used and '' or redact(body,self.cfg.headers) + local text=string.format('HTTP %d%s',status,body_text~='' and ': '..body_text or '') + self:_emit_error(state,message,text,{http_status=status,transport_fallback=status==400 or status==404 or status==405}) +end +function Transport:_main_complete(state,message,opts,response,msg,err,op) + if state.done or state.cancelled then return end + local status=response and response.status or (op and op.status) or 0 + if err then + if status==404 and opts.era=='legacy' and not state.fire_and_forget and message.method and op and op.session_id then + self:_session_expired(state,message,op.session_id,op.session_generation); return + end + if status>=400 then self:_http_failure(state,message,status,op and table.concat(op.body_parts),nil,opts) + else + local kind=failure_kind(err) + self:_emit_error(state,message,err,{transport_error=kind,timeout=kind=='timeout',idle_timeout=kind=='idle_timeout'}) + end + return + end + if status==404 and opts.era=='legacy' and not state.fire_and_forget and message.method and op and op.session_id then + self:_session_expired(state,message,op.session_id,op.session_generation); return + end + if status<200 or status>=300 then + local null_id=msg and (msg.id==nil or msg.id==json.null) + if msg and msg.error and (msg.id==message.id or null_id) then self:_http_failure(state,message,status,response.body,msg.error,opts) + else self:_http_failure(state,message,status,response and response.body,nil,opts) end + return + end + if state.fire_and_forget then + if msg and msg.error then + self:_emit_error(state,message,msg.error.message or 'JSON-RPC error on fire-and-forget POST') + else + self:_clear_state(state) + if state.handshake_notification then self:_finish_handshake(state,true) end + end + return + end + if op.sse then + if message.id~=nil and not state.got_response then self:_emit_error(state,message,'HTTP SSE stream ended without a response for this request',{http_status=status}) + elseif not state.done then self:_clear_state(state) end + return + end + if message.id~=nil and not state.got_response then + self:_emit_error(state,message,'HTTP response did not contain this request\'s JSON-RPC response',{http_status=status}) + elseif not state.done then self:_clear_state(state) end +end +function Transport:send(message,opts) + if self.closed then return nil,'HTTP transport closed' end + opts=opts or {} + local current_era=opts.era or self.era + if message.method==nil and current_era=='modern' then return {} end + self.sequence=self.sequence+1 + local fire=message.method==nil or message.id==nil + local key=fire and ('fire:'..self.sequence) or ('id:'..tostring(message.id)) + local effective={era=opts.era or self.era,protocol_version=opts.protocol_version or self.protocol_version, + method=opts.method or message.method,name=opts.name,param_headers=opts.param_headers,arguments=opts.arguments} + if opts.era then self.era=opts.era end + if opts.protocol_version then self.protocol_version=opts.protocol_version end + local handshake_notification=effective.era=='legacy' and message.method=='notifications/initialized' + local state={key=key,message=message,opts=effective,fire_and_forget=fire,handshake_notification=handshake_notification,cancelled=false,done=false,got_response=false} + if handshake_notification then + state.handshake_future=async.future() + function state:await() return self.handshake_future:await() end + end + self.active[key]=state + if effective.era=='legacy' and message.method=='initialize' then self.initialize_params=message.params or {} end + self:_start_http(state,message,effective,function(response,result,err,op) + self:_main_complete(state,message,effective,response,result,err,op) + end) + return state +end +local function cancel_state(self,id,handle,notify) + local state=self.active['id:'..tostring(id)] or handle + if not state then return end + local was_legacy=state.opts.era=='legacy' + local method=state.message and state.message.method + local version=state.opts.protocol_version or self.protocol_version + state.cancelled=true; self.active[state.key]=nil + local op=state.op; if op then async.close(op.idle_timer); async.close(op.fire_timer); cancel_handle(op.handle) end + if notify and was_legacy and state.op and state.op.session_generation==self.session_generation and + method and method~='initialize' and method~='notifications/cancelled' and not self.closed then + self:send({jsonrpc='2.0',method='notifications/cancelled',params={requestId=id,reason='request cancelled'}}, + {era='legacy',protocol_version=version,method='notifications/cancelled'}) + end +end +function Transport:open_notification_stream() + if self.closed or self.notification_stream then return false end + local headers=M.headers(self.cfg,{era='legacy',protocol_version=self.protocol_version or '2025-11-25'},self.session_id) + headers.Accept='text/event-stream' + headers['Content-Type']=nil + local stream={status=0,ignore=false,handle=nil,parser=nil} + self.notification_stream=stream + local function finish() + if self.notification_stream~=stream then return end + self.notification_stream=nil + if stream.status~=405 and not self.closed and self.on_notification_stream_end then + pcall(self.on_notification_stream_end,stream.status) + end + end + local options={url=self.cfg.url,method='GET',auth=self:auth_name(),headers=headers, + timeout_ms=0,idle_timeout_ms=0} + options.on_head=function(head) + if self.closed or self.notification_stream~=stream then return end + stream.status=head.status or 0 + if stream.status<200 or stream.status>=300 then + stream.ignore=true + cancel_handle(stream.handle) + finish() + return + end + stream.opened=true + stream.parser=M.sse_parser(function(data) + local message=decode_message(data) + if message and self.on_message and not self.closed then self.on_message(message) end + end,MAX_BODY) + end + options.on_data=function(chunk) + if self.closed or stream.ignore or self.notification_stream~=stream or not stream.parser then return end + local ok=stream.parser:feed(chunk) + if not ok then stream.ignore=true; cancel_handle(stream.handle); finish() end + end + local ok,handle=pcall(self.request_fn,options,function() + if self.notification_stream~=stream then return end + if stream.parser and not stream.ignore then pcall(stream.parser.finish,stream.parser) end + finish() + end) + if not ok or not handle then finish(); return false end + stream.handle=handle + if self.closed or self.notification_stream~=stream or stream.ignore then cancel_handle(handle); return false end + return true +end +function Transport:close_notification_stream() + local stream=self.notification_stream + if not stream then return end + self.notification_stream=nil; stream.ignore=true + cancel_handle(stream.handle) +end +function Transport:cancel_request(id,handle) cancel_state(self,id,handle,false) end +function Transport:cancel(id,handle) cancel_state(self,id,handle,true) end +function Transport:fail(err) + if self.closed then return end + self.closed=true + if self.notification_stream then self:close_notification_stream() end + for _,state in pairs(self.active) do + state.cancelled=true + if state.handshake_future then self:_finish_handshake(state,nil,'HTTP transport closed') end + if state.op then async.close(state.op.idle_timer); async.close(state.op.fire_timer); cancel_handle(state.op.handle) end + end + self.active={}; if self.on_error then self.on_error(err) end +end +function Transport:close() + if self.did_close then return end + self.did_close=true + if self.notification_stream then self:close_notification_stream() end + local session=self.session_id + for _,state in pairs(self.active) do + state.cancelled=true + if state.handshake_future then self:_finish_handshake(state,nil,'HTTP transport closed') end + if state.op then async.close(state.op.idle_timer); async.close(state.op.fire_timer); cancel_handle(state.op.handle) end + end + self.active={}; self.closed=true + self:_delete_session(session) +end +return M |
