@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/plugins/mcp/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What an `mcp` mount reports. A rejected mount throws one, and every `ctx.reportError` raises one,
+ * so a host filters them from Cordis `internal/error` by class and `kind`. Named apart from the
+ * SDK's own `McpError`, which is a protocol error.
+ */
+export type McpServerErrorKind = 
+/** A mount or reconnection that could not connect or initialize. */
+'connect'
+/** A listing that failed; the last complete catalog stays published. */
+ | 'refresh'
+/** Tools left out, each with its reason. */
+ | 'unexposable'
+/** A connection that went away. */
+ | 'disconnect';
+/** A remote tool that cannot be exposed, and why. */
+export type UnexposableTool = {
+    readonly tool: string;
+    readonly reason: string;
+};
+export declare class McpServerError extends Error {
+    readonly name = "McpServerError";
+    readonly server: string;
+    readonly kind: McpServerErrorKind;
+    /** Set for `unexposable`. */
+    readonly tools: readonly UnexposableTool[];
+    constructor(server: string, kind: McpServerErrorKind, message: string, options?: {
+        cause?: unknown;
+        tools?: readonly UnexposableTool[];
+    });
+}
+/** A reason in one line, for messages and results. */
+export declare const describeError: (error: unknown) => string;

package/dist/plugins/mcp/index.d.ts

@@ -0,0 +1,33 @@
+import { type Plugin } from '@leuduan/cordis';
+import { type McpConfigInput } from './config.js';
+export { MAX_SERVER_NAME_LENGTH, McpConfigSchema, McpTransportSchema } from './config.js';
+export type { McpConfig, McpConfigInput, McpTransportConfig, McpTransportFactory } from './config.js';
+export { McpServerError } from './errors.js';
+export type { McpServerErrorKind, UnexposableTool } from './errors.js';
+export { MAX_TOOL_NAME_LENGTH, mcpToolName } from './names.js';
+export { CALL_META_KEY, SESSION_RESET_NOTE } from './tool.js';
+/**
+ * Connects to one MCP server and exposes its tools as ordinary lagent tools named
+ * `mcp__<server>__<tool>`, granted to `agents`. One mount is one server: a server that cannot be
+ * reached, or a tool listed in `tools` that cannot be exposed, rejects the mount with an
+ * `McpServerError` and leaves nothing registered. Tools found by discovery that cannot be exposed,
+ * a refresh that fails and a connection that goes away are reported through `ctx.reportError`.
+ *
+ * The plugin mounts no service, so the same mount works on the root, where one connection serves
+ * every thread, through `thread.ctx`, or inside a host preset. A failed mount stays in its owner's
+ * tree: an optional server is disposed when it fails, or a thread activation never becomes ready.
+ *
+ * ```ts
+ * await root.plugin(mcp, {
+ *   name: 'docs',
+ *   transport: { kind: 'stdio', command: ['node', 'server.js'], cwd: '/srv/docs', env: { PATH: '/usr/bin' } },
+ *   agents: ['main'],
+ *   confirm: 'all',
+ *   onInterrupted: 'report',
+ *   maxConcurrentCalls: 1,
+ * })
+ * ```
+ *
+ * The design and its reasons are in `docs/mcp.md`.
+ */
+export declare const mcp: Plugin.Object<McpConfigInput>;

package/dist/plugins/mcp/index.js

@@ -0,0 +1,5 @@
+import{a as Y}from"../../chunks/BM3S37EZ.js";import{b as z}from"../../chunks/RK3VP2Q4.js";import{a as B,b as W}from"../../chunks/NAOUTU7A.js";import"../../chunks/UKXMCHHT.js";import{a as v}from"../../chunks/34KW6VNQ.js";import{a as w}from"../../chunks/PUSUPTAT.js";import"../../chunks/CDQG7RKA.js";import{a as N,b as H}from"../../chunks/DXFXAYDN.js";import"../../chunks/DRYAN665.js";import{a as U}from"../../chunks/2OSESBIL.js";import"../../chunks/YLNJXQ3Z.js";import"../../chunks/DDANMY45.js";import{d as g}from"../../chunks/37YOGDGY.js";import"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import{m as A}from"../../chunks/D7E6EWIE.js";import{scopeOf as Fe}from"@leuduan/cordis";import{z as c}from"zod";var S=64,Z=/^(?!.*__)[A-Za-z0-9](?:[A-Za-z0-9_-]*[A-Za-z0-9-])?$/,V=/^[A-Za-z0-9_-]+$/,me=n=>n.replace(/[^A-Za-z0-9_-]/g,"_"),O=(n,e,t)=>`mcp__${n}__${t??me(e)}`;var D=24,pe=c.strictObject({kind:c.literal("stdio"),command:c.tuple([c.string().min(1)],c.string()),cwd:c.string().min(1),env:c.record(c.string(),c.string())}),fe=c.strictObject({kind:c.literal("streamable-http"),url:c.url({protocol:/^https?$/,error:"url must be an http or https URL"}),headers:c.record(c.string(),c.string()).default({})}),ge=c.strictObject({kind:c.literal("custom"),create:c.custom(n=>typeof n=="function","create must be a function")}),X=c.discriminatedUnion("kind",[pe,fe,ge]),we=c.union([c.string().min(1),c.strictObject({name:c.string().min(1),as:c.string().regex(V,"as must use A-Z a-z 0-9 _ -")})]),P=n=>c.number().positive().finite().default(n),k=c.strictObject({name:c.string().max(D).regex(Z,"name must use A-Z a-z 0-9 _ -, start with a letter or digit, never end with _, and never contain __"),transport:X,agents:U,confirm:c.union([c.literal("all"),c.literal("none"),c.strictObject({except:c.array(c.string())})]),onInterrupted:c.union([c.literal("report"),c.literal("annotations"),c.strictObject({rerun:c.array(c.string())})]),maxConcurrentCalls:c.union([c.number().int().positive(),c.literal("unbounded")]),tools:c.array(we).optional(),instructions:c.boolean().default(!1),connectTimeoutSeconds:P(30),callTimeoutSeconds:P(120),maxCallSeconds:P(600),maxContentBytes:c.number().int().nonnegative().default(1024*1024),signal:c.custom(n=>n instanceof AbortSignal,"signal must be an AbortSignal").optional()}).superRefine((n,e)=>{if(n.maxCallSeconds<n.callTimeoutSeconds&&e.addIssue({code:"custom",path:["maxCallSeconds"],message:"must be at least callTimeoutSeconds"}),n.tools===void 0)return;let t=n.tools.map(s=>typeof s=="string"?s:s.name),r=t.find((s,a)=>t.indexOf(s)!==a);if(r!==void 0&&e.addIssue({code:"custom",path:["tools"],message:`lists ${r} more than once`}),typeof n.confirm=="object")for(let s of n.confirm.except)t.includes(s)||e.addIssue({code:"custom",path:["confirm","except"],message:`${s} is not in tools`});if(typeof n.onInterrupted=="object")for(let s of n.onInterrupted.rerun)t.includes(s)||e.addIssue({code:"custom",path:["onInterrupted","rerun"],message:`${s} is not in tools`})});import{ListToolsResultSchema as be}from"@modelcontextprotocol/sdk/types.js";var K={entries:new Map,unexposable:[]};async function Q(n,e){let t=[],r=new Set,s;do{let a=await n.request({method:"tools/list",params:s===void 0?{}:{cursor:s}},be,{signal:e});if(t.push(...a.tools),s=a.nextCursor,s!==void 0){if(r.has(s))throw new Error(`the server repeated the pagination cursor ${s}`);r.add(s)}}while(s!==void 0);return t}function ee(n,e){let t=n.tools===void 0?void 0:new Map(n.tools.map(o=>typeof o=="string"?[o,void 0]:[o.name,o.as])),r=[],s=[];for(let o of e){if(t!==void 0&&!t.has(o.name))continue;let u=O(n.name,o.name,t?.get(o.name));s.push({remote:o,name:u,problem:ve(o,u)})}if(t!==void 0){let o=new Set(e.map(u=>u.name));for(let u of t.keys())o.has(u)||r.push({tool:u,reason:"the server does not offer it"})}let a=new Map;for(let o of s)a.set(o.name,[...a.get(o.name)??[],o]);let i=new Map;for(let o of s){let u=a.get(o.name);if(u.length>1){let p=u.filter(l=>l!==o).map(l=>l.remote.name);r.push({tool:o.remote.name,reason:`${o.name} collides with ${p.join(", ")}`});continue}if(o.problem!==null){r.push({tool:o.remote.name,reason:o.problem});continue}i.set(o.name,{name:o.name,remoteName:o.remote.name,definition:o.remote,spec:A.parse(te(o.remote,o.name)),fingerprint:g(o.remote)})}return{entries:i,unexposable:L(r)}}var J=(n,e)=>n<e?-1:n>e?1:0,te=(n,e)=>({name:e,description:n.description??n.title??"",input_schema:n.inputSchema});function ve(n,e){return e.length>64?`${e} is ${e.length} characters, over the ${64} a tool name may have`:n.execution?.taskSupport==="required"?"it requires task-augmented execution":A.safeParse(te(n,e)).success?null:"its input schema is not an object schema"}var L=n=>[...n].sort((e,t)=>J(e.tool,t.tool)||J(e.reason,t.reason)),ne=(n,e)=>g(n)===g(e);import{Client as Ee}from"@modelcontextprotocol/sdk/client/index.js";import{StreamableHTTPClientTransport as oe,StreamableHTTPError as _e}from"@modelcontextprotocol/sdk/client/streamableHttp.js";import{ToolListChangedNotificationSchema as Me}from"@modelcontextprotocol/sdk/types.js";import Te from"@leuduan/lagent/package.json"with{type:"json"};function re(){return Te.version}import{ReadBuffer as xe,serializeMessage as Se}from"@modelcontextprotocol/sdk/shared/stdio.js";var ye=8*1024,b=class{onclose;onerror;onmessage;spawned=null;buffer=new xe;stderr="";exit=null;closed=!1;closedEarly=!1;options;constructor(e){this.options=e}get pid(){return this.spawned?.pid}get stderrTail(){return this.stderr}get exited(){return this.exit}async start(){if(this.spawned!==null)throw new Error("ContainedStdioTransport already started");let e=await H({command:this.options.command,cwd:this.options.cwd,env:this.options.env,signal:this.options.signal,killGraceMs:this.options.killGraceMs??N,stdio:"pipes"});if(this.spawned=e,this.closedEarly)throw await e.stop(),new Error("ContainedStdioTransport closed while starting");e.stdout.on("data",t=>this.receive(t)),e.stderr.setEncoding("utf8"),e.stderr.on("data",t=>{this.stderr=(this.stderr+t).slice(-ye),w.debug("MCP server '%s' stderr: %s",this.options.server,t.trimEnd())}),e.stdin.on("error",t=>this.onerror?.(t)),e.result.then(t=>{this.exit=t,this.closed=!0,this.onclose?.()})}receive(e){try{this.buffer.append(e)}catch(t){this.onerror?.(t instanceof Error?t:new Error(String(t)));return}for(;;){let t;try{t=this.buffer.readMessage()}catch(r){this.onerror?.(r instanceof Error?r:new Error(String(r)));continue}if(t===null)return;this.onmessage?.(t)}}async send(e){let t=this.spawned?.stdin;if(t===void 0||this.closed||t.destroyed)throw new Error("The MCP server is not running");t.write(Se(e))||await new Promise((r,s)=>{let a=()=>{t.off("close",i),r()},i=()=>{t.off("drain",a),s(new Error("The MCP server closed its input"))};t.once("drain",a),t.once("close",i)})}async close(){let e=this.spawned;if(e===null){this.closedEarly=!0;return}e.stdin.end();let t=this.options.killGraceMs??N,r,s=await Promise.race([e.result.then(()=>!0),new Promise(a=>r=setTimeout(()=>a(!1),t))]);clearTimeout(r),s?await e.result:await e.stop()}};var $e=5e3,y=class{live=null;count=0;disposed=!1;options;constructor(e){this.options=e}get current(){return this.live?.alive?this.live:null}async open(e,t){if(this.disposed)throw new Error("the mount is disposed");e.throwIfAborted();let r=new Ee({name:"lagent",version:re()},{capabilities:{}}),s={alive:!0},a={transport:null},i=null;r.onerror=l=>w.debug("MCP server '%s': %s",this.options.server,l),r.onclose=()=>{s.alive&&(s.alive=!1,i!==null&&(i.alive=!1),i!==null&&a.transport!==null&&!this.disposed&&this.options.onLost(i,this.describeClose(a.transport)))};let o=!1;r.setNotificationHandler(Me,async()=>{i===null?o=!0:i===this.current&&this.options.onToolsChanged(i)});let u=(async()=>{let l=Ce(await this.createTransport(e));if(a.transport=l,e.aborted)throw await T(l.close()),e.reason;await r.connect(l,{signal:e,timeout:t})})();try{if(await v(u,e),e.throwIfAborted(),this.disposed)throw new Error("the mount is disposed")}catch(l){throw s.alive=!1,await T(r.close()),se(l,a.transport)}let p=a.transport;if(i={number:this.count+1,client:r,transport:p,instructions:r.getInstructions()??null,get alive(){return s.alive},set alive(l){s.alive=l}},!s.alive)throw se(new Error("the connection closed during initialization"),p);return this.count=i.number,this.live=i,o&&this.options.onToolsChanged(i),i}async invalidate(e){e.alive&&(e.alive=!1,await T(e.client.close()))}async dispose(){this.disposed=!0;let e=this.live;this.live=null,!(e===null||!e.alive)&&(e.alive=!1,await T(e.client.close()))}async createTransport(e){let t=this.options.transport;switch(t.kind){case"stdio":return new b({server:this.options.server,command:t.command,cwd:t.cwd,env:t.env,signal:this.options.lifetime});case"streamable-http":return new oe(new URL(t.url),{requestInit:{headers:t.headers}});case"custom":return await t.create(e)}}describeClose(e){if(!(e instanceof b))return"the connection closed";let t=e.exited,r=t===null?"its connection closed":t.exitCode!==null?`it exited with code ${t.exitCode}`:`it was ended by ${t.exitSignal??"a signal"}`;return ae(`the server process ended: ${r}`,e)}},ie=n=>n instanceof _e&&n.code===404;function Ce(n){let e=n.close.bind(n),t;return n.close=()=>t??=(async()=>{try{n instanceof oe&&await T(n.terminateSession()),await e()}catch(r){w.debug("MCP transport close failed: %s",r)}})(),n}async function T(n){let e;await Promise.race([n.catch(t=>w.debug("MCP cleanup failed: %s",t)),new Promise(t=>e=setTimeout(t,$e))]),clearTimeout(e)}function ae(n,e){let t=e instanceof b?e.stderrTail.trim():"";return t?`${n}; its stderr ended with:
+${t}`:n}function se(n,e){let t=n instanceof Error?n:new Error(String(n)),r=e===null?t.message:ae(t.message||t.name,e);return r===t.message?t:new Error(r,{cause:t})}var h=class extends Error{name="McpServerError";server;kind;tools;constructor(e,t,r,s={}){super(`MCP server '${e}': ${r}`,s.cause===void 0?{}:{cause:s.cause}),this.server=e,this.kind=t,this.tools=s.tools??[]}},f=n=>n instanceof Error?n.message||n.name:String(n);var E=class{active=0;waiters=[];limit;constructor(e){this.limit=e}acquire(e){return e.throwIfAborted(),this.active<this.limit?(this.active+=1,Promise.resolve(this.releaser())):new Promise((t,r)=>{let s={grant:()=>{e.removeEventListener("abort",a),this.active+=1,t(this.releaser())}},a=()=>{let i=this.waiters.indexOf(s);i>=0&&this.waiters.splice(i,1),r(e.reason)};e.addEventListener("abort",a,{once:!0}),this.waiters.push(s)})}get waiting(){return this.waiters.length}releaser(){let e=!1;return()=>{e||(e=!0,this.active-=1,this.waiters.shift()?.grant())}}};import{CallToolResultSchema as Re,ErrorCode as le,McpError as I}from"@modelcontextprotocol/sdk/types.js";var Ae="The tool returned content addressed to the user only; nothing in it is for you.",Ne="The tool returned no content.",Oe=new Set(["image/png","image/jpeg","image/webp","image/gif"]),Pe=n=>{let e=n.trim().toLowerCase();return e==="image/jpg"?"image/jpeg":e};function ce(n,e){let t=[],r=[],s=[],a=[],i=e.maxContentBytes,o=l=>l>i?!1:(i-=l,!0);for(let l of n.content){if(!ke(l)){s.push(Le(l,o));continue}switch(l.type){case"text":a.push(l.text),t.push(l.text);break;case"image":{let m=_(l.data),d=Pe(l.mimeType);Oe.has(d)?o(m)?(r.push({type:"image",url:null,data:l.data,media_type:d,detail:"auto"}),t.push(`[image: ${d}, ${x(m)}]`)):t.push(`[image omitted: ${l.mimeType}, ${x(m)}, over this result's limit]`):t.push(`[image not shown: ${l.mimeType}, ${x(m)}; only PNG, JPEG, WebP and GIF are shown]`);break}case"audio":t.push(`[audio not shown: ${l.mimeType}, ${x(_(l.data))}]`);break;case"resource_link":t.push(`[resource link: ${l.name} <${l.uri}>${l.mimeType?` (${l.mimeType})`:""}]`);break;case"resource":{let m=l.resource;if("text"in m)t.push(`[resource: ${m.uri}]
+${m.text}`);else{let d=m.mimeType?`${m.mimeType}, `:"";t.push(`[resource not shown: ${m.uri}, ${d}${x(_(m.blob))}]`)}break}}}let u=n.structuredContent;return u!==void 0&&!a.some(l=>Ie(l,u))&&t.push(JSON.stringify(u,null,2)),{output:t.join(`
+`)||(s.length>0?Ae:Ne),...r.length>0?{content:r}:{},is_error:n.isError===!0,notes:null,metadata:{mcp_server:e.server,mcp_tool:e.remoteName,...s.length>0?{user_content:s}:{}}}}function ke(n){let e=n.annotations?.audience;return e===void 0||e.includes("assistant")}function Le(n,e){let t=(r,s)=>{let a=_(r);return e(a)?{...s,data:r}:{...s,bytes:a,omitted:!0}};switch(n.type){case"text":return{type:"text",text:n.text};case"image":case"audio":return t(n.data,{type:n.type,mime_type:n.mimeType});case"resource_link":return{type:"resource_link",uri:n.uri,name:n.name,mime_type:n.mimeType??null};case"resource":return"text"in n.resource?{type:"resource",uri:n.resource.uri,text:n.resource.text}:t(n.resource.blob,{type:"resource",uri:n.resource.uri,mime_type:n.resource.mimeType??null})}}function Ie(n,e){try{return g(JSON.parse(n))===g(e)}catch{return!1}}function _(n){let e=n.endsWith("==")?2:n.endsWith("=")?1:0;return Math.max(0,Math.floor(n.length*3/4)-e)}function x(n){return n<1024?`${n} B`:n<1024*1024?`${(n/1024).toFixed(1)} KB`:`${(n/(1024*1024)).toFixed(1)} MB`}var ue="work.leuduan.lagent/call",R="The connection to this MCP server was re-established; any session state the server held may have been reset.";function je(n,e){if(n==="report")return"report";if(n==="annotations"){let t=e.definition.annotations;return t?.readOnlyHint===!0||t?.idempotentHint===!0?"rerun":"report"}return n.rerun.includes(e.remoteName)?"rerun":"report"}var de=(n,e)=>B({name:e.name,description:e.spec.description,parameters:{jsonSchema:e.spec.input_schema},onInterrupted:je(n.config.onInterrupted,e),executionMode:"parallel",execute:(t,r)=>Ge(n,e,t,r)});async function Ge(n,e,t,r){let s=d=>({output:d,is_error:!0,metadata:{mcp_server:n.server,mcp_tool:e.remoteName}}),{maxCallSeconds:a,callTimeoutSeconds:i,maxContentBytes:o}=n.config,u=AbortSignal.timeout(a*1e3),p=AbortSignal.any([r.signal,u]),l=d=>s(r.signal.aborted?`The call was cancelled ${d}; it was never sent to the MCP server.`:`The call's ${a} s deadline passed ${d}; it was never sent to the MCP server.`),m;try{m=await n.slots.acquire(p)}catch{return l("while it waited for a free slot")}try{let d;try{d=await n.ready(p)}catch(C){return p.aborted?l("while the connection was being re-established"):s(`The call was not sent. ${f(C)}`)}let $=n.entry(e.name);if($===void 0||$.fingerprint!==e.fingerprint)return s($===void 0?`The MCP server no longer offers ${e.remoteName}, so the call was not sent.`:`The MCP server changed the definition of ${e.remoteName}, so the call was not sent. Review the new definition and call again if it still fits.`);if(!d.alive)return s("The connection to the MCP server closed before the call was sent.");let G;try{G=await d.client.request({method:"tools/call",params:{name:e.remoteName,arguments:t,_meta:{[ue]:`${r.threadId}#${r.callSeq}`}}},Re,{signal:p,timeout:i*1e3,resetTimeoutOnProgress:!0,onprogress:()=>{}})}catch(C){return s(qe(n,C,d,r.signal,u))}let q=ce(G,{server:n.server,remoteName:e.remoteName,maxContentBytes:o}),F=n.takeSessionNote(d);return F===null?q:{...q,notes:[F]}}finally{m()}}function qe(n,e,t,r,s){let a="The server may or may not have run it.";return r.aborted?`The call was cancelled after it was sent. ${a}`:s.aborted?`The call's ${n.config.maxCallSeconds} s deadline passed after it was sent. ${a}`:ie(e)?(n.invalidate(t),"The MCP server had ended its session, so the call did not run. A new session opens with the next call."):e instanceof I&&e.code===le.RequestTimeout?`The MCP server sent no response or progress for ${n.config.callTimeoutSeconds} s. ${a}`:e instanceof I&&e.code===le.ConnectionClosed?`The connection to the MCP server was lost while the call was in flight. ${a}`:e instanceof I?`The MCP server answered with an error: ${f(e)}`:`The request to the MCP server failed: ${f(e)}. ${a}`}var M=class{server;slots;connection;lifetime=new AbortController;catalog=K;listedFrom=null;published=new Map;known=new Map;reported=[];started=!1;changedWhileStarting=!1;runningFor=null;disposed=!1;running=null;queued=null;reconnecting=null;noteOwedTo=null;cachedInstructions=null;ctx;config;constructor(e,t){this.ctx=e,this.config=t,this.server=t.name,this.slots=new E(t.maxConcurrentCalls==="unbounded"?1/0:t.maxConcurrentCalls),this.connection=new y({server:t.name,transport:t.transport,lifetime:this.lifetime.signal,onToolsChanged:()=>{this.started?this.refresh():this.changedWhileStarting=!0},onLost:(r,s)=>this.report(new h(this.server,"disconnect",s))})}get connectTimeoutMs(){return this.config.connectTimeoutSeconds*1e3}async start(){let e=[this.lifetime.signal,AbortSignal.timeout(this.connectTimeoutMs)];this.config.signal!==void 0&&e.push(this.config.signal);let t=AbortSignal.any(e);try{let s=await this.connection.open(t,this.connectTimeoutMs);this.cachedInstructions=s.instructions}catch(s){throw new h(this.server,"connect",`could not connect: ${f(s)}`,{cause:s})}let r=await this.refresh(t);if(!r.ok)throw r.error;this.started=!0,this.changedWhileStarting&&this.refresh()}async ready(e){let t=this.connection.current;if(t===null){if(this.disposed)throw new Error("the mount is disposed");this.reconnecting??=this.reconnect().finally(()=>{this.reconnecting=null}),t=await v(this.reconnecting,e)}if(this.listedFrom!==t.number){let r=this.running!==null&&this.runningFor===t?this.running:this.refresh(),s=await v(r,e);if(!s.ok)throw s.error;if(this.listedFrom!==t.number||!t.alive)throw new h(this.server,"refresh","the connection changed while its tools were being listed")}return t}async reconnect(){let e;try{let t=AbortSignal.any([this.lifetime.signal,AbortSignal.timeout(this.connectTimeoutMs)]);e=await this.connection.open(t,this.connectTimeoutMs)}catch(t){let r=new h(this.server,"connect",`could not reconnect: ${f(t)}`,{cause:t});throw this.report(r),r}return this.cachedInstructions=e.instructions,this.noteOwedTo=e.number,e}entry(e){return this.catalog.entries.get(e)}takeSessionNote(e){return this.noteOwedTo!==e.number?null:(this.noteOwedTo=null,R)}invalidate(e){e.alive&&(this.report(new h(this.server,"disconnect","the server ended its session")),this.connection.invalidate(e))}remoteNameOf(e){return this.known.get(e)}get instructions(){return this.cachedInstructions}refresh(e){return this.queued!==null?this.queued:this.running===null?this.run(e):(this.queued=this.running.then(()=>(this.queued=null,this.run())),this.queued)}run(e){let t=this.refreshOnce(e);return this.running=t,this.runningFor=this.connection.current,t.finally(()=>{this.running===t&&(this.running=null,this.runningFor=null)}),t}async refreshOnce(e){try{return await this.listAndPublish(e)}catch(t){let r=new h(this.server,"refresh",`could not publish its tools: ${f(t)}`,{cause:t});return this.report(r),{ok:!1,error:r}}}async listAndPublish(e){let t=this.connection.current;if(t===null)return{ok:!1,error:new h(this.server,"refresh","not connected")};let r;try{let o=e??AbortSignal.any([this.lifetime.signal,AbortSignal.timeout(this.connectTimeoutMs)]);r=ee(this.config,await Q(t.client,o))}catch(o){let u=new h(this.server,"refresh",`could not list its tools: ${f(o)}`,{cause:o});return this.started&&this.live(t)&&this.report(u),{ok:!1,error:u}}if(!this.live(t))return{ok:!1,error:new h(this.server,"refresh","the listing is out of date")};if(this.config.tools!==void 0&&r.unexposable.length>0&&!this.started)return{ok:!1,error:new h(this.server,"unexposable",j(r.unexposable),{tools:r.unexposable})};let a=this.publish(r),i=this.catalog.unexposable;return a.length>0&&this.config.tools!==void 0&&!this.started?{ok:!1,error:new h(this.server,"unexposable",j(i),{tools:i})}:(this.listedFrom=t.number,ne(i,this.reported)||(this.reported=i,i.length>0&&this.report(new h(this.server,"unexposable",j(i),{tools:i}))),{ok:!0})}live(e){return!this.disposed&&this.ctx.fiber.uid!==null&&e===this.connection.current}publish(e){let t=[];for(let[i,o]of this.published)e.entries.get(i)?.fingerprint!==o.entry.fingerprint&&(this.published.delete(i),o.withdraw());let r=this.ctx,s=this.config.agents;for(let i of e.entries.values()){if(this.published.has(i.name))continue;let o;try{o=W(r,de(this,i),{agents:s})}catch(u){t.push({tool:i.remoteName,reason:`${i.name} cannot be registered: ${f(u)}`});continue}this.published.set(i.name,{entry:i,withdraw:o}),this.known.set(i.name,i.remoteName)}let a=new Map([...e.entries].filter(([i])=>this.published.has(i)));return this.catalog={entries:a,unexposable:L([...e.unexposable,...t])},t}report(e){this.disposed||this.ctx.fiber.uid===null||this.ctx.reportError(e)}async dispose(){this.disposed=!0,await this.connection.dispose(),this.lifetime.abort()}},j=n=>`cannot expose ${n.map(e=>`${e.tool} (${e.reason})`).join("; ")}`;var he=new WeakMap;function Ue(n,e){let t=Fe(n),r=he.get(n.tools);r===void 0&&he.set(n.tools,r=new Map);let s=r.get(t);if(s===void 0&&r.set(t,s=new Set),s.has(e))throw new Error(`Another mcp mount in this layer already uses the server name '${e}'`);let a=s;n.effect(()=>(a.add(e),()=>a.delete(e)))}function He(n,e){if(n.confirm==="all")return"confirm";if(n.confirm!=="none")return n.confirm.except.includes(e)?void 0:"confirm"}var Rt={name:"lagent:mcp",inject:["tools","prompts"],async apply(n,e){let t=k.parse(e);Ue(n,t.name);let r=new M(n,t);n.effect(()=>()=>r.dispose()),await n.plugin(Y,{confirm:s=>{let a=r.remoteNameOf(s);return a!==void 0&&He(t,a)==="confirm"}}),t.instructions&&z(n,{tag:`mcp:${t.name}`,slot:"instruction",agents:t.agents,render:()=>{let s=r.instructions?.trim();return s?`Instructions from the MCP server "${t.name}" about its tools:
+${s}`:null}}),await r.start()}};export{ue as CALL_META_KEY,D as MAX_SERVER_NAME_LENGTH,S as MAX_TOOL_NAME_LENGTH,k as McpConfigSchema,h as McpServerError,X as McpTransportSchema,R as SESSION_RESET_NOTE,Rt as mcp,O as mcpToolName};

package/dist/plugins/mcp/mount.d.ts

@@ -0,0 +1,98 @@
+import type { Context } from '@leuduan/cordis';
+import { type CatalogEntry } from './catalog.js';
+import type { McpConfig } from './config.js';
+import { type Generation } from './connection.js';
+import { McpServerError } from './errors.js';
+import { CallSlots } from './slots.js';
+import { type McpToolHost } from './tool.js';
+type RefreshOutcome = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: McpServerError;
+};
+/**
+ * One server's mount: its connection, its catalog, and the tools published from it.
+ *
+ * Refreshes are serialized: one runs at a time and at most one more waits, shared by everyone who
+ * asks meanwhile, so a burst of `list_changed` notifications never overlaps listings and the latest
+ * one wins. A refresh publishes only a complete listing, only for the generation it listed from,
+ * and only while the mount lives; a failed one keeps the last catalog. Reconnection is lazy and
+ * single-flight: the next call opens a new generation and refreshes before it is sent.
+ */
+export declare class McpMount implements McpToolHost {
+    readonly server: string;
+    readonly slots: CallSlots;
+    private readonly connection;
+    private readonly lifetime;
+    private catalog;
+    /** The generation the published catalog was listed from; calls never run against another's. */
+    private listedFrom;
+    private readonly published;
+    /** Every lagent name this mount ever published, with its remote name, for the confirmation vote. */
+    private readonly known;
+    private reported;
+    private started;
+    /** A `list_changed` arrived before the first listing finished, which may have missed it. */
+    private changedWhileStarting;
+    /** The generation the running refresh lists from, for a call to join instead of queueing another. */
+    private runningFor;
+    private disposed;
+    private running;
+    private queued;
+    private reconnecting;
+    /** The generation whose first result still owes the session-reset note. */
+    private noteOwedTo;
+    /** The instructions of the latest successful initialization, kept through an outage. */
+    private cachedInstructions;
+    private readonly ctx;
+    readonly config: McpConfig;
+    constructor(ctx: Context, config: McpConfig);
+    private get connectTimeoutMs();
+    /**
+     * Connects, lists every tool, and publishes them. Rejects, having published nothing, when the
+     * server cannot be reached or initialized, its listing fails, or a tool the host listed cannot be
+     * exposed.
+     */
+    start(): Promise<void>;
+    /**
+     * The live generation, with a catalog listed from it. A generation that went away is replaced
+     * once, single-flight; a catalog listed from another generation, after a reconnection whose
+     * listing failed, is listed again first. Either failing fails the call before it is sent.
+     */
+    ready(signal: AbortSignal): Promise<Generation>;
+    /** Opens a new generation. Listing its tools is `ready`'s, so a failed listing is retried by the next call. */
+    private reconnect;
+    entry(name: string): CatalogEntry | undefined;
+    takeSessionNote(generation: Generation): string | null;
+    invalidate(generation: Generation): void;
+    /** The remote name behind a lagent name this mount published at any time, for the confirmation vote. */
+    remoteNameOf(name: string): string | undefined;
+    /**
+     * The server's `initialize` instructions, from the latest successful initialization. Kept through
+     * an outage, so a prompt rendered while the server is unreachable still carries them.
+     */
+    get instructions(): string | null;
+    /**
+     * Lists again, serialized with every other refresh; the latest request always wins. `signal`
+     * bounds the listing when this call starts one; joining one already running or queued keeps its
+     * bound.
+     */
+    refresh(signal?: AbortSignal): Promise<RefreshOutcome>;
+    private run;
+    /** Never rejects: both callers, a notification and the queue, would leave a rejection unhandled. */
+    private refreshOnce;
+    private listAndPublish;
+    /** Whether `generation` is still the live one of a mount that has not been disposed. */
+    private live;
+    /**
+     * Replaces the published tools with `catalog`'s. Each tool is one `provideTool` effect holding its
+     * registration and its grant, so withdrawing it releases both. A name another tool in this layer
+     * already holds cannot be registered; that tool is returned as unexposable.
+     */
+    private publish;
+    private report;
+    /** Closes the connection; the published tools go with the mount's other effects. */
+    dispose(): Promise<void>;
+}
+export {};

package/dist/plugins/mcp/names.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lagent names for MCP tools: `mcp__<server>__<tool>`. The MCP spec allows `A-Z a-z 0-9 _ - .` and
+ * up to 128 characters in a tool name; OpenAI function names allow `A-Z a-z 0-9 _ -` and at most 64.
+ * A remote name is mapped onto the narrower set, never truncated or hashed: the model, the journal
+ * and the policy lists all read it, so it must stay readable and identical across restarts.
+ */
+/** The longest tool name every supported provider accepts. */
+export declare const MAX_TOOL_NAME_LENGTH = 64;
+/**
+ * A server name: in the narrow set already, never containing `__`, and neither starting nor ending
+ * with `_`. The first `__` after `mcp__` then always ends the server name, so two servers can never
+ * map tools onto the same lagent name: `docs` with `_search` and `docs_` with `search` would both
+ * be `mcp__docs___search`.
+ */
+export declare const SERVER_NAME: RegExp;
+/** An alias for a tool segment, which must already be in the narrow set. */
+export declare const TOOL_SEGMENT: RegExp;
+/** The tool segment a remote name maps to: every character outside the narrow set becomes `_`. */
+export declare const toolSegment: (remoteName: string) => string;
+/**
+ * The lagent name of a server's tool, for a tool policy's lists and host UIs. `alias`
+ * replaces the tool segment only; the server prefix always applies, so an alias never lands on a
+ * builtin. The result may be longer than {@link MAX_TOOL_NAME_LENGTH}, which makes it unexposable.
+ */
+export declare const mcpToolName: (server: string, remoteName: string, alias?: string) => string;

package/dist/plugins/mcp/render.d.ts

@@ -0,0 +1,29 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolResultPayload } from '../../models/index.js';
+/** Said when nothing is left for the model because every item was addressed to the user. */
+export declare const USER_ONLY_OUTPUT = "The tool returned content addressed to the user only; nothing in it is for you.";
+export declare const EMPTY_OUTPUT = "The tool returned no content.";
+/**
+ * The image types every provider lagent supports accepts as input: OpenAI takes PNG, JPEG, WebP
+ * and non-animated GIF. A part in any other type would be refused, and since the journal keeps it,
+ * every later request in the thread would be refused with it.
+ */
+export declare const MODEL_IMAGE_TYPES: ReadonlySet<string>;
+/** A MIME type as a part stores it: lowercased, and the common `image/jpg` as `image/jpeg`. */
+export declare const imageMediaType: (mimeType: string) => string;
+export type RenderOptions = {
+    readonly server: string;
+    readonly remoteName: string;
+    /** The most decoded bytes of non-text content the result keeps, for the model and the host. */
+    readonly maxContentBytes: number;
+};
+/**
+ * Renders a `tools/call` result as lagent's text-first payload. `output` is the canonical text;
+ * images become content parts within the byte budget; items whose audience excludes the assistant
+ * go to `metadata` for hosts and never reach the model. A result is not checked against the tool's
+ * output schema.
+ */
+export declare function renderCallResult(result: CallToolResult, options: RenderOptions): ToolResultPayload;
+/** The size of base64 data once decoded. */
+export declare function decodedBytes(base64: string): number;
+export declare function formatBytes(bytes: number): string;

package/dist/plugins/mcp/slots.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The calls one server takes at once, in arrival order, shared by every thread its mount serves.
+ * A waiter whose signal aborts leaves the queue without ever holding a slot.
+ */
+export declare class CallSlots {
+    private active;
+    private readonly waiters;
+    private readonly limit;
+    constructor(limit: number);
+    /** Resolves with the slot's release; rejects with the signal's reason if it aborts first. */
+    acquire(signal: AbortSignal): Promise<() => void>;
+    /** Calls queued for a slot. */
+    get waiting(): number;
+    private releaser;
+}

package/dist/plugins/mcp/stdio.d.ts

@@ -0,0 +1,49 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { type SpawnResult } from '../../sys/spawn.js';
+export type StdioServerOptions = {
+    readonly server: string;
+    readonly command: readonly [string, ...string[]];
+    readonly cwd: string;
+    readonly env: Readonly<Record<string, string>>;
+    /** The owner: aborting it stops the server's process group within the bound. */
+    readonly signal: AbortSignal;
+    readonly killGraceMs?: number;
+};
+/**
+ * The SDK's `Transport` over a stdio server spawned through `sys/spawn`, so the server and
+ * everything it starts lead a process group that never outlives lagent. The SDK's own stdio
+ * transport spawns outside that containment.
+ *
+ * stdout carries newline-delimited JSON-RPC and nothing else. stderr is diagnostics: it is read
+ * from the start, since an unread pipe would block the server, and only a bounded tail is kept,
+ * for the host's errors and the debug log.
+ */
+export declare class ContainedStdioTransport implements Transport {
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: <T extends JSONRPCMessage>(message: T) => void;
+    private spawned;
+    private readonly buffer;
+    private stderr;
+    private exit;
+    private closed;
+    /** `close` came before the process existed: the process is stopped as soon as it does. */
+    private closedEarly;
+    private readonly options;
+    constructor(options: StdioServerOptions);
+    /** The server's pid, which is also its process group's id, once started. */
+    get pid(): number | undefined;
+    /** The last of what the server wrote to stderr. */
+    get stderrTail(): string;
+    /** How the server's process ended, once it has. */
+    get exited(): SpawnResult | null;
+    start(): Promise<void>;
+    private receive;
+    send(message: JSONRPCMessage): Promise<void>;
+    /**
+     * The spec's stdio shutdown: close the server's input, give it one grace period to exit, then
+     * stop its whole group, SIGTERM then SIGKILL, within `sys/spawn`'s bound.
+     */
+    close(): Promise<void>;
+}

package/dist/plugins/mcp/tool.d.ts

@@ -0,0 +1,41 @@
+import type { Tool } from '../../loop/index.js';
+import type { InterruptionPolicy } from '../../models/index.js';
+import type { CatalogEntry } from './catalog.js';
+import type { McpConfig } from './config.js';
+import { type Generation } from './connection.js';
+import type { CallSlots } from './slots.js';
+/**
+ * The `_meta` key carrying a call's durable identity: the thread id, an opaque identifier with no
+ * meaning outside lagent's journal, and the `tool/call` sequence. Stable across a re-dispatch after
+ * a crash, so a server that chooses to can deduplicate; servers that do not know it ignore it.
+ */
+export declare const CALL_META_KEY = "work.leuduan.lagent/call";
+/** Told with the first result after a new session. */
+export declare const SESSION_RESET_NOTE = "The connection to this MCP server was re-established; any session state the server held may have been reset.";
+/** What a tool needs from the mount that published it. */
+export interface McpToolHost {
+    readonly server: string;
+    readonly config: Pick<McpConfig, 'maxCallSeconds' | 'callTimeoutSeconds' | 'maxContentBytes' | 'onInterrupted'>;
+    readonly slots: CallSlots;
+    /** The live generation, reconnecting once first if the last one went away. */
+    ready(signal: AbortSignal): Promise<Generation>;
+    /** The current catalog's entry under a lagent name. */
+    entry(name: string): CatalogEntry | undefined;
+    /** The note owed to the first result of `generation`, once. */
+    takeSessionNote(generation: Generation): string | null;
+    /** Ends a generation whose session the server no longer has. */
+    invalidate(generation: Generation): void;
+}
+/**
+ * What a re-dispatch may do with a call to `entry` after an interruption, by the mount's
+ * `onInterrupted`: `'report'` for every tool, the listed remote names for `{ rerun }`, and for
+ * `'annotations'` the server's own `readOnlyHint` or `idempotentHint`, trusted only because the
+ * mount asked for that.
+ */
+export declare function interruptionPolicyOf(onInterrupted: McpConfig['onInterrupted'], entry: Pick<CatalogEntry, 'remoteName' | 'definition'>): InterruptionPolicy;
+/**
+ * One MCP tool as a lagent tool, bound to the definition it was published with. Arguments go to
+ * the server unchanged: validating them is the server's job. The mount's `onInterrupted` decides
+ * what a re-dispatch may do; the server's annotations count only when the mount says so.
+ */
+export declare const mcpTool: (host: McpToolHost, entry: CatalogEntry) => Tool;

package/dist/plugins/providers/anthropic.d.ts

@@ -0,0 +1,175 @@
+import type { ContentPart, ConversationMessage, FailureClassification, JsonObject, LLMStreamChunk, ModelResponse, ResponseFinish, ThinkingEffort, ToolChoice, ToolSpec } from '../../llm/index.js';
+import type { DeepReadonly } from '../../util/json.js';
+/** One Messages content block, as JSON. */
+export type AnthropicBlock = Record<string, unknown>;
+/** One Messages turn. Consecutive messages of one role are one turn. */
+export type AnthropicMessage = {
+    role: 'user' | 'assistant';
+    content: AnthropicBlock[];
+};
+/**
+ * A call id as Messages accepts it: an id already in its alphabet as it is, any other (another
+ * provider's, such as Responses' `call_…|fc_…`) as a digest of itself. Deterministic, so a call and
+ * its result agree; never reversed, since only ids Messages wrote come back.
+ */
+export declare const anthropicToolUseId: (id: string) => string;
+/**
+ * The state an assistant message keeps for replay: its message id, and its thinking blocks with
+ * their signatures, which the API verifies and which only the model that wrote them can read.
+ */
+export type AnthropicReplayState = {
+    id: string;
+    thinking: AnthropicBlock[];
+};
+/**
+ * A request's conversation as Messages turns.
+ *
+ * - A `tool` message is a `tool_result` block in the next user turn, and results lead their turn,
+ *   as the API requires.
+ * - A `developer` or `system` message is user text inside `<system-reminder>`: Messages has no role
+ *   for a notice in the conversation.
+ * - An assistant message replays its thinking first, from state `replayTag` wrote; another model's
+ *   is dropped. A malformed tool call goes back with empty input, since Messages takes an object.
+ * - Empty text is dropped (the API refuses it), and a message left with nothing is dropped too.
+ */
+export declare function toAnthropicMessages(messages: readonly DeepReadonly<ConversationMessage>[], options: {
+    readonly provider: string;
+    readonly replayTag: string;
+}): AnthropicMessage[];
+/**
+ * Content parts as Messages blocks: images by URL or base64, files as documents (a PDF by URL or
+ * base64, plain text inline). A file the provider holds by id is refused: that is another API's
+ * upload, which Messages cannot name.
+ */
+export declare function contentBlocks(content: readonly DeepReadonly<ContentPart>[], provider: string): AnthropicBlock[];
+/** Tool specs as Messages tools; the schema goes as it stands. */
+export declare const toAnthropicTools: (tools: readonly DeepReadonly<ToolSpec>[]) => AnthropicBlock[];
+/** A request's tool choice, with parallel calls off when the request says so. */
+export declare function toAnthropicToolChoice(choice: DeepReadonly<ToolChoice>, parallel: boolean): AnthropicBlock;
+/**
+ * The thinking fields for an effort: none sent for none named, so the model's own default stands;
+ * `none` disables thinking; any other is adaptive thinking at that effort, with its text summarized,
+ * since some models omit thinking text unless asked.
+ */
+export declare function anthropicThinking(effort: ThinkingEffort | undefined): JsonObject;
+/** One raw Messages stream event, as the API streams it. Only the fields read here are typed. */
+export type AnthropicStreamEvent = {
+    type: 'message_start';
+    message: {
+        id: string;
+        model: string;
+        usage?: RawUsage;
+    };
+} | {
+    type: 'content_block_start';
+    index: number;
+    content_block: AnthropicBlock;
+} | {
+    type: 'content_block_delta';
+    index: number;
+    delta: AnthropicBlock;
+} | {
+    type: 'content_block_stop';
+    index: number;
+} | {
+    type: 'message_delta';
+    delta: {
+        stop_reason?: string | null;
+        stop_sequence?: string | null;
+    };
+    usage?: RawUsage;
+} | {
+    type: 'message_stop';
+} | {
+    type: 'ping';
+} | {
+    type: 'error';
+    error: {
+        type?: string;
+        message?: string;
+    };
+};
+type RawUsage = {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    output_tokens_details?: {
+        thinking_tokens?: number | null;
+    } | null;
+};
+/** A failure the API reported, from a rejected request (with its status) or an `error` stream event. */
+export declare class AnthropicAPIError extends Error {
+    readonly errorType: string | undefined;
+    readonly status?: number;
+    readonly headers?: Headers;
+    constructor(
+    /** The API's error type, such as `overloaded_error`. */
+    errorType: string | undefined, message: string, 
+    /** The HTTP status of a rejected request; absent for a failure inside the stream. */
+    status?: number, headers?: Headers);
+}
+/**
+ * Whether a failure says the request exceeded the model's context window. The API names no code of
+ * its own for it, only `invalid_request_error`, so its wording decides, as `adapters.md` allows
+ * where a provider has no code: "prompt is too long", which a gateway may wrap in its own prose.
+ */
+export declare const isAnthropicOverflow: (error: AnthropicAPIError) => boolean;
+/**
+ * The kind of a failure from a Messages client, by structured evidence only: the API's error type
+ * where it names a kind (a `billing_error` is `quota` whatever status carries it), else the HTTP
+ * status as every protocol reads one (`statusKind`, 529 being Anthropic's overloaded). A failure
+ * inside the stream has no status, so its type is all there is; else socket codes.
+ * `retryAfterMs` comes from the `retry-after-ms` or `retry-after` header.
+ */
+export declare function classifyAnthropicFailure(error: unknown, now?: number): FailureClassification;
+/** `end_turn`, `tool_use` and `stop_sequence` finish a message; the output cap and window are `length`. */
+export declare const anthropicFinish: (stopReason: string) => ResponseFinish;
+export interface MessagesAssemblyOptions {
+    /** The tag the message's state is written under, which replays it. */
+    readonly replayTag: string;
+    /** The name a tool call reaches lagent under, from the name the model used. */
+    readonly toolName?: (name: string) => string;
+}
+/**
+ * One streamed Messages message, folded event by event. It owns the rule that a message is complete
+ * only once its stop reason arrived and `message_stop` followed, and hands back what arrived for a
+ * cut-off one: text and reasoning, never a tool call or state.
+ */
+export declare class MessagesAssembly {
+    private id;
+    private model;
+    private readonly blocks;
+    private stopReason;
+    private stopSequence;
+    private stopped;
+    private usage;
+    private readonly options;
+    constructor(options: MessagesAssemblyOptions);
+    /** Folds one event and returns the chunk it adds, if any. An `error` event throws. */
+    apply(event: AnthropicStreamEvent): LLMStreamChunk | null;
+    /** Whether the message is complete: its stop reason arrived, and `message_stop` after it. */
+    get complete(): boolean;
+    /** The message's stop reason, once one arrived. */
+    get stop(): string | null;
+    private applyDelta;
+    private addUsage;
+    /**
+     * Usage as lagent counts it: Anthropic's `input_tokens` excludes the cached ones, so input is the
+     * sum of uncached, cache-read and cache-written tokens, with the cached ones also kept apart.
+     */
+    private normalizedUsage;
+    private ordered;
+    private text;
+    private reasoning;
+    /** What the message says about itself: observed, never sent back. */
+    metadata(): JsonObject;
+    /** The settled message, once complete; `undefined` before. */
+    settle(): ModelResponse | undefined;
+    /** What arrived so far: text and reasoning, never a tool call nobody finished asking for. */
+    partial(): {
+        message: ConversationMessage;
+        providerMetadata: JsonObject;
+    };
+}
+export {};

package/dist/plugins/providers/anthropicMessages.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import type { LLMClient, ModelRequest, StreamingLLMResponse } from '../../llm/index.js';
+import { type AnthropicStreamEvent } from './anthropic.js';
+import { type CallHeaders } from './stream.js';
+declare const AnthropicMessagesConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodString;
+    streamIdleTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    authorization: z.ZodDefault<z.ZodEnum<{
+        "x-api-key": "x-api-key";
+        bearer: "bearer";
+    }>>;
+    defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    thinkingEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>;
+    maxOutputTokens: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+type AnthropicMessagesConfig = z.input<typeof AnthropicMessagesConfigSchema>;
+type ParsedConfig = z.output<typeof AnthropicMessagesConfigSchema>;
+type RequestPayload = Record<string, unknown>;
+/**
+ * The Anthropic Messages adapter for a provider whose models answer on Messages (Go or Copilot),
+ * which names itself as `name`. It speaks over `fetch` with no SDK: the request goes as
+ * JSON and the server-sent events are read as they arrive, so nothing reads the process environment.
+ * `headers` adds headers to each call, over the client's own; it is the client's owner's, and
+ * nothing subclasses the client to say it.
+ *
+ * The prompt goes as `system` blocks, notices as user text, and thinking replays from
+ * `provider_state` to the model that wrote it. Provider-executed tools and non-text response
+ * formats are refused.
+ */
+export declare class AnthropicMessagesLLMClient implements LLMClient {
+    readonly providerName: string;
+    protected readonly config: ParsedConfig;
+    private readonly fetchImpl;
+    private readonly callHeaders;
+    constructor(config: AnthropicMessagesConfig & {
+        name: string;
+        headers?: CallHeaders;
+        fetch?: typeof globalThis.fetch;
+    });
+    /** The tag replayable state is written and read under: one model's signed thinking is no other's. */
+    private replayTag;
+    /** The output cap of a request: its own, else the one configured for its model. */
+    private maxOutputTokens;
+    /** The headers of one call: the client's own, then the owner's for this call and its mapped request. */
+    private headers;
+    buildRequest(call: ModelRequest): RequestPayload;
+    chat(call: ModelRequest): Promise<StreamingLLMResponse>;
+    private open;
+    /** `error` as the overflow it is, when its fields say so, else unchanged. */
+    classified(error: unknown): unknown;
+}
+/**
+ * The events of a server-sent event stream, each `data` payload parsed as JSON. Lines end in CR, LF
+ * or CRLF, as the format allows; a CR at the end of a chunk waits for the next, which may bring its
+ * LF. The payload's own `type` names the event, so `event:` lines, ids and comments are not read.
+ */
+export declare function serverSentEvents(body: AsyncIterable<Uint8Array>): AsyncGenerator<AnthropicStreamEvent>;
+export {};