summaryrefslogtreecommitdiff
path: root/panto_mcp/jsonrpc.lua
diff options
context:
space:
mode:
authort <t@tjp.lol>2026-11-17 00:53:11 -0700
committert <t@tjp.lol>2026-11-17 15:42:02 -0700
commit413d9a4b241a0f4111e39fdc0059ac15069d034f (patch)
tree55f416467d7d1f1c6a36e875c3dd60e14874a1b0 /panto_mcp/jsonrpc.lua
Establish panto-mcp baselineHEADv0.1.0main
Diffstat (limited to 'panto_mcp/jsonrpc.lua')
-rw-r--r--panto_mcp/jsonrpc.lua75
1 files changed, 75 insertions, 0 deletions
diff --git a/panto_mcp/jsonrpc.lua b/panto_mcp/jsonrpc.lua
new file mode 100644
index 0000000..714c137
--- /dev/null
+++ b/panto_mcp/jsonrpc.lua
@@ -0,0 +1,75 @@
+-- Transport contract (shared with future HTTP):
+-- t:set_callbacks(on_message, on_error); t:send(message, opts) -> handle|nil, err
+-- t:cancel(id, handle); t:close() (nonblocking).
+-- cancel_request cancels a transport handle without sending an MCP-level notice.
+-- `cancel` additionally permits a transport-specific cancellation notification.
+-- opts = {era, protocol_version, method, name, param_headers?};
+-- on_error means the whole transport failed, not a request-level RPC error.
+local async = require('panto_mcp.async')
+local json = require('panto').ext.json
+local M = {}; M.__index = M
+function M.new(transport, opts)
+ opts=opts or {}
+ local self=setmetatable({transport=transport, next_id=0, pending={},
+ timeout_ms=opts.timeout_ms or 300000, timer_factory=opts.timer_factory or async.timer,
+ on_notification=opts.on_notification, on_error=opts.on_error},M)
+ transport:set_callbacks(function(msg) self:receive(msg) end, function(err) self:fail(err) end)
+ return self
+end
+function M:finish(id, value, err)
+ local p=self.pending[id]; if not p then return end
+ self.pending[id]=nil
+ async.close(p.timer)
+ p.future:resolve(value,err)
+end
+function M:receive(msg)
+ if self.closed then return end
+ if type(msg)~='table' or msg.jsonrpc~='2.0' then self:fail('malformed JSON-RPC message'); return end
+ if type(msg.method)=='string' then
+ if msg.id~=nil then
+ local reply={jsonrpc='2.0',id=msg.id}
+ if msg.method=='ping' then reply.result={} else reply.error={code=-32601,message='Method not found'} end
+ self.transport:send(reply,{method=msg.method})
+ elseif self.on_notification then self.on_notification(msg.method,msg.params) end
+ elseif msg.id~=nil and (msg.result~=nil or msg.error~=nil) then
+ self:finish(msg.id,msg.result,msg.error)
+ else self:fail('malformed JSON-RPC response') end
+end
+function M:start(method, params, opts)
+ opts=opts or {}; opts.method=method
+ if self.closed then local f=async.future(); f:resolve(nil,self.error or 'connection closed'); return f end
+ self.next_id=self.next_id+1
+ local id=self.next_id
+ local future=async.future(function() self:cancel(id,'request cancelled') end)
+ local p={future=future,cancel_protocol=opts.cancel_protocol}; self.pending[id]=p
+ p.timer=self.timer_factory(opts.timeout_ms or self.timeout_ms,function() self:cancel(id,'request timed out: ' .. method) end)
+ local ok,h,err=pcall(self.transport.send,self.transport,{jsonrpc='2.0',id=id,method=method,params=params or {}},opts)
+ if not ok or not h then self:finish(id,nil,not ok and h or err or 'send failed') else p.handle=h end
+ return future
+end
+function M:request(method,params,opts) return self:start(method,params,opts):await() end
+function M:notify(method,params,opts)
+ if self.closed then return nil,self.error end
+ opts=opts or {}; opts.method=method
+ return self.transport:send({jsonrpc='2.0',method=method,params=params or {}},opts)
+end
+function M:cancel(id,reason)
+ local p=self.pending[id]; if not p then return end
+ self.pending[id]=nil; async.close(p.timer)
+ if p.cancel_protocol~=false then pcall(self.transport.cancel,self.transport,id,p.handle)
+ elseif type(self.transport.cancel_request)=='function' then pcall(self.transport.cancel_request,self.transport,id,p.handle) end
+ p.future:resolve(nil,reason or 'request cancelled')
+end
+function M:fail(err,abandon)
+ if self.closed then return end
+ self.closed=true; self.error=err or 'connection closed'
+ local pending=self.pending; self.pending={}
+ for _,p in pairs(pending) do
+ async.close(p.timer)
+ if abandon then p.future:abandon(nil,self.error) else p.future:resolve(nil,self.error) end
+ end
+ self.transport:close()
+ if self.on_error then self.on_error(self.error) end
+end
+function M:close(abandon) self:fail('connection closed',abandon) end
+return M