tg-agent 0.1.0

package/dist/customTools.js

@@ -0,0 +1,386 @@
+import { Type } from "@sinclair/typebox";
+import { config } from "./config.js";
+import { callMcpServer, formatMcpTarget, loadMcpServers, loadMcpServersSync } from "./mcp.js";
+const DEFAULT_MAX_BYTES = 200_000;
+const DEFAULT_TIMEOUT_MS = 60_000;
+function clampNumber(value, min, max) {
+    if (Number.isNaN(value))
+        return min;
+    return Math.min(max, Math.max(min, value));
+}
+function normalizeHeaders(headers) {
+    if (!headers)
+        return {};
+    const normalized = {};
+    if (Array.isArray(headers)) {
+        for (const entry of headers) {
+            if (!entry?.name)
+                continue;
+            normalized[entry.name] = entry.value ?? "";
+        }
+        return normalized;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (!key)
+            continue;
+        normalized[key] = value;
+    }
+    return normalized;
+}
+function resolveTimeoutMs(input) {
+    const fallback = config.fetchTimeoutMs > 0 ? config.fetchTimeoutMs : DEFAULT_TIMEOUT_MS;
+    if (!input)
+        return clampNumber(fallback, 1000, 120_000);
+    return clampNumber(input, 1000, 120_000);
+}
+function resolveMaxBytes(input) {
+    const fallback = config.fetchMaxBytes > 0 ? config.fetchMaxBytes : DEFAULT_MAX_BYTES;
+    if (!input)
+        return clampNumber(fallback, 1024, 5_000_000);
+    return clampNumber(input, 1024, 5_000_000);
+}
+function isHttpUrl(raw) {
+    try {
+        const url = new URL(raw);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+function concatChunks(chunks, totalBytes) {
+    const buffer = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return buffer;
+}
+async function readBodyLimited(response, maxBytes, signal) {
+    const reader = response.body?.getReader?.();
+    if (!reader) {
+        const text = (await response.text?.()) ?? "";
+        const bytes = Math.min(text.length, maxBytes);
+        const truncated = text.length > maxBytes;
+        return { text: text.slice(0, maxBytes), bytes, truncated };
+    }
+    const decoder = new TextDecoder("utf-8");
+    const chunks = [];
+    let bytes = 0;
+    let truncated = false;
+    while (true) {
+        if (signal?.aborted) {
+            try {
+                await reader.cancel?.();
+            }
+            catch {
+                // ignore
+            }
+            throw new Error("Fetch aborted");
+        }
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        const nextBytes = bytes + value.byteLength;
+        if (nextBytes > maxBytes) {
+            const sliceSize = Math.max(0, maxBytes - bytes);
+            if (sliceSize > 0) {
+                chunks.push(value.slice(0, sliceSize));
+                bytes += sliceSize;
+            }
+            truncated = true;
+            try {
+                await reader.cancel?.();
+            }
+            catch {
+                // ignore
+            }
+            break;
+        }
+        chunks.push(value);
+        bytes = nextBytes;
+    }
+    const buffer = concatChunks(chunks, bytes);
+    const text = decoder.decode(buffer);
+    return { text, bytes, truncated };
+}
+function formatFetchOutput(result, bodyText) {
+    const statusLine = `HTTP ${result.status} ${result.statusText}`.trim();
+    const meta = [
+        `url: ${result.url}`,
+        `bytes: ${result.bytes}${result.truncated ? " (truncated)" : ""}`,
+        `content-type: ${result.contentType ?? "unknown"}`,
+    ];
+    return `${statusLine}\n${meta.join("\n")}\n\n${bodyText}`;
+}
+const fetchParamsSchema = Type.Object({
+    url: Type.String({ description: "HTTP or HTTPS URL" }),
+    method: Type.Optional(Type.String({ description: "HTTP method (default: GET)" })),
+    headers: Type.Optional(Type.Array(Type.Object({
+        name: Type.String({ description: "Header name" }),
+        value: Type.String({ description: "Header value" }),
+    }), { description: "Request headers as name/value pairs" })),
+    body: Type.Optional(Type.String({ description: "Request body (string)" })),
+    timeoutMs: Type.Optional(Type.Integer({ description: "Timeout in milliseconds", minimum: 1000, maximum: 120000 })),
+    maxBytes: Type.Optional(Type.Integer({ description: "Max response bytes", minimum: 1024, maximum: 5000000 })),
+});
+function createFetchTool() {
+    return {
+        name: "fetch",
+        label: "fetch",
+        description: "Fetch a URL via HTTP(S) and return the response body.",
+        parameters: fetchParamsSchema,
+        execute: async (toolCallId, params, onUpdate, _ctx, signal) => {
+            if (!isHttpUrl(params.url)) {
+                return {
+                    content: [{ type: "text", text: "Invalid URL. Only http(s) is allowed." }],
+                    details: {
+                        url: params.url,
+                        status: 0,
+                        statusText: "invalid_url",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                };
+            }
+            const timeoutMs = resolveTimeoutMs(params.timeoutMs);
+            const maxBytes = resolveMaxBytes(params.maxBytes);
+            const controller = new AbortController();
+            const onAbort = () => controller.abort();
+            signal?.addEventListener("abort", onAbort, { once: true });
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                onUpdate?.({
+                    content: [{ type: "text", text: `Fetching ${params.url}...` }],
+                    details: {
+                        url: params.url,
+                        status: 0,
+                        statusText: "pending",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                });
+                const response = await fetch(params.url, {
+                    method: params.method?.toUpperCase() ?? "GET",
+                    headers: normalizeHeaders(params.headers),
+                    body: params.body,
+                    signal: controller.signal,
+                });
+                const readResult = await readBodyLimited(response, maxBytes, signal);
+                const contentType = response.headers.get("content-type");
+                const output = formatFetchOutput({
+                    url: response.url,
+                    status: response.status,
+                    statusText: response.statusText,
+                    bytes: readResult.bytes,
+                    truncated: readResult.truncated,
+                    contentType,
+                }, readResult.text);
+                return {
+                    content: [{ type: "text", text: output }],
+                    details: {
+                        url: response.url,
+                        status: response.status,
+                        statusText: response.statusText,
+                        bytes: readResult.bytes,
+                        truncated: readResult.truncated,
+                        contentType,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Fetch failed: ${message}` }],
+                    details: {
+                        url: params.url,
+                        status: 0,
+                        statusText: "error",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                };
+            }
+            finally {
+                clearTimeout(timeout);
+                signal?.removeEventListener("abort", onAbort);
+            }
+        },
+    };
+}
+const mcpParamsSchema = Type.Object({
+    server: Type.Optional(Type.String({ description: "MCP server name" })),
+    method: Type.String({ description: "MCP method name" }),
+    params: Type.Optional(Type.Any({ description: "MCP params payload" })),
+});
+function formatMcpToolOutput(server, result, bodyText) {
+    const statusLine = result.status > 0 ? `HTTP ${result.status} ${result.statusText}`.trim() : result.statusText;
+    const meta = [
+        `server: ${server.name}`,
+        `type: ${server.type}`,
+        `target: ${result.target}`,
+        `bytes: ${result.bytes}${result.truncated ? " (truncated)" : ""}`,
+        `content-type: ${result.contentType ?? "unknown"}`,
+    ];
+    return `${statusLine}\n${meta.join("\n")}\n\n${bodyText}`;
+}
+function createMcpTool(loadServers) {
+    return {
+        name: "mcp",
+        label: "mcp",
+        description: "Call an MCP endpoint via JSON-RPC.",
+        parameters: mcpParamsSchema,
+        execute: async (_toolCallId, params, onUpdate, _ctx, signal) => {
+            const servers = await loadServers();
+            if (servers.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "MCP is not configured. Add [mcp_servers.*] to ~/.tg-agent/config.toml.",
+                        },
+                    ],
+                    details: {
+                        server: "",
+                        type: "http",
+                        target: "",
+                        status: 0,
+                        statusText: "not_configured",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                };
+            }
+            let serverName = params.server?.trim() ?? "";
+            if (!serverName) {
+                if (servers.length === 1) {
+                    serverName = servers[0]?.name ?? "";
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Multiple MCP servers configured. Provide server name. Available: ${servers
+                                    .map((entry) => entry.name)
+                                    .join(", ")}`,
+                            },
+                        ],
+                        details: {
+                            server: "",
+                            type: "http",
+                            target: "",
+                            status: 0,
+                            statusText: "server_required",
+                            bytes: 0,
+                            truncated: false,
+                            contentType: null,
+                        },
+                    };
+                }
+            }
+            const server = servers.find((entry) => entry.name === serverName);
+            if (!server) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `MCP server not found: ${serverName}. Available: ${servers
+                                .map((entry) => entry.name)
+                                .join(", ")}`,
+                        },
+                    ],
+                    details: {
+                        server: serverName,
+                        type: "http",
+                        target: "",
+                        status: 0,
+                        statusText: "server_not_found",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                };
+            }
+            try {
+                onUpdate?.({
+                    content: [
+                        {
+                            type: "text",
+                            text: `Calling MCP ${server.name} ${params.method}...`,
+                        },
+                    ],
+                    details: {
+                        server: server.name,
+                        type: server.type,
+                        target: formatMcpTarget(server),
+                        status: 0,
+                        statusText: "pending",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                });
+                const result = await callMcpServer(server, params.method, params.params ?? {}, {
+                    timeoutMs: resolveTimeoutMs(undefined),
+                    maxBytes: resolveMaxBytes(undefined),
+                    signal,
+                });
+                const output = formatMcpToolOutput(server, {
+                    server: server.name,
+                    type: server.type,
+                    target: formatMcpTarget(server),
+                    status: result.statusCode ?? 0,
+                    statusText: result.statusText ?? (result.ok ? "ok" : "error"),
+                    bytes: result.bytes,
+                    truncated: result.truncated,
+                    contentType: result.contentType ?? null,
+                }, result.output);
+                return {
+                    content: [{ type: "text", text: output }],
+                    details: {
+                        server: server.name,
+                        type: server.type,
+                        target: formatMcpTarget(server),
+                        status: result.statusCode ?? 0,
+                        statusText: result.statusText ?? (result.ok ? "ok" : "error"),
+                        bytes: result.bytes,
+                        truncated: result.truncated,
+                        contentType: result.contentType ?? null,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `MCP failed: ${message}` }],
+                    details: {
+                        server: server.name,
+                        type: server.type,
+                        target: formatMcpTarget(server),
+                        status: 0,
+                        statusText: "error",
+                        bytes: 0,
+                        truncated: false,
+                        contentType: null,
+                    },
+                };
+            }
+        },
+    };
+}
+export function createCustomTools() {
+    const tools = [createFetchTool()];
+    const servers = loadMcpServersSync(config.agentDir);
+    if (servers.length > 0) {
+        tools.push(createMcpTool(() => loadMcpServers(config.agentDir)));
+    }
+    return tools;
+}