@vietor/agent-core 0.7.0

package/dist/llm/responses.js

@@ -0,0 +1,130 @@
+import OpenAI from "openai";
+import { EmptyAssistantMessageError, toText, } from "./messages.js";
+import { BaseAdapter } from "./base.js";
+import { netFetch } from "../util/net.js";
+export class ResponsesAdapter extends BaseAdapter {
+    client;
+    constructor(config) {
+        super(config);
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl || undefined,
+            maxRetries: 0,
+            fetch: netFetch,
+        });
+    }
+    async stream(opts) {
+        const { messages, tools, onDelta, onThinking, onUsage, onToolCall, thinking, signal } = opts;
+        const useThinking = thinking !== false;
+        const params = {
+            model: this.model,
+            input: toResponsesInput(messages),
+            max_output_tokens: this.maxOutputTokens,
+            stream: true,
+            ...(tools.length > 0 && { tools: tools.map(toResponsesTool) }),
+            ...(useThinking && {
+                reasoning: { effort: this.thinkingEffort },
+                include: ["reasoning.summary_text"],
+            }),
+        };
+        const stream = await this.client.responses.create(params, { signal });
+        let finalResponse;
+        for await (const event of stream) {
+            switch (event.type) {
+                case "response.output_text.delta":
+                    onDelta?.(event.delta);
+                    break;
+                case "response.refusal.delta":
+                    onDelta?.(event.delta);
+                    break;
+                case "response.reasoning_summary_text.delta":
+                    onThinking?.(event.delta);
+                    break;
+                case "response.output_item.added":
+                    if (event.item.type === "function_call")
+                        onToolCall?.();
+                    break;
+                case "response.completed":
+                case "response.failed":
+                    finalResponse = event.response;
+                    break;
+            }
+        }
+        if (!finalResponse)
+            throw new EmptyAssistantMessageError();
+        if (finalResponse.status === "failed") {
+            const detail = finalResponse.error
+                ? `${finalResponse.error.code}: ${finalResponse.error.message}`
+                : "unknown error";
+            throw new Error(`Responses API error: ${detail}`);
+        }
+        if (finalResponse.usage) {
+            onUsage?.(finalResponse.usage.input_tokens, finalResponse.usage.output_tokens);
+        }
+        const textParts = [];
+        const toolCalls = [];
+        for (const item of finalResponse.output) {
+            if (item.type === "message") {
+                for (const part of item.content) {
+                    if (part.type === "output_text")
+                        textParts.push(part.text);
+                    else if (part.type === "refusal")
+                        textParts.push(part.refusal);
+                }
+            }
+            else if (item.type === "function_call") {
+                toolCalls.push({
+                    id: item.call_id,
+                    type: "function",
+                    function: { name: item.name, arguments: item.arguments },
+                });
+            }
+        }
+        const content = textParts.join("") || null;
+        const message = { role: "assistant", content };
+        if (toolCalls.length)
+            message.tool_calls = toolCalls;
+        if (!content && !toolCalls.length) {
+            throw new EmptyAssistantMessageError();
+        }
+        return message;
+    }
+}
+export function toResponsesTool(schema) {
+    return {
+        type: "function",
+        name: schema.function.name,
+        description: schema.function.description,
+        parameters: schema.function.parameters,
+        strict: false,
+    };
+}
+export function toResponsesInput(messages) {
+    const items = [];
+    for (const m of messages) {
+        if (m.role === "system") {
+            const text = toText(m.content);
+            if (text)
+                items.push({ type: "message", role: "system", content: [{ type: "input_text", text }] });
+        }
+        else if (m.role === "user") {
+            const text = toText(m.content);
+            if (text)
+                items.push({ type: "message", role: "user", content: [{ type: "input_text", text }] });
+        }
+        else if (m.role === "tool") {
+            items.push({ type: "function_call_output", call_id: m.tool_call_id, output: m.content });
+        }
+        else {
+            const text = toText(m.content);
+            if (text)
+                items.push({ type: "message", role: "assistant", content: [{ type: "input_text", text }] });
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls) {
+                    items.push({ type: "function_call", call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments });
+                }
+            }
+        }
+    }
+    return items;
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,40 @@
+import type { ToolSchema } from "../tools/types.js";
+import type { LLMAssistantMessage, LLMMessage } from "./messages.js";
+export type LLMThinkingEffort = "high" | "max";
+export type LLMBackend = "completions" | "anthropic" | "responses";
+export interface LLMConfig {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    thinkingEffort?: LLMThinkingEffort;
+    backend?: LLMBackend;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+}
+export interface ResolvedLLMConfig extends LLMConfig {
+    thinkingEffort: LLMThinkingEffort;
+    backend: LLMBackend;
+    maxInputTokens: number;
+    maxOutputTokens: number;
+}
+export interface ChatOptions {
+    messages: LLMMessage[];
+    tools: ToolSchema[];
+    onDelta?: (text: string) => void;
+    onThinking?: (text: string) => void;
+    onRetry?: (attempt: number, max: number, error: unknown) => void;
+    onUsage?: (inputTokens: number, outputTokens: number) => void;
+    onToolCall?: () => void;
+    thinking?: boolean;
+    signal?: AbortSignal;
+}
+export interface LLMClient {
+    readonly model: string;
+    readonly thinkingEffort: LLMThinkingEffort;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    chat(opts: ChatOptions): Promise<LLMAssistantMessage>;
+}
+export interface Adapter extends Omit<LLMClient, "chat"> {
+    stream(opts: ChatOptions): Promise<LLMAssistantMessage>;
+}

package/dist/llm/types.js

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

package/dist/mcp/client.d.ts

@@ -0,0 +1,15 @@
+import type { MCPClientInfo } from "./types.js";
+import type { MCPServerConfig } from "./types.js";
+import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare class MCPClient {
+    private client;
+    private transport;
+    private connectReject?;
+    private closing;
+    onClosed?: (error?: string) => void;
+    constructor(config: MCPServerConfig, clientInfo: MCPClientInfo);
+    connect(): Promise<void>;
+    listTools(): Promise<Tool[]>;
+    callTool(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<CallToolResult>;
+    kill(): void;
+}

package/dist/mcp/client.js

@@ -0,0 +1,53 @@
+import { AbortedError } from "../util/async.js";
+import { killProcessTree } from "../util/subprocess.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+export class MCPClient {
+    client;
+    transport;
+    connectReject;
+    closing = false;
+    onClosed;
+    constructor(config, clientInfo) {
+        this.client = new Client(clientInfo, { capabilities: {} });
+        if (config.type === "stdio") {
+            this.transport = new StdioClientTransport({ ...config, stderr: "ignore" });
+        }
+        else {
+            const opts = { requestInit: { headers: config.headers } };
+            const url = new URL(config.url);
+            this.transport = new StreamableHTTPClientTransport(url, opts);
+        }
+        this.transport.onerror = (e) => { if (!this.closing)
+            this.onClosed?.(e.message); };
+        this.transport.onclose = () => { if (!this.closing)
+            this.onClosed?.(); };
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.connectReject = reject;
+            this.client
+                .connect(this.transport)
+                .then(resolve, reject)
+                .finally(() => {
+                this.connectReject = undefined;
+            });
+        });
+    }
+    async listTools() {
+        return this.client.listTools().then((r) => r.tools);
+    }
+    async callTool(name, args, signal) {
+        return this.client.callTool({ name, arguments: args }, undefined, { signal });
+    }
+    kill() {
+        this.closing = true;
+        this.connectReject?.(new AbortedError());
+        this.connectReject = undefined;
+        this.client.close().catch(() => { });
+        if (this.transport instanceof StdioClientTransport) {
+            killProcessTree(this.transport.pid);
+        }
+    }
+}

package/dist/mcp/manager.d.ts

@@ -0,0 +1,18 @@
+import type { ToolRegistry } from "../tools/registry.js";
+import type { MCPClientInfo, MCPServerConfig, MCPServerInfo } from "./types.js";
+export declare class MCPServerManager {
+    private tools;
+    private clientInfo;
+    private servers;
+    private pending;
+    private disposed;
+    constructor(tools: ToolRegistry, clientInfo: MCPClientInfo);
+    connect(mcpServers?: Record<string, MCPServerConfig>): Promise<void>;
+    private connectServer;
+    private markFailed;
+    private unregisterServerTools;
+    private handleServerClosed;
+    private adapt;
+    list(): MCPServerInfo[];
+    kill(): void;
+}

package/dist/mcp/manager.js

@@ -0,0 +1,155 @@
+import { toolError } from "../tools/types.js";
+import { MCPClient } from "./client.js";
+import { withTimeout, withTimeoutFn } from "../util/async.js";
+import { CALL_TIMEOUT_MS, MCP_CONNECT_TIMEOUT_MS, NO_OUTPUT } from "../util/constants.js";
+import { toErrorMessage } from "../util/text.js";
+const SUMMARY_PRIORITY = ["url", "path", "file_path", "filePath", "command", "query", "pattern", "name", "text", "selector", "uid"];
+function isStringProp(v) {
+    return typeof v === "object" && v !== null && v.type === "string";
+}
+function summaryCandidates(inputSchema) {
+    const props = inputSchema.properties;
+    if (!props)
+        return [];
+    const candidates = [];
+    for (const k of SUMMARY_PRIORITY)
+        if (k in props)
+            candidates.push(k);
+    const required = inputSchema.required;
+    if (Array.isArray(required)) {
+        for (const k of required) {
+            if (typeof k === "string" && !candidates.includes(k) && isStringProp(props[k]))
+                candidates.push(k);
+        }
+    }
+    for (const [k, v] of Object.entries(props)) {
+        if (!candidates.includes(k) && isStringProp(v))
+            candidates.push(k);
+    }
+    return candidates;
+}
+function extractContent(result) {
+    const parts = [];
+    for (const c of result.content) {
+        switch (c.type) {
+            case "text":
+                parts.push(c.text);
+                break;
+            case "image":
+                parts.push(`[image: ${c.mimeType}]`);
+                break;
+            case "audio":
+                parts.push(`[audio: ${c.mimeType}]`);
+                break;
+            case "resource": {
+                const r = c.resource;
+                parts.push("text" in r ? r.text : `[resource: ${r.uri}]`);
+                break;
+            }
+            default:
+                parts.push(`[${c.type}]`);
+        }
+    }
+    if (result.structuredContent) {
+        parts.push(`<structured>${JSON.stringify(result.structuredContent)}</structured>`);
+    }
+    return parts.join("\n");
+}
+function mcpToolName(server, tool) {
+    return `MCP__${server}__${tool}`;
+}
+export class MCPServerManager {
+    tools;
+    clientInfo;
+    servers = new Map();
+    pending = new Set();
+    disposed = false;
+    constructor(tools, clientInfo) {
+        this.tools = tools;
+        this.clientInfo = clientInfo;
+    }
+    async connect(mcpServers = {}) {
+        await Promise.all(Object.entries(mcpServers).map(([name, cfg]) => this.connectServer(name, cfg)));
+    }
+    async connectServer(name, cfg) {
+        if (this.disposed)
+            return;
+        const type = cfg.type;
+        if (cfg.enabled === false) {
+            this.servers.set(name, { type, status: "disabled", tools: [] });
+            return;
+        }
+        this.servers.set(name, { type, status: "pending", tools: [] });
+        let client;
+        try {
+            client = new MCPClient(cfg, this.clientInfo);
+        }
+        catch (e) {
+            this.markFailed(name, type, toErrorMessage(e));
+            return;
+        }
+        this.pending.add(client);
+        try {
+            await withTimeout(client.connect(), MCP_CONNECT_TIMEOUT_MS);
+            if (this.disposed)
+                return;
+            const mcpTools = await withTimeout(client.listTools(), MCP_CONNECT_TIMEOUT_MS);
+            if (this.disposed)
+                return;
+            this.servers.set(name, { type, status: "connected", client, tools: mcpTools.map((t) => t.name) });
+            this.tools.registerAll(mcpTools.map((t) => this.adapt(name, client, t)));
+            client.onClosed = (error) => this.handleServerClosed(name, client, error);
+        }
+        catch (e) {
+            client.kill();
+            if (!this.disposed) {
+                this.markFailed(name, type, toErrorMessage(e));
+            }
+        }
+        finally {
+            this.pending.delete(client);
+        }
+    }
+    markFailed(name, type, error) {
+        this.servers.set(name, { type, status: "failed", tools: [], error });
+    }
+    unregisterServerTools(name, tools) {
+        for (const t of tools)
+            this.tools.unregister(mcpToolName(name, t));
+    }
+    handleServerClosed(name, client, error) {
+        const entry = this.servers.get(name);
+        if (!entry || entry.client !== client || entry.status !== "connected")
+            return;
+        this.unregisterServerTools(name, entry.tools);
+        this.markFailed(name, entry.type, error ?? "MCP server connection closed");
+    }
+    adapt(server, client, tool) {
+        const summaryKeys = summaryCandidates(tool.inputSchema);
+        return {
+            name: mcpToolName(server, tool.name),
+            description: tool.description ?? `${server} ${tool.name}`,
+            parameters: tool.inputSchema,
+            ...(summaryKeys.length ? { summaryKeys } : {}),
+            async execute(args, ctx) {
+                const result = await withTimeoutFn((signal) => client.callTool(tool.name, args, signal), CALL_TIMEOUT_MS, ctx.signal, `MCP tool call timed out (${CALL_TIMEOUT_MS / 1000}s)`);
+                const text = extractContent(result);
+                return result.isError
+                    ? toolError(text)
+                    : { content: text || NO_OUTPUT };
+            },
+        };
+    }
+    list() {
+        return [...this.servers.entries()].map(([name, s]) => ({ name, type: s.type, status: s.status, tools: s.tools, error: s.error }));
+    }
+    kill() {
+        this.disposed = true;
+        for (const { client } of this.servers.values())
+            client?.kill();
+        for (const client of this.pending)
+            client.kill();
+        this.servers.clear();
+        this.pending.clear();
+    }
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,26 @@
+export interface MCPClientInfo {
+    name: string;
+    version: string;
+}
+export type ServerType = "stdio" | "http";
+export type MCPServerConfig = StdioServerConfig | HttpServerConfig;
+export interface StdioServerConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface HttpServerConfig {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface MCPServerInfo {
+    name: string;
+    type: ServerType;
+    status: "pending" | "connected" | "failed" | "disabled";
+    tools: string[];
+    error?: string;
+}

package/dist/mcp/types.js

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

package/dist/runtime/agent.d.ts

@@ -0,0 +1,56 @@
+import type { LLMClient } from "../llm/types.js";
+import { SessionMessages, type SessionMessage } from "./session-messages.js";
+import type { SessionEvent } from "./events.js";
+import type { Skill } from "../skills/loader.js";
+import type { ToolRegistry } from "../tools/registry.js";
+import type { Todo } from "../tools/types.js";
+export type RunStatus = "ok" | "aborted" | "error" | "stalled" | "maxTurns";
+export interface AgentOptions {
+    llm: LLMClient;
+    conversation: SessionMessages;
+    tools: ToolRegistry;
+    cwd: string;
+    setTodos: (todos: Todo[]) => void;
+    getTodos: () => readonly Todo[];
+    stallThreshold: number;
+    maxTurns: number;
+    contextLimit: number;
+    resolveSkill?: (name: string) => Skill | undefined;
+    onCompact?: () => void;
+}
+export declare class Agent {
+    private llm;
+    private conversation;
+    private tools;
+    private cwd;
+    private setTodos;
+    private getTodos;
+    private stallThreshold;
+    private maxTurns;
+    readonly contextLimit: number;
+    private todoSnapshot;
+    private resolveSkill?;
+    private onCompact?;
+    private inputTokens;
+    private outputTokens;
+    constructor(opts: AgentOptions);
+    get contextTokens(): number;
+    get usage(): {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    resetUsage(): void;
+    get model(): string;
+    get thinkingEffort(): import("../llm/types.js").LLMThinkingEffort;
+    clear(): void;
+    export(): SessionMessage[];
+    compact(onEvent?: (e: SessionEvent) => void, signal?: AbortSignal): Promise<RunStatus>;
+    run(userInput: string, onEvent?: (e: SessionEvent) => void, signal?: AbortSignal): Promise<RunStatus>;
+    runSkill(skill: Skill, onEvent?: (e: SessionEvent) => void, signal?: AbortSignal): Promise<RunStatus>;
+    private runTurn;
+    private loop;
+    private resolvePendingToolCalls;
+    private chatOnce;
+    private runToolCalls;
+    private executeToolCall;
+}