@roll-agent/runtime 0.1.0

package/dist/approval/approval-gate.d.ts

@@ -0,0 +1,11 @@
+export interface ApprovalDecision {
+    readonly approved: boolean;
+    readonly reason?: string;
+}
+export declare class ApprovalGate {
+    private readonly pending;
+    request(approvalId: string): Promise<ApprovalDecision>;
+    resolve(approvalId: string, decision: ApprovalDecision): boolean;
+    abortAll(reason?: string): void;
+    get pendingCount(): number;
+}

package/dist/approval/approval-gate.js

@@ -0,0 +1 @@
+export class ApprovalGate{pending=new Map;request(e){return new Promise(n=>{this.pending.set(e,n)})}resolve(e,n){const t=this.pending.get(e);return!!t&&(this.pending.delete(e),t(n),!0)}abortAll(e="aborted"){for(const n of this.pending.values())n({approved:!1,reason:e});this.pending.clear()}get pendingCount(){return this.pending.size}}

package/dist/engine/agent-session.d.ts

@@ -0,0 +1,34 @@
+import { type ModelMessage } from "ai";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { SessionEvent } from "../types/events.ts";
+import type { ToolPolicy } from "../types/policy.ts";
+import { type AgentToolSource } from "../tool-bridge/build-tools.ts";
+export interface AgentSessionOptions {
+    readonly id: string;
+    readonly model: LanguageModelV3;
+    readonly sources: readonly AgentToolSource[];
+    readonly maxSteps: number;
+    readonly policy?: ToolPolicy;
+    readonly initialMessages?: readonly ModelMessage[];
+    readonly onPersist?: (messages: readonly ModelMessage[]) => void;
+}
+export declare class AgentSession {
+    readonly id: string;
+    private readonly model;
+    private readonly maxSteps;
+    private readonly messages;
+    private readonly onPersist;
+    private readonly gate;
+    private readonly tools;
+    private readonly registry;
+    private emit;
+    private activeTurn;
+    constructor(options: AgentSessionOptions);
+    send(input: string): AsyncIterable<SessionEvent>;
+    private runTurn;
+    private requestApproval;
+    approve(approvalId: string): boolean;
+    reject(approvalId: string, reason?: string): boolean;
+    getMessages(): readonly ModelMessage[];
+    abort(): void;
+}

package/dist/engine/agent-session.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";import{stepCountIs as t,streamText as s}from"ai";import{buildAgentToolset as o}from"../tool-bridge/build-tools.js";import{readIsError as r}from"../tool-bridge/normalize-result.js";import{ApprovalGate as a}from"../approval/approval-gate.js";import{AsyncEventQueue as i}from"./event-queue.js";function l(e){return e instanceof Error?e.message:String(e)}function n(e){return{...void 0!==e.inputTokens?{inputTokens:e.inputTokens}:{},...void 0!==e.outputTokens?{outputTokens:e.outputTokens}:{},...void 0!==e.totalTokens?{totalTokens:e.totalTokens}:{}}}export class AgentSession{id;model;maxSteps;messages;onPersist;gate=new a;tools;registry;emit;activeTurn;constructor(e){this.id=e.id,this.model=e.model,this.maxSteps=e.maxSteps,this.messages=e.initialMessages?[...e.initialMessages]:[],this.onPersist=e.onPersist;const t=o(e.sources,{...e.policy?{policy:e.policy}:{},requestApproval:e=>this.requestApproval(e)});this.tools=t.tools,this.registry=t.registry}async*send(e){if(this.activeTurn)throw new Error("session already has an active turn");const t=new i;this.emit=e=>t.push(e);const s=this.messages.length;this.messages.push({role:"user",content:e});const o={abortController:new AbortController,aborted:!1};this.activeTurn=o,this.runTurn(t,o,s).catch(e=>{t.push({type:"error",stage:"execute",message:l(e)}),t.close()});try{for await(const e of t)yield e}finally{this.activeTurn===o&&this.abort(),void 0!==this.emit&&(this.emit=void 0)}}async runTurn(o,a,i){try{o.push({type:"message-start",messageId:e()});const p=s({model:this.model,messages:this.messages,tools:this.tools,stopWhen:t(this.maxSteps),abortSignal:a.abortController.signal});let u,m,h="";for await(const e of p.fullStream)switch(e.type){case"text-delta":h+=e.text,o.push({type:"text-delta",delta:e.text});break;case"tool-call":{const t=this.registry.resolve(e.toolName);o.push({type:"tool-call",toolCallId:e.toolCallId,agentName:t?.agentName??e.toolName,toolName:t?.toolName??e.toolName,input:e.input});break}case"tool-result":{const t=this.registry.resolve(e.toolName);o.push({type:"tool-result",toolCallId:e.toolCallId,agentName:t?.agentName??e.toolName,toolName:t?.toolName??e.toolName,output:e.output,isError:r(e.output)});break}case"tool-error":{const t=this.registry.resolve(e.toolName);o.push({type:"tool-result",toolCallId:e.toolCallId,agentName:t?.agentName??e.toolName,toolName:t?.toolName??e.toolName,output:l(e.error),isError:!0});break}case"finish-step":o.push({type:"step-finish",finishReason:e.finishReason,usage:n(e.usage)});break;case"finish":u=n(e.totalUsage);break;case"error":o.push({type:"error",stage:"execute",message:l(e.error)});break;case"abort":a.aborted=!0}if(a.aborted||a.abortController.signal.aborted)return this.messages.splice(i),void o.push({type:"error",stage:"execute",message:"aborted"});try{m=(await p.response).messages}catch(e){return this.messages.splice(i),void o.push({type:"error",stage:"execute",message:l(e)})}this.messages.push(...m),this.onPersist?.(this.messages.slice(i)),o.push({type:"message-finish",text:h,...u?{totalUsage:u}:{}})}catch(e){this.messages.splice(i),o.push({type:"error",stage:"execute",message:l(e)})}finally{this.activeTurn===a&&(this.activeTurn=void 0),o.close()}}requestApproval(t){const s=e(),o=this.gate.request(s);return void 0===this.emit?(this.gate.resolve(s,{approved:!1,reason:"approval event could not be delivered"}),o):(this.emit({type:"confirmation-required",approvalId:s,agentName:t.agentName,toolName:t.toolName,input:t.input,...t.reason?{reason:t.reason}:{}}),o)}approve(e){return this.gate.resolve(e,{approved:!0})}reject(e,t){return this.gate.resolve(e,{approved:!1,...t?{reason:t}:{}})}getMessages(){return this.messages}abort(){this.activeTurn&&(this.activeTurn.aborted=!0),this.gate.abortAll(),this.activeTurn?.abortController.abort()}}

package/dist/engine/conversation-engine.d.ts

@@ -0,0 +1,48 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import { McpClientManager } from "@roll-agent/core/mcp/client-manager";
+import type { RollConfig } from "@roll-agent/core/config/schema";
+import type { RegisteredAgent } from "@roll-agent/core/types/agent";
+import type { AgentToolSource } from "../tool-bridge/build-tools.ts";
+import type { ToolPolicy } from "../types/policy.ts";
+import type { ThreadStore } from "../store/thread-store.ts";
+import { AgentSession } from "./agent-session.ts";
+export interface ConversationEngineOptions {
+    readonly config: RollConfig;
+    readonly agents?: readonly RegisteredAgent[];
+    readonly model?: LanguageModelV3;
+    readonly sources?: readonly AgentToolSource[];
+    readonly clientManager?: McpClientManager;
+    readonly store?: ThreadStore;
+    readonly policy?: ToolPolicy;
+    readonly maxSteps?: number;
+    readonly onAgentBootstrapIssue?: (issue: AgentBootstrapIssue) => void;
+}
+export interface CreateSessionInput {
+    readonly title?: string;
+}
+export interface AgentBootstrapIssue {
+    readonly agentName: string;
+    readonly message: string;
+}
+export declare class ConversationEngine {
+    private readonly config;
+    private readonly clientManager;
+    private readonly store;
+    private readonly policy;
+    private readonly maxSteps;
+    private readonly explicitAgents;
+    private readonly explicitModel;
+    private readonly explicitSources;
+    private readonly onAgentBootstrapIssue;
+    private ready;
+    constructor(options: ConversationEngineOptions);
+    createSession(input?: CreateSessionInput): Promise<AgentSession>;
+    resumeSession(threadId: string): Promise<AgentSession>;
+    private buildSession;
+    private ensureReady;
+    private bootstrap;
+    private resolveModel;
+    private resolveProviderName;
+    private resolveModelName;
+    dispose(): Promise<void>;
+}

package/dist/engine/conversation-engine.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";import{McpClientManager as t}from"@roll-agent/core/mcp/client-manager";import{createProviderModel as s}from"@roll-agent/core/llm/providers";import{AgentStore as o}from"@roll-agent/core/registry/store";import{resolveTransportWithDevSpawnSpec as i}from"@roll-agent/core/registry/dev-spawn";import{normalizeListedTools as r}from"@roll-agent/core/cli/utils/agent-tools";import{getAgentEnv as n}from"@roll-agent/core/config/helpers";import{AgentSession as l}from"./agent-session.js";const a=16;function c(e){if("object"!=typeof e||null===e||!("annotations"in e))return;const t=e.annotations;if("object"!=typeof t||null===t)return;const s={};return"readOnlyHint"in t&&"boolean"==typeof t.readOnlyHint&&(s.readOnlyHint=t.readOnlyHint),"destructiveHint"in t&&"boolean"==typeof t.destructiveHint&&(s.destructiveHint=t.destructiveHint),void 0===s.readOnlyHint&&void 0===s.destructiveHint?void 0:s}export class ConversationEngine{config;clientManager;store;policy;maxSteps;explicitAgents;explicitModel;explicitSources;onAgentBootstrapIssue;ready;constructor(e){this.config=e.config,this.clientManager=e.clientManager??new t,this.store=e.store,this.policy=e.policy,this.maxSteps=e.maxSteps??a,this.explicitAgents=e.agents,this.explicitModel=e.model,this.explicitSources=e.sources,this.onAgentBootstrapIssue=e.onAgentBootstrapIssue}async createSession(t={}){const s=await this.ensureReady(),o=this.store?this.store.createThread({...t.title?{title:t.title}:{},model:this.resolveModelName()}):e();return this.buildSession(s,o,[])}async resumeSession(e){if(!this.store)throw new Error("resumeSession requires a ThreadStore");if(!this.store.hasThread(e))throw new Error(`Thread "${e}" 不存在`);const t=await this.ensureReady();return this.buildSession(t,e,this.store.getMessages(e))}buildSession(e,t,s){const o=this.store;return new l({id:t,model:e.model,sources:e.sources,maxSteps:this.maxSteps,...this.policy?{policy:this.policy}:{},initialMessages:s,...o?{onPersist:e=>o.appendMessages(t,e)}:{}})}ensureReady(){return this.ready||(this.ready=this.bootstrap()),this.ready}async bootstrap(){const e=this.explicitModel??this.resolveModel();if(this.explicitSources)return{model:e,sources:this.explicitSources};const t=this.explicitAgents??new o(this.config.agents.dataDir).list(),s=[];for(const o of t)try{const t=i(o),l=n(this.config,o.skill.name),a=await this.clientManager.connect(o.skill.name,t,o.installPath,{samplingModel:e,...l?{env:l}:{}}),d=(await a.listTools()).tools,h=r(d).map((e,t)=>({tool:e,annotations:c(d[t])}));s.push({agentName:o.skill.name,client:a,tools:h})}catch(e){this.onAgentBootstrapIssue?.({agentName:o.skill.name,message:e instanceof Error?e.message:String(e)})}return{model:e,sources:s}}resolveModel(){const e=this.resolveProviderName(),t=this.resolveModelName(),o=this.config.llm.providers[e];if(!o)throw new Error(`LLM provider "${e}" 未配置`);return s(e,t,o.apiKey,o.baseUrl)}resolveProviderName(){return this.config.runtime.provider??this.config.llm.defaultProvider}resolveModelName(){return this.config.runtime.model??this.config.llm.defaultModel}async dispose(){await this.clientManager.disconnectAll()}}

package/dist/engine/event-queue.d.ts

@@ -0,0 +1,8 @@
+export declare class AsyncEventQueue<T> {
+    private readonly buffer;
+    private resolver;
+    private closed;
+    push(item: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/engine/event-queue.js

@@ -0,0 +1 @@
+export class AsyncEventQueue{buffer=[];resolver;closed=!1;push(e){if(!this.closed)if(this.resolver){const s=this.resolver;this.resolver=void 0,s({value:e,done:!1})}else this.buffer.push(e)}close(){if(!this.closed&&(this.closed=!0,this.resolver)){const e=this.resolver;this.resolver=void 0,e({value:void 0,done:!0})}}async*[Symbol.asyncIterator](){for(;;){if(this.buffer.length>0){yield this.buffer.shift();continue}if(this.closed)return;const e=await new Promise(e=>{this.resolver=e});if(e.done)return;yield e.value}}}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { ConversationEngine } from "./engine/conversation-engine.ts";
+export type { AgentBootstrapIssue, ConversationEngineOptions, CreateSessionInput, } from "./engine/conversation-engine.ts";
+export { AgentSession } from "./engine/agent-session.ts";
+export type { AgentSessionOptions } from "./engine/agent-session.ts";
+export { buildAgentToolset } from "./tool-bridge/build-tools.ts";
+export type { AgentToolSource, SourceTool, ApprovalRequest, ToolBridgeContext, BuiltToolset, } from "./tool-bridge/build-tools.ts";
+export { ToolRegistry } from "./tool-bridge/naming.ts";
+export type { ToolRoute } from "./tool-bridge/naming.ts";
+export { normalizeToolResult } from "./tool-bridge/normalize-result.ts";
+export type { NormalizedToolResult } from "./tool-bridge/normalize-result.ts";
+export { ThreadStore, defaultThreadsDir, expandTilde } from "./store/thread-store.ts";
+export type { ThreadRecord, CreateThreadInput } from "./store/thread-store.ts";
+export { DefaultToolPolicy } from "./policy/default-policy.ts";
+export { ConfigurableToolPolicy } from "./policy/configurable-policy.ts";
+export type { ConfigurableToolPolicyOptions, ToolApprovalDefault, ToolApprovalOverrideAction, } from "./policy/configurable-policy.ts";
+export type { ToolPolicy, ToolPolicyContext, PolicyDecision, PolicyAction, ToolAnnotations, } from "./types/policy.ts";
+export { ApprovalGate } from "./approval/approval-gate.ts";
+export type { ApprovalDecision } from "./approval/approval-gate.ts";
+export { RuntimeServer } from "./server/runtime-server.ts";
+export { createStdioConnection } from "./server/transport/stdio.ts";
+export { RpcMethod, EVENT_NOTIFICATION, isRequest } from "./server/protocol.ts";
+export type { JsonRpcConnection, JsonRpcMessage, JsonRpcRequest, JsonRpcNotification, JsonRpcId, } from "./server/protocol.ts";
+export type { SessionEvent, SessionEventStage, SessionTokenUsage } from "./types/events.ts";

package/dist/index.js

@@ -0,0 +1 @@
+export{ConversationEngine}from"./engine/conversation-engine.js";export{AgentSession}from"./engine/agent-session.js";export{buildAgentToolset}from"./tool-bridge/build-tools.js";export{ToolRegistry}from"./tool-bridge/naming.js";export{normalizeToolResult}from"./tool-bridge/normalize-result.js";export{ThreadStore,defaultThreadsDir,expandTilde}from"./store/thread-store.js";export{DefaultToolPolicy}from"./policy/default-policy.js";export{ConfigurableToolPolicy}from"./policy/configurable-policy.js";export{ApprovalGate}from"./approval/approval-gate.js";export{RuntimeServer}from"./server/runtime-server.js";export{createStdioConnection}from"./server/transport/stdio.js";export{RpcMethod,EVENT_NOTIFICATION,isRequest}from"./server/protocol.js";

package/dist/policy/configurable-policy.d.ts

@@ -0,0 +1,17 @@
+import type { PolicyDecision, ToolPolicy, ToolPolicyContext } from "../types/policy.ts";
+export declare const TOOL_APPROVAL_DEFAULTS: readonly ["guarded", "auto", "deny"];
+export type ToolApprovalDefault = (typeof TOOL_APPROVAL_DEFAULTS)[number];
+export declare const TOOL_APPROVAL_OVERRIDE_ACTIONS: readonly ["auto", "confirm", "deny"];
+export type ToolApprovalOverrideAction = (typeof TOOL_APPROVAL_OVERRIDE_ACTIONS)[number];
+export interface ConfigurableToolPolicyOptions {
+    readonly defaultMode?: ToolApprovalDefault;
+    readonly overrides?: Readonly<Record<string, ToolApprovalOverrideAction>>;
+    readonly fallback?: ToolPolicy;
+}
+export declare class ConfigurableToolPolicy implements ToolPolicy {
+    private readonly defaultMode;
+    private readonly overrides;
+    private readonly fallback;
+    constructor(options?: ConfigurableToolPolicyOptions);
+    check(context: ToolPolicyContext): PolicyDecision;
+}

package/dist/policy/configurable-policy.js

@@ -0,0 +1 @@
+import{DefaultToolPolicy as o}from"./default-policy.js";export const TOOL_APPROVAL_DEFAULTS=["guarded","auto","deny"];export const TOOL_APPROVAL_OVERRIDE_ACTIONS=["auto","confirm","deny"];function e(o){return`${o.agentName}.${o.toolName}`}function t(o){return"auto"===o?{action:"allow"}:"confirm"===o?{action:"confirm",reason:"配置要求确认"}:{action:"deny",reason:"配置拒绝执行"}}export class ConfigurableToolPolicy{defaultMode;overrides;fallback;constructor(e={}){this.defaultMode=e.defaultMode??"guarded",this.overrides=e.overrides??{},this.fallback=e.fallback??new o}check(o){const a=this.overrides[e(o)];return void 0!==a?t(a):"auto"===this.defaultMode?!0===o.annotations?.destructiveHint?{action:"confirm",reason:"破坏性操作"}:{action:"allow"}:"deny"===this.defaultMode?{action:"deny",reason:"默认策略拒绝执行"}:this.fallback.check(o)}}

package/dist/policy/default-policy.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyDecision, ToolPolicy, ToolPolicyContext } from "../types/policy.ts";
+export declare class DefaultToolPolicy implements ToolPolicy {
+    check(context: ToolPolicyContext): PolicyDecision;
+}

package/dist/policy/default-policy.js

@@ -0,0 +1 @@
+const e=["send","write","delete","remove","update","create","post","submit","reply","pay","insert","drop","set","put","patch","add","edit","open","select","filter","exchange","cancel","approve","click","navigate","fill","type","press","upload","scroll"],t=["get","list","read","search","fetch","query","find","show","describe","inspect","status","check","count","view","load","scan","resolve","validate","format","preview","diagnostic","snapshot"],n=new Set(e),o=new Set(t);function a(e){return e.toLowerCase().split(/[_\-\s]+/).map(e=>e.trim()).filter(e=>e.length>0)}function r(e,t){return e.some(e=>t.has(e))}export class DefaultToolPolicy{check(e){const{annotations:t}=e,s=a(e.toolName);return!0===t?.destructiveHint?{action:"confirm",reason:"破坏性操作"}:r(s,n)?{action:"confirm",reason:"写/发送类操作"}:!0===t?.readOnlyHint||r(s,o)?{action:"allow"}:{action:"confirm",reason:"未知操作，默认需确认"}}}

package/dist/server/protocol.d.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+export type JsonRpcId = number | string;
+export interface JsonRpcRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: JsonRpcId;
+    readonly method: string;
+    readonly params?: unknown;
+}
+export interface JsonRpcNotification {
+    readonly jsonrpc: "2.0";
+    readonly method: string;
+    readonly params?: unknown;
+}
+export interface JsonRpcSuccessResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: JsonRpcId;
+    readonly result: unknown;
+}
+export interface JsonRpcErrorResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: JsonRpcId | null;
+    readonly error: {
+        readonly code: number;
+        readonly message: string;
+    };
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccessResponse | JsonRpcErrorResponse;
+export interface JsonRpcConnection {
+    send(message: JsonRpcMessage): void;
+    onMessage(handler: (message: JsonRpcMessage) => void): void;
+    onClose(handler: () => void): void;
+    close(): void;
+}
+export declare const RpcMethod: {
+    readonly Create: "session.create";
+    readonly Resume: "session.resume";
+    readonly Send: "session.send";
+    readonly Approve: "session.approve";
+    readonly Reject: "session.reject";
+    readonly Abort: "session.abort";
+    readonly Messages: "session.messages";
+};
+export declare const EVENT_NOTIFICATION = "session.event";
+export declare const createParamsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+}, {
+    title?: string | undefined;
+}>;
+export declare const resumeParamsSchema: z.ZodObject<{
+    threadId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    threadId: string;
+}, {
+    threadId: string;
+}>;
+export declare const sendParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+    sessionId: string;
+}, {
+    input: string;
+    sessionId: string;
+}>;
+export declare const approveParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    approvalId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    approvalId: string;
+    sessionId: string;
+}, {
+    approvalId: string;
+    sessionId: string;
+}>;
+export declare const rejectParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    approvalId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    approvalId: string;
+    sessionId: string;
+    reason?: string | undefined;
+}, {
+    approvalId: string;
+    sessionId: string;
+    reason?: string | undefined;
+}>;
+export declare const abortParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+export declare const messagesParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+export declare function isRequest(message: JsonRpcMessage): message is JsonRpcRequest;

package/dist/server/protocol.js

@@ -0,0 +1 @@
+import{z as s}from"zod";export const RpcMethod={Create:"session.create",Resume:"session.resume",Send:"session.send",Approve:"session.approve",Reject:"session.reject",Abort:"session.abort",Messages:"session.messages"};export const EVENT_NOTIFICATION="session.event";export const createParamsSchema=s.object({title:s.string().optional()});export const resumeParamsSchema=s.object({threadId:s.string()});export const sendParamsSchema=s.object({sessionId:s.string(),input:s.string()});export const approveParamsSchema=s.object({sessionId:s.string(),approvalId:s.string()});export const rejectParamsSchema=s.object({sessionId:s.string(),approvalId:s.string(),reason:s.string().optional()});export const abortParamsSchema=s.object({sessionId:s.string()});export const messagesParamsSchema=s.object({sessionId:s.string()});export function isRequest(s){return"method"in s&&"id"in s}

package/dist/server/runtime-server.d.ts

@@ -0,0 +1,12 @@
+import type { ConversationEngine } from "../engine/conversation-engine.ts";
+import { type JsonRpcConnection } from "./protocol.ts";
+export declare class RuntimeServer {
+    private readonly engine;
+    private readonly connection;
+    private readonly sessions;
+    constructor(engine: ConversationEngine, connection: JsonRpcConnection);
+    abortAll(): void;
+    private handleMessage;
+    private requireSession;
+    private dispatch;
+}

package/dist/server/runtime-server.js

@@ -0,0 +1 @@
+import{EVENT_NOTIFICATION as s,RpcMethod as e,abortParamsSchema as n,approveParamsSchema as t,createParamsSchema as r,isRequest as o,messagesParamsSchema as i,rejectParamsSchema as a,resumeParamsSchema as c,sendParamsSchema as d}from"./protocol.js";function h(s){return s instanceof Error?s.message:String(s)}export class RuntimeServer{engine;connection;sessions=new Map;constructor(s,e){this.engine=s,this.connection=e,this.connection.onMessage(s=>this.handleMessage(s))}abortAll(){for(const s of this.sessions.values())s.abort();this.sessions.clear()}handleMessage(s){o(s)&&this.dispatch(s).then(e=>{this.connection.send({jsonrpc:"2.0",id:s.id,result:e})}).catch(e=>{this.connection.send({jsonrpc:"2.0",id:s.id,error:{code:-32e3,message:h(e)}})})}requireSession(s){const e=this.sessions.get(s);if(!e)throw new Error(`Session "${s}" 不存在`);return e}async dispatch(o){switch(o.method){case e.Create:{const s=r.parse(o.params),e=await this.engine.createSession(s.title?{title:s.title}:{});return this.sessions.set(e.id,e),{sessionId:e.id}}case e.Resume:{const s=c.parse(o.params),e=await this.engine.resumeSession(s.threadId);return this.sessions.set(e.id,e),{sessionId:e.id}}case e.Send:{const e=d.parse(o.params),n=this.requireSession(e.sessionId);for await(const t of n.send(e.input))this.connection.send({jsonrpc:"2.0",method:s,params:{sessionId:e.sessionId,event:t}});return{status:"completed"}}case e.Approve:{const s=t.parse(o.params);return{resolved:this.requireSession(s.sessionId).approve(s.approvalId)}}case e.Reject:{const s=a.parse(o.params);return{resolved:this.requireSession(s.sessionId).reject(s.approvalId,s.reason)}}case e.Abort:{const s=n.parse(o.params);return this.requireSession(s.sessionId).abort(),{ok:!0}}case e.Messages:{const s=i.parse(o.params);return{messages:this.requireSession(s.sessionId).getMessages()}}default:throw new Error(`Unknown method: ${o.method}`)}}}

package/dist/server/transport/stdio.d.ts

@@ -0,0 +1,3 @@
+import type { Readable, Writable } from "node:stream";
+import type { JsonRpcConnection } from "../protocol.ts";
+export declare function createStdioConnection(input: Readable, output: Writable): JsonRpcConnection;

package/dist/server/transport/stdio.js

@@ -0,0 +1 @@
+import{createInterface as n}from"node:readline";function o(n){return"object"==typeof n&&null!==n&&"jsonrpc"in n&&"2.0"===n.jsonrpc}export function createStdioConnection(e,t){const r=[],s=[],c=n({input:e});return c.on("line",n=>{const e=n.trim();if(0===e.length)return;let t;try{t=JSON.parse(e)}catch{return}if(o(t))for(const n of r)n(t)}),c.on("close",()=>{for(const n of s)n()}),{send(n){t.write(`${JSON.stringify(n)}\n`)},onMessage(n){r.push(n)},onClose(n){s.push(n)},close(){c.close()}}}

package/dist/store/thread-store.d.ts

@@ -0,0 +1,30 @@
+import { type ModelMessage } from "ai";
+export interface ThreadRecord {
+    readonly id: string;
+    readonly title: string | undefined;
+    readonly model: string | undefined;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface CreateThreadInput {
+    readonly id?: string;
+    readonly title?: string;
+    readonly model?: string;
+}
+export declare function expandTilde(path: string): string;
+export declare function defaultThreadsDir(): string;
+export declare class ThreadStore {
+    private readonly db;
+    constructor(dir?: string);
+    private init;
+    createThread(input?: CreateThreadInput): string;
+    hasThread(id: string): boolean;
+    getThread(id: string): ThreadRecord | undefined;
+    listThreads(): ThreadRecord[];
+    countMessages(threadId: string): number;
+    updateTitle(threadId: string, title: string): void;
+    deleteThread(threadId: string): void;
+    appendMessages(threadId: string, messages: readonly ModelMessage[]): void;
+    getMessages(threadId: string): ModelMessage[];
+    close(): void;
+}

package/dist/store/thread-store.js

@@ -0,0 +1 @@
+import{existsSync as e,mkdirSync as t}from"node:fs";import{homedir as r}from"node:os";import{resolve as d}from"node:path";import{randomUUID as a}from"node:crypto";import{DatabaseSync as s}from"node:sqlite";import{modelMessageSchema as i}from"ai";const n=1;export function expandTilde(e){return e.startsWith("~/")?d(r(),e.slice(2)):e}export function defaultThreadsDir(){return d(r(),".roll-agent","threads")}function E(e){return{id:e.id,title:e.title??void 0,model:e.model??void 0,createdAt:e.created_at,updatedAt:e.updated_at}}export class ThreadStore{db;constructor(r=defaultThreadsDir()){const a=expandTilde(r);e(a)||t(a,{recursive:!0}),this.db=new s(d(a,"threads.db")),this.init()}init(){this.db.exec("PRAGMA foreign_keys = ON;"),this.db.exec(`CREATE TABLE IF NOT EXISTS threads (\n         id TEXT PRIMARY KEY,\n         title TEXT,\n         model TEXT,\n         created_at TEXT NOT NULL,\n         updated_at TEXT NOT NULL\n       );\n       CREATE TABLE IF NOT EXISTS messages (\n         thread_id TEXT NOT NULL,\n         idx INTEGER NOT NULL,\n         role TEXT NOT NULL,\n         content_json TEXT NOT NULL,\n         created_at TEXT NOT NULL,\n         PRIMARY KEY (thread_id, idx),\n         FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE\n       );\n       PRAGMA user_version = ${String(1)};`)}createThread(e={}){const t=e.id??a(),r=(new Date).toISOString();return this.db.prepare("INSERT INTO threads (id, title, model, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(t,e.title??null,e.model??null,r,r),t}hasThread(e){return void 0!==this.db.prepare("SELECT 1 FROM threads WHERE id = ?").get(e)}getThread(e){const t=this.db.prepare("SELECT * FROM threads WHERE id = ?").get(e);return t?E(t):void 0}listThreads(){return this.db.prepare("SELECT * FROM threads ORDER BY updated_at DESC, rowid DESC").all().map(E)}countMessages(e){return this.db.prepare("SELECT COUNT(*) AS n FROM messages WHERE thread_id = ?").get(e).n}updateTitle(e,t){this.db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(t,e)}deleteThread(e){this.db.prepare("DELETE FROM threads WHERE id = ?").run(e)}appendMessages(e,t){if(0===t.length)return;if(!this.hasThread(e))throw new Error(`Thread "${e}" 不存在`);let r=this.db.prepare("SELECT COALESCE(MAX(idx), -1) AS maxIdx FROM messages WHERE thread_id = ?").get(e).maxIdx+1;const d=(new Date).toISOString(),a=this.db.prepare("INSERT INTO messages (thread_id, idx, role, content_json, created_at) VALUES (?, ?, ?, ?, ?)");this.db.exec("BEGIN");try{for(const s of t)a.run(e,r,s.role,JSON.stringify(s),d),r+=1;this.db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(d,e),this.db.exec("COMMIT")}catch(e){throw this.db.exec("ROLLBACK"),e}}getMessages(e){return this.db.prepare("SELECT content_json FROM messages WHERE thread_id = ? ORDER BY idx ASC").all(e).map(e=>i.parse(JSON.parse(e.content_json)))}close(){this.db.close()}}

package/dist/tool-bridge/build-tools.d.ts

@@ -0,0 +1,30 @@
+import { type ToolSet } from "ai";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { AgentTool } from "@roll-agent/core/types/agent";
+import type { ApprovalDecision } from "../approval/approval-gate.ts";
+import type { ToolAnnotations, ToolPolicy } from "../types/policy.ts";
+import { ToolRegistry } from "./naming.ts";
+export interface SourceTool {
+    readonly tool: AgentTool;
+    readonly annotations: ToolAnnotations | undefined;
+}
+export interface AgentToolSource {
+    readonly agentName: string;
+    readonly client: Client;
+    readonly tools: readonly SourceTool[];
+}
+export interface ApprovalRequest {
+    readonly agentName: string;
+    readonly toolName: string;
+    readonly input: Record<string, unknown>;
+    readonly reason: string | undefined;
+}
+export interface ToolBridgeContext {
+    readonly policy?: ToolPolicy;
+    readonly requestApproval: (request: ApprovalRequest) => Promise<ApprovalDecision>;
+}
+export interface BuiltToolset {
+    readonly tools: ToolSet;
+    readonly registry: ToolRegistry;
+}
+export declare function buildAgentToolset(sources: readonly AgentToolSource[], ctx: ToolBridgeContext): BuiltToolset;

package/dist/tool-bridge/build-tools.js

@@ -0,0 +1 @@
+import{jsonSchema as o,tool as t}from"ai";import{preflightToolCall as n}from"@roll-agent/core/tool-runtime/preflight";import{ToolRegistry as r}from"./naming.js";import{normalizeToolResult as e}from"./normalize-result.js";function a(o){return"object"!=typeof o||null===o||Array.isArray(o)?{}:o}function i(o){return`参数校验失败: ${o.map(o=>o.message).join("; ")}`}async function s(o,t,n,r,e){if(!o.policy)return;const a=o.policy.check({agentName:t,toolName:n,input:r,...e?{annotations:e}:{}});if("deny"===a.action)return{output:"策略拒绝执行"+(a.reason?`: ${a.reason}`:""),isError:!0};if("confirm"===a.action){const e=await o.requestApproval({agentName:t,toolName:n,input:r,reason:a.reason});if(!e.approved)return{output:"已取消执行"+(e.reason?`: ${e.reason}`:""),isError:!0}}}export function buildAgentToolset(c,u){const m=new r,l={};for(const r of c){const{client:c,agentName:p}=r;for(const{tool:f,annotations:g}of r.tools){l[m.register(p,f.name)]=t({description:f.description??`${f.name} (via ${p})`,inputSchema:o(f.inputSchema),execute:async(o,t)=>{const r=a(o),m=n(f,r);if(!m.ok)return{output:i(m.issues),isError:!0};const l=await s(u,p,f.name,r,g);if(l)return l;const y=t.abortSignal?{signal:t.abortSignal}:void 0,d=await c.callTool({name:f.name,arguments:r},void 0,y);return e(d)}})}}return{tools:l,registry:m}}

package/dist/tool-bridge/naming.d.ts

@@ -0,0 +1,10 @@
+export interface ToolRoute {
+    readonly agentName: string;
+    readonly toolName: string;
+}
+export declare class ToolRegistry {
+    private readonly routes;
+    register(agentName: string, toolName: string): string;
+    resolve(id: string): ToolRoute | undefined;
+    size(): number;
+}

package/dist/tool-bridge/naming.js

@@ -0,0 +1 @@
+const e=/[^a-zA-Z0-9_-]/g;function t(t){return t.replace(e,"_")}export class ToolRegistry{routes=new Map;register(e,r){const s=`${t(e)}__${t(r)}`;let o=s,n=1;for(;this.routes.has(o);)o=`${s}_${String(n)}`,n+=1;return this.routes.set(o,{agentName:e,toolName:r}),o}resolve(e){return this.routes.get(e)}size(){return this.routes.size}}

package/dist/tool-bridge/normalize-result.d.ts

@@ -0,0 +1,6 @@
+export interface NormalizedToolResult {
+    readonly output: unknown;
+    readonly isError: boolean;
+}
+export declare function normalizeToolResult(result: unknown): NormalizedToolResult;
+export declare function readIsError(output: unknown): boolean;

package/dist/tool-bridge/normalize-result.js

@@ -0,0 +1 @@
+import{extractTextContent as o,isToolErrorResult as r}from"@roll-agent/core/cli/utils/tool-results";function t(o){return"object"==typeof o&&null!==o&&"content"in o?o.content:void 0}export function normalizeToolResult(n){const e=r(n),i=o(t(n));return{output:i.length>0?i.join("\n"):n,isError:e}}export function readIsError(o){return"object"==typeof o&&null!==o&&"isError"in o&&!0===o.isError}

package/dist/types/events.d.ts

@@ -0,0 +1,45 @@
+export interface SessionTokenUsage {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+}
+export type SessionEventStage = "bootstrap" | "plan" | "execute";
+export type SessionEvent = {
+    readonly type: "message-start";
+    readonly messageId: string;
+} | {
+    readonly type: "text-delta";
+    readonly delta: string;
+} | {
+    readonly type: "tool-call";
+    readonly toolCallId: string;
+    readonly agentName: string;
+    readonly toolName: string;
+    readonly input: unknown;
+} | {
+    readonly type: "tool-result";
+    readonly toolCallId: string;
+    readonly agentName: string;
+    readonly toolName: string;
+    readonly output: unknown;
+    readonly isError: boolean;
+} | {
+    readonly type: "confirmation-required";
+    readonly approvalId: string;
+    readonly agentName: string;
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly reason?: string;
+} | {
+    readonly type: "step-finish";
+    readonly finishReason: string;
+    readonly usage?: SessionTokenUsage;
+} | {
+    readonly type: "message-finish";
+    readonly text: string;
+    readonly totalUsage?: SessionTokenUsage;
+} | {
+    readonly type: "error";
+    readonly stage: SessionEventStage;
+    readonly message: string;
+};

package/dist/types/events.js

@@ -0,0 +1 @@
+export{};

package/dist/types/policy.d.ts

@@ -0,0 +1,18 @@
+export interface ToolAnnotations {
+    readonly readOnlyHint?: boolean;
+    readonly destructiveHint?: boolean;
+}
+export type PolicyAction = "allow" | "confirm" | "deny";
+export interface PolicyDecision {
+    readonly action: PolicyAction;
+    readonly reason?: string;
+}
+export interface ToolPolicyContext {
+    readonly agentName: string;
+    readonly toolName: string;
+    readonly input: Record<string, unknown>;
+    readonly annotations?: ToolAnnotations;
+}
+export interface ToolPolicy {
+    check(context: ToolPolicyContext): PolicyDecision;
+}

package/dist/types/policy.js

@@ -0,0 +1 @@
+export{};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@roll-agent/runtime",
+  "version": "0.1.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/steveoon/roll-agent"
+  },
+  "homepage": "https://github.com/steveoon/roll-agent",
+  "bugs": {
+    "url": "https://github.com/steveoon/roll-agent/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.6.0"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^3.0.8",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "ai": "^6.0.154",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@roll-agent/core": "0.11.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node ../../scripts/obfuscate.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "node --experimental-strip-types --experimental-sqlite --test \"src/**/*.test.ts\"",
+    "clean": "rm -rf dist"
+  }
+}