@opengeni/ogtool 0.1.0 → 0.3.5

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+import { type AttemptToolCatalog, type AttemptToolCatalogEntry } from "@opengeni/codemode";
+export declare function resolveTool(catalog: AttemptToolCatalog, name: string): AttemptToolCatalogEntry;
+export declare function listProjection(catalog: AttemptToolCatalog): Record<string, unknown>;
+export declare function parseToolArguments(raw: string | undefined): Record<string, unknown>;

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 /** npm package name used by deployment BOMs and custom-rig bootstrap hints. */
-declare const OGTOOL_PACKAGE_NAME: "@opengeni/ogtool";
-/** Environment variables consumed by the dependency-free CLI. */
-declare const OGTOOL_ENVIRONMENT: {
-    readonly url: "OPENGENI_TOOLSPACE_URL";
-    readonly tokenFile: "OPENGENI_TOOLSPACE_TOKEN_FILE";
+export declare const OGTOOL_PACKAGE_NAME: "@opengeni/ogtool";
+/** Environment variables consumed by the standalone bundled CLI. */
+export declare const OGTOOL_ENVIRONMENT: {
+    readonly url: "OPENGENI_CODEMODE_URL";
+    readonly token: "OPENGENI_CODEMODE_TOKEN";
+    readonly tokenFile: "OPENGENI_CODEMODE_TOKEN_FILE";
     readonly packageSpec: "OPENGENI_OGTOOL_PACKAGE_SPEC";
 };
-
-export { OGTOOL_ENVIRONMENT, OGTOOL_PACKAGE_NAME };
+export * from "@opengeni/codemode";

package/dist/index.js

@@ -1,8 +1,10 @@
 // src/index.ts
+export * from "@opengeni/codemode";
 var OGTOOL_PACKAGE_NAME = "@opengeni/ogtool";
 var OGTOOL_ENVIRONMENT = {
-  url: "OPENGENI_TOOLSPACE_URL",
-  tokenFile: "OPENGENI_TOOLSPACE_TOKEN_FILE",
+  url: "OPENGENI_CODEMODE_URL",
+  token: "OPENGENI_CODEMODE_TOKEN",
+  tokenFile: "OPENGENI_CODEMODE_TOKEN_FILE",
   packageSpec: "OPENGENI_OGTOOL_PACKAGE_SPEC"
 };
 export {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/** npm package name used by deployment BOMs and custom-rig bootstrap hints. */\nexport const OGTOOL_PACKAGE_NAME = \"@opengeni/ogtool\" as const;\n\n/** Environment variables consumed by the dependency-free CLI. */\nexport const OGTOOL_ENVIRONMENT = {\n  url: \"OPENGENI_TOOLSPACE_URL\",\n  tokenFile: \"OPENGENI_TOOLSPACE_TOKEN_FILE\",\n  packageSpec: \"OPENGENI_OGTOOL_PACKAGE_SPEC\",\n} as const;\n"],"mappings":";AACO,IAAM,sBAAsB;AAG5B,IAAM,qBAAqB;AAAA,EAChC,KAAK;AAAA,EACL,WAAW;AAAA,EACX,aAAa;AACf;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/** npm package name used by deployment BOMs and custom-rig bootstrap hints. */\nexport const OGTOOL_PACKAGE_NAME = \"@opengeni/ogtool\" as const;\n\n/** Environment variables consumed by the standalone bundled CLI. */\nexport const OGTOOL_ENVIRONMENT = {\n  url: \"OPENGENI_CODEMODE_URL\",\n  token: \"OPENGENI_CODEMODE_TOKEN\",\n  tokenFile: \"OPENGENI_CODEMODE_TOKEN_FILE\",\n  packageSpec: \"OPENGENI_OGTOOL_PACKAGE_SPEC\",\n} as const;\n\nexport * from \"@opengeni/codemode\";\n"],"mappings":";AAWA,cAAc;AAVP,IAAM,sBAAsB;AAG5B,IAAM,qBAAqB;AAAA,EAChC,KAAK;AAAA,EACL,OAAO;AAAA,EACP,WAAW;AAAA,EACX,aAAa;AACf;","names":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opengeni/ogtool",
-  "version": "0.1.0",
-  "description": "Dependency-free CLI for calling the OpenGeni Toolspace MCP surface from a sandbox or custom rig.",
+  "version": "0.3.5",
+  "description": "Codemode CLI and typed client entrypoint for an OpenGeni execution attempt.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -9,10 +9,9 @@
     "directory": "packages/ogtool"
   },
   "bin": {
-    "ogtool": "./bin/ogtool.cjs"
+    "ogtool": "./dist/bin/ogtool.cjs"
   },
   "files": [
-    "bin",
     "dist",
     "src"
   ],
@@ -32,11 +31,14 @@
     "provenance": true
   },
   "scripts": {
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsc --noEmit",
     "test": "bun test",
-    "build": "tsup",
+    "build": "bun build.ts",
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
+  "dependencies": {
+    "@opengeni/codemode": "^0.4.1"
+  },
   "engines": {
     "node": ">=18"
   }

package/src/cli.ts

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+import {
+  CodemodeClient,
+  generateCodemodeDeclarations,
+  type AttemptToolCatalog,
+  type AttemptToolCatalogEntry,
+} from "@opengeni/codemode";
+import packageManifest from "../package.json" with { type: "json" };
+
+const PACKAGE_NAME = "@opengeni/ogtool";
+const VERSION = packageManifest.version;
+
+function usage(exitCode = 1): void {
+  const output = [
+    "usage:",
+    "  ogtool list",
+    "  ogtool call <tool-path-or-model-name> [json-object]",
+    "  ogtool declarations [output-file]",
+    "  ogtool doctor",
+    "  ogtool --version",
+    "",
+    "requires OPENGENI_CODEMODE_URL and OPENGENI_CODEMODE_TOKEN or OPENGENI_CODEMODE_TOKEN_FILE",
+  ].join("\n");
+  (exitCode === 0 ? process.stdout : process.stderr).write(`${output}\n`);
+  process.exitCode = exitCode;
+}
+
+function configuredClient(): CodemodeClient {
+  const baseUrl = process.env.OPENGENI_CODEMODE_URL?.trim();
+  const directTokenConfigured = process.env.OPENGENI_CODEMODE_TOKEN !== undefined;
+  const tokenFile = process.env.OPENGENI_CODEMODE_TOKEN_FILE?.trim();
+  if (!baseUrl) throw new Error("OPENGENI_CODEMODE_URL is required");
+  if (!directTokenConfigured && !tokenFile) {
+    throw new Error("OPENGENI_CODEMODE_TOKEN or OPENGENI_CODEMODE_TOKEN_FILE is required");
+  }
+  return new CodemodeClient({
+    baseUrl,
+    token: directTokenConfigured
+      ? async () => requiredDirectToken()
+      : async () => readToken(tokenFile!),
+  });
+}
+
+function requiredDirectToken(): string {
+  const token = process.env.OPENGENI_CODEMODE_TOKEN?.trim();
+  if (!token) throw new Error("OPENGENI_CODEMODE_TOKEN is empty");
+  return token;
+}
+
+function readToken(tokenFile: string): string {
+  let token: string;
+  try {
+    token = readFileSync(tokenFile, "utf8").trim();
+  } catch {
+    throw new Error("OPENGENI_CODEMODE_TOKEN_FILE is not readable");
+  }
+  if (!token) throw new Error("OPENGENI_CODEMODE_TOKEN_FILE is empty");
+  return token;
+}
+
+function doctor(): void {
+  const directTokenRaw = process.env.OPENGENI_CODEMODE_TOKEN;
+  const directTokenConfigured = directTokenRaw !== undefined;
+  const directTokenNonempty = Boolean(directTokenRaw?.trim().length);
+  const tokenFile = process.env.OPENGENI_CODEMODE_TOKEN_FILE ?? null;
+  const rawUrl = process.env.OPENGENI_CODEMODE_URL ?? null;
+  let urlValid = false;
+  let protocol: string | null = null;
+  if (rawUrl) {
+    try {
+      const target = new URL(rawUrl);
+      protocol = target.protocol;
+      urlValid = protocol === "http:" || protocol === "https:";
+    } catch {
+      urlValid = false;
+    }
+  }
+  let tokenFileReadable = false;
+  let tokenFileNonempty = false;
+  if (tokenFile) {
+    try {
+      tokenFileReadable = statSync(tokenFile).isFile();
+      tokenFileNonempty = tokenFileReadable && readFileSync(tokenFile, "utf8").trim().length > 0;
+    } catch {
+      tokenFileReadable = false;
+    }
+  }
+  const tokenMode = directTokenConfigured ? "environment" : tokenFile ? "file" : null;
+  const tokenReady = directTokenConfigured ? directTokenNonempty : tokenFileNonempty;
+  const ok = urlValid && tokenReady;
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        ok,
+        package: PACKAGE_NAME,
+        version: VERSION,
+        node: process.version,
+        urlConfigured: rawUrl !== null,
+        urlValid,
+        protocol,
+        tokenMode,
+        directTokenConfigured,
+        directTokenNonempty,
+        tokenFileConfigured: tokenFile !== null,
+        tokenFileReadable,
+        tokenFileNonempty,
+        packageSpec: process.env.OPENGENI_OGTOOL_PACKAGE_SPEC ?? null,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  process.exitCode = ok ? 0 : 1;
+}
+
+export function resolveTool(catalog: AttemptToolCatalog, name: string): AttemptToolCatalogEntry {
+  const matches = catalog.entries.filter(
+    (entry) =>
+      entry.modelName === name ||
+      entry.codemodePath.join(".") === name ||
+      `${entry.identity.serverId}.${entry.identity.toolName}` === name,
+  );
+  if (matches.length !== 1) {
+    throw new Error(
+      matches.length === 0 ? `Unknown Codemode tool: ${name}` : `Ambiguous tool: ${name}`,
+    );
+  }
+  return matches[0]!;
+}
+
+export function listProjection(catalog: AttemptToolCatalog): Record<string, unknown> {
+  return {
+    catalogDigest: catalog.digest,
+    attemptId: catalog.attemptId,
+    tools: catalog.entries.map((entry) => ({
+      name: entry.modelName,
+      path: entry.codemodePath.join("."),
+      identity: entry.identity,
+      ...(entry.title ? { title: entry.title } : {}),
+      ...(entry.description ? { description: entry.description } : {}),
+      inputSchema: entry.inputSchema,
+      ...(entry.outputSchema ? { outputSchema: entry.outputSchema } : {}),
+      ...(entry.annotations ? { annotations: entry.annotations } : {}),
+      approval: entry.approval,
+      source: entry.source,
+    })),
+  };
+}
+
+export function parseToolArguments(raw: string | undefined): Record<string, unknown> {
+  if (raw === undefined) return {};
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error("tool arguments must be valid JSON");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("tool arguments must be a JSON object");
+  }
+  return value as Record<string, unknown>;
+}
+
+async function main(): Promise<void> {
+  const command = process.argv[2];
+  if (command === "--help" || command === "-h" || command === "help") return usage(0);
+  if (command === "--version" || command === "-V" || command === "version") {
+    process.stdout.write(`${VERSION}\n`);
+    return;
+  }
+  if (command === "doctor") return doctor();
+  if (!command) return usage();
+
+  const client = configuredClient();
+  if (command === "list") {
+    process.stdout.write(`${JSON.stringify(listProjection(await client.catalog()), null, 2)}\n`);
+    return;
+  }
+  if (command === "call") {
+    const name = process.argv[3];
+    if (!name) throw new Error("tool path or model name is required");
+    const argumentsValue = parseToolArguments(process.argv[4]);
+    const catalog = await client.catalog();
+    const entry = resolveTool(catalog, name);
+    const result = await client.call(entry.identity, argumentsValue, {
+      operationId: randomUUID(),
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  if (command === "declarations") {
+    const catalog = await client.catalog();
+    const declaration = generateCodemodeDeclarations(catalog);
+    const output = process.argv[3];
+    if (!output || output === "-") {
+      process.stdout.write(declaration);
+    } else {
+      writeFileSync(output, declaration, { encoding: "utf8", mode: 0o600 });
+      process.stdout.write(
+        `${JSON.stringify({ catalogDigest: catalog.digest, output }, null, 2)}\n`,
+      );
+    }
+    return;
+  }
+  return usage();
+}
+
+void main().catch((error: unknown) => {
+  const code =
+    error && typeof error === "object" && "code" in error
+      ? String((error as { code: unknown }).code)
+      : null;
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = code === "tool_outcome_unknown" ? 3 : 1;
+});

package/src/index.ts

@@ -1,9 +1,12 @@
 /** npm package name used by deployment BOMs and custom-rig bootstrap hints. */
 export const OGTOOL_PACKAGE_NAME = "@opengeni/ogtool" as const;
 
-/** Environment variables consumed by the dependency-free CLI. */
+/** Environment variables consumed by the standalone bundled CLI. */
 export const OGTOOL_ENVIRONMENT = {
-  url: "OPENGENI_TOOLSPACE_URL",
-  tokenFile: "OPENGENI_TOOLSPACE_TOKEN_FILE",
+  url: "OPENGENI_CODEMODE_URL",
+  token: "OPENGENI_CODEMODE_TOKEN",
+  tokenFile: "OPENGENI_CODEMODE_TOKEN_FILE",
   packageSpec: "OPENGENI_OGTOOL_PACKAGE_SPEC",
 } as const;
+
+export * from "@opengeni/codemode";

package/bin/ogtool.cjs

@@ -1,327 +0,0 @@
-#!/usr/bin/env node
-
-"use strict";
-
-const fs = require("node:fs");
-const http = require("node:http");
-const https = require("node:https");
-const path = require("node:path");
-
-const PACKAGE_NAME = "@opengeni/ogtool";
-const DEFAULT_PROTOCOL_VERSION = "2025-03-26";
-const DEFAULT_MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
-const DEFAULT_TIMEOUT_MS = 120_000;
-
-function packageVersion() {
-  try {
-    const manifest = JSON.parse(
-      fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"),
-    );
-    if (typeof manifest.version === "string" && manifest.version.length > 0) {
-      return manifest.version;
-    }
-  } catch {
-    // A malformed/custom installation is reported honestly by --version and
-    // doctor rather than blocking the direct MCP fallback.
-  }
-  return "unknown";
-}
-
-const VERSION = packageVersion();
-
-function usage(exitCode = 1) {
-  const out = [
-    "usage:",
-    "  ogtool list",
-    "  ogtool call <tool-name> [json-object]",
-    "  ogtool doctor",
-    "  ogtool --version",
-    "",
-    "aliases: tools/list, tools/call",
-    "requires OPENGENI_TOOLSPACE_TOKEN_FILE and OPENGENI_TOOLSPACE_URL for list/call",
-  ].join("\n");
-  (exitCode === 0 ? process.stdout : process.stderr).write(`${out}\n`);
-  process.exitCode = exitCode;
-}
-
-function positiveIntegerEnvironment(name, fallback) {
-  const raw = process.env[name];
-  if (raw === undefined || raw === "") return fallback;
-  const parsed = Number(raw);
-  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-    throw new Error(`${name} must be a positive integer`);
-  }
-  return parsed;
-}
-
-function configuredEndpoint() {
-  const raw = process.env.OPENGENI_TOOLSPACE_URL;
-  if (!raw) throw new Error("OPENGENI_TOOLSPACE_URL is required");
-  let target;
-  try {
-    target = new URL(raw);
-  } catch {
-    throw new Error("OPENGENI_TOOLSPACE_URL must be a valid URL");
-  }
-  if (target.protocol !== "http:" && target.protocol !== "https:") {
-    throw new Error("OPENGENI_TOOLSPACE_URL must use http or https");
-  }
-  return target;
-}
-
-function readToken() {
-  const tokenFile = process.env.OPENGENI_TOOLSPACE_TOKEN_FILE;
-  if (!tokenFile) throw new Error("OPENGENI_TOOLSPACE_TOKEN_FILE is required");
-  let token;
-  try {
-    token = fs.readFileSync(tokenFile, "utf8").trim();
-  } catch {
-    throw new Error("OPENGENI_TOOLSPACE_TOKEN_FILE is not readable");
-  }
-  if (!token) throw new Error("OPENGENI_TOOLSPACE_TOKEN_FILE is empty");
-  return token;
-}
-
-function doctor() {
-  const tokenFile = process.env.OPENGENI_TOOLSPACE_TOKEN_FILE ?? null;
-  const rawUrl = process.env.OPENGENI_TOOLSPACE_URL ?? null;
-  let urlValid = false;
-  let protocol = null;
-  if (rawUrl) {
-    try {
-      const target = new URL(rawUrl);
-      protocol = target.protocol;
-      urlValid = protocol === "http:" || protocol === "https:";
-    } catch {
-      urlValid = false;
-    }
-  }
-  let tokenFileReadable = false;
-  let tokenFileNonempty = false;
-  if (tokenFile) {
-    try {
-      tokenFileReadable = fs.statSync(tokenFile).isFile();
-      tokenFileNonempty = tokenFileReadable && fs.readFileSync(tokenFile, "utf8").trim().length > 0;
-    } catch {
-      tokenFileReadable = false;
-    }
-  }
-  const ok = urlValid && tokenFileReadable && tokenFileNonempty;
-  process.stdout.write(
-    `${JSON.stringify(
-      {
-        ok,
-        package: PACKAGE_NAME,
-        version: VERSION,
-        node: process.version,
-        urlConfigured: rawUrl !== null,
-        urlValid,
-        protocol,
-        tokenFileConfigured: tokenFile !== null,
-        tokenFileReadable,
-        tokenFileNonempty,
-        packageSpec: process.env.OPENGENI_OGTOOL_PACKAGE_SPEC ?? null,
-      },
-      null,
-      2,
-    )}\n`,
-  );
-  process.exitCode = ok ? 0 : 1;
-}
-
-function parseEventStream(text) {
-  const messages = [];
-  for (const block of text.split(/\r?\n\r?\n/u)) {
-    const data = block
-      .split(/\r?\n/u)
-      .filter((line) => line.startsWith("data:"))
-      .map((line) => line.slice(5).trimStart())
-      .join("\n");
-    if (!data || data === "[DONE]") continue;
-    try {
-      messages.push(JSON.parse(data));
-    } catch {
-      throw new Error("Toolspace returned an invalid event-stream JSON message");
-    }
-  }
-  return messages.at(-1) ?? null;
-}
-
-function parseResponseBody(text, contentType) {
-  if (!text) return null;
-  if (contentType.toLowerCase().includes("text/event-stream")) {
-    return parseEventStream(text);
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error("Toolspace returned a non-JSON response");
-  }
-}
-
-class McpClient {
-  constructor(target, token) {
-    this.target = target;
-    this.token = token;
-    this.nextId = 1;
-    this.sessionId = null;
-    this.protocolVersion = DEFAULT_PROTOCOL_VERSION;
-    this.maxResponseBytes = positiveIntegerEnvironment(
-      "OPENGENI_OGTOOL_MAX_RESPONSE_BYTES",
-      DEFAULT_MAX_RESPONSE_BYTES,
-    );
-    this.timeoutMs = positiveIntegerEnvironment("OPENGENI_OGTOOL_TIMEOUT_MS", DEFAULT_TIMEOUT_MS);
-  }
-
-  rpc(method, params) {
-    return {
-      jsonrpc: "2.0",
-      id: this.nextId++,
-      method,
-      ...(params === undefined ? {} : { params }),
-    };
-  }
-
-  notify(method, params) {
-    return {
-      jsonrpc: "2.0",
-      method,
-      ...(params === undefined ? {} : { params }),
-    };
-  }
-
-  request(payload) {
-    const body = JSON.stringify(payload);
-    const transport = this.target.protocol === "https:" ? https : http;
-    const headers = {
-      accept: "application/json, text/event-stream",
-      authorization: `Bearer ${this.token}`,
-      "content-type": "application/json",
-      "content-length": Buffer.byteLength(body),
-      "mcp-protocol-version": this.protocolVersion,
-    };
-    if (this.sessionId) headers["mcp-session-id"] = this.sessionId;
-
-    return new Promise((resolve, reject) => {
-      const request = transport.request(
-        this.target,
-        { method: "POST", headers, timeout: this.timeoutMs },
-        (response) => {
-          const chunks = [];
-          let received = 0;
-          response.on("data", (chunk) => {
-            received += chunk.length;
-            if (received > this.maxResponseBytes) {
-              response.destroy(
-                new Error(`Toolspace response exceeds ${this.maxResponseBytes} bytes`),
-              );
-              return;
-            }
-            chunks.push(chunk);
-          });
-          response.on("error", reject);
-          response.on("end", () => {
-            const returnedSession = response.headers["mcp-session-id"];
-            if (typeof returnedSession === "string" && returnedSession) {
-              this.sessionId = returnedSession;
-            }
-            const text = Buffer.concat(chunks).toString("utf8");
-            const status = response.statusCode ?? 0;
-            if (status < 200 || status >= 300) {
-              const preview = text.replace(/\s+/gu, " ").trim().slice(0, 1_000);
-              reject(new Error(`Toolspace HTTP ${status}${preview ? `: ${preview}` : ""}`));
-              return;
-            }
-            try {
-              resolve(parseResponseBody(text, String(response.headers["content-type"] ?? "")));
-            } catch (error) {
-              reject(error);
-            }
-          });
-        },
-      );
-      request.on("timeout", () => request.destroy(new Error("Toolspace request timed out")));
-      request.on("error", reject);
-      request.end(body);
-    });
-  }
-
-  async initialize() {
-    const initialized = await this.request(
-      this.rpc("initialize", {
-        protocolVersion: DEFAULT_PROTOCOL_VERSION,
-        capabilities: {},
-        clientInfo: { name: "ogtool", version: VERSION },
-      }),
-    );
-    const negotiated = initialized?.result?.protocolVersion;
-    if (typeof negotiated === "string" && negotiated) this.protocolVersion = negotiated;
-    await this.request(this.notify("notifications/initialized"));
-  }
-}
-
-function parseToolArguments(raw) {
-  if (raw === undefined) return {};
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch {
-    throw new Error("tool arguments must be valid JSON");
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("tool arguments must be a JSON object");
-  }
-  return value;
-}
-
-async function main() {
-  const command = process.argv[2];
-  if (command === "--help" || command === "-h" || command === "help") {
-    usage(0);
-    return;
-  }
-  if (command === "--version" || command === "-V" || command === "version") {
-    process.stdout.write(`${VERSION}\n`);
-    return;
-  }
-  if (command === "doctor") {
-    doctor();
-    return;
-  }
-  if (!command) {
-    usage();
-    return;
-  }
-
-  const client = new McpClient(configuredEndpoint(), readToken());
-  await client.initialize();
-  let response;
-  if (command === "list" || command === "tools/list") {
-    response = await client.request(client.rpc("tools/list", {}));
-  } else if (command === "call" || command === "tools/call") {
-    const name = process.argv[3];
-    if (!name) throw new Error("tool name is required");
-    response = await client.request(
-      client.rpc("tools/call", { name, arguments: parseToolArguments(process.argv[4]) }),
-    );
-  } else {
-    usage();
-    return;
-  }
-
-  if (response?.error) {
-    process.stderr.write(`${JSON.stringify(response, null, 2)}\n`);
-    process.exitCode = 2;
-    return;
-  }
-  process.stdout.write(`${JSON.stringify(response?.result ?? response, null, 2)}\n`);
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-  });
-}
-
-module.exports = { McpClient, parseEventStream, parseResponseBody, parseToolArguments };