@yesod/openclaw 0.0.2 → 0.1.0

package/dist/mcp-entry.cjs

@@ -0,0 +1,886 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/mcp-entry.ts
+var import_core3 = require("@yesod/core");
+
+// src/adapter.ts
+var import_node_crypto2 = require("crypto");
+var import_core = require("@yesod/core");
+
+// src/websocket.ts
+var import_ws = __toESM(require("ws"), 1);
+
+// src/identity.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var PROTOCOL_VERSION = "v2";
+var DEFAULT_IDENTITY_PATH = (0, import_node_path.join)((0, import_node_os.homedir)(), ".yesod", "device.json");
+function generateDeviceIdentity() {
+  const { publicKey, privateKey } = (0, import_node_crypto.generateKeyPairSync)("ed25519");
+  const pubKeyDer = publicKey.export({ type: "spki", format: "der" });
+  const pubKeyRaw = pubKeyDer.subarray(pubKeyDer.length - 32);
+  const publicKeyB64Url = pubKeyRaw.toString("base64url");
+  const deviceId = (0, import_node_crypto.createHash)("sha256").update(pubKeyRaw).digest("hex");
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+  return { deviceId, publicKeyB64Url, privateKeyPem };
+}
+function signPayload(privateKeyPem, payload) {
+  const sig = (0, import_node_crypto.sign)(null, Buffer.from(payload), privateKeyPem);
+  return sig.toString("base64url");
+}
+function buildAuthPayload(deviceId, clientId, nonce, scopes, token = "") {
+  const signedAtMs = Date.now();
+  const parts = [
+    PROTOCOL_VERSION,
+    deviceId,
+    clientId,
+    clientId,
+    // clientMode = clientId
+    "operator",
+    scopes.join(","),
+    String(signedAtMs),
+    token,
+    nonce
+  ];
+  return { payload: parts.join("|"), signedAtMs };
+}
+
+// src/websocket.ts
+var PROTOCOL_VERSION2 = 3;
+var DEFAULT_SCOPES = ["operator.read", "operator.write", "operator.admin"];
+var GatewayWebSocketClient = class {
+  ws = null;
+  identity;
+  scopes;
+  clientId;
+  displayName;
+  reqCounter = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  eventHandlers = [];
+  connected = false;
+  disposed = false;
+  reconnectEnabled;
+  maxReconnectDelay;
+  reconnectDelay = 1e3;
+  reconnectTimer = null;
+  gatewayUrl;
+  constructor(config) {
+    this.gatewayUrl = config.gatewayUrl;
+    this.identity = config.identity ?? generateDeviceIdentity();
+    this.scopes = config.scopes ?? DEFAULT_SCOPES;
+    this.clientId = config.clientId ?? "cli";
+    this.displayName = config.displayName ?? "yesod";
+    this.reconnectEnabled = config.reconnect ?? false;
+    this.maxReconnectDelay = config.maxReconnectDelayMs ?? 3e4;
+  }
+  async connect() {
+    if (this.connected) return;
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws.default(this.gatewayUrl);
+      this.ws = ws;
+      const timeout = setTimeout(() => {
+        ws.close();
+        reject(new Error("Connection timeout"));
+      }, 15e3);
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+      ws.on("open", async () => {
+        try {
+          await this.handleAuth(ws);
+          clearTimeout(timeout);
+          this.connected = true;
+          this.reconnectDelay = 1e3;
+          this.setupMessageHandler(ws);
+          this.setupCloseHandler(ws);
+          resolve();
+        } catch (err) {
+          clearTimeout(timeout);
+          ws.close();
+          reject(err);
+        }
+      });
+    });
+  }
+  async handleAuth(ws) {
+    const challenge = await this.waitForFrame(
+      ws,
+      (f) => f.type === "event" && f.event === "connect.challenge",
+      1e4
+    );
+    const nonce = challenge.payload.nonce;
+    const { payload: authPayload, signedAtMs } = buildAuthPayload(
+      this.identity.deviceId,
+      this.clientId,
+      nonce,
+      this.scopes
+    );
+    const signature = signPayload(this.identity.privateKeyPem, authPayload);
+    const connectId = `r${++this.reqCounter}`;
+    const connectReq = {
+      type: "req",
+      id: connectId,
+      method: "connect",
+      params: {
+        minProtocol: PROTOCOL_VERSION2,
+        maxProtocol: PROTOCOL_VERSION2,
+        client: {
+          id: this.clientId,
+          displayName: this.displayName,
+          version: "0.0.2",
+          platform: "linux",
+          mode: this.clientId
+        },
+        role: "operator",
+        scopes: this.scopes,
+        caps: ["tool-events"],
+        device: {
+          id: this.identity.deviceId,
+          publicKey: this.identity.publicKeyB64Url,
+          signature,
+          signedAt: signedAtMs,
+          nonce
+        }
+      }
+    };
+    ws.send(JSON.stringify(connectReq));
+    const res = await this.waitForFrame(
+      ws,
+      (f) => f.type === "res" && f.id === connectId,
+      15e3
+    );
+    const resFrame = res;
+    if (!resFrame.ok) {
+      throw new Error(
+        `Connect failed: ${resFrame.error?.message ?? "unknown error"}`
+      );
+    }
+  }
+  waitForFrame(ws, filter, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => {
+          ws.off("message", handler);
+          reject(new Error("Timeout waiting for frame"));
+        },
+        timeoutMs
+      );
+      const handler = (data) => {
+        let frame;
+        try {
+          frame = JSON.parse(String(data));
+        } catch {
+          return;
+        }
+        if (!filter(frame)) return;
+        clearTimeout(timer);
+        ws.off("message", handler);
+        resolve(frame);
+      };
+      ws.on("message", handler);
+    });
+  }
+  setupMessageHandler(ws) {
+    ws.on("message", (data) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(data));
+      } catch {
+        return;
+      }
+      if (frame.type === "res") {
+        const pending = this.pendingRequests.get(frame.id);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(frame.id);
+          pending.resolve(frame);
+        }
+      } else if (frame.type === "event") {
+        for (const handler of this.eventHandlers) {
+          handler(frame);
+        }
+      }
+    });
+  }
+  setupCloseHandler(ws) {
+    ws.on("close", () => {
+      this.connected = false;
+      for (const [id, pending] of this.pendingRequests) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("Connection closed"));
+        this.pendingRequests.delete(id);
+      }
+      if (this.reconnectEnabled && !this.disposed) {
+        this.scheduleReconnect();
+      }
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+      } catch {
+        this.reconnectDelay = Math.min(
+          this.reconnectDelay * 2,
+          this.maxReconnectDelay
+        );
+        this.scheduleReconnect();
+      }
+    }, this.reconnectDelay);
+  }
+  async request(method, params = {}, timeoutMs = 3e4) {
+    if (!this.ws || !this.connected) {
+      throw new Error("Not connected");
+    }
+    const id = `r${++this.reqCounter}`;
+    const frame = { type: "req", id, method, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify(frame));
+    });
+  }
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+    return () => {
+      const idx = this.eventHandlers.indexOf(handler);
+      if (idx >= 0) this.eventHandlers.splice(idx, 1);
+    };
+  }
+  async subscribeToSession(sessionKey) {
+    await this.request("sessions.subscribe", { sessionKey });
+    await this.request("sessions.messages.subscribe", { sessionKey });
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async disconnect() {
+    this.disposed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  getIdentity() {
+    return this.identity;
+  }
+};
+
+// src/prompt.ts
+var FORMAT_INSTRUCTIONS = {
+  summary: "When you are done, output a final summary of what you accomplished. Keep it concise (1-3 paragraphs).",
+  structured: "When you are done, output your result as a JSON object with the requested fields. Wrap the JSON in a ```json code block.",
+  diff: 'When you are done, output a JSON object summarizing the changes: { "summary": "...", "filesChanged": [{ "path": "...", "linesAdded": N, "linesRemoved": N }] }. Wrap in a ```json code block.',
+  review: 'When you are done, output a JSON object: { "summary": "...", "findings": [{ "severity": "critical|high|medium|low|info", "location": "file:line", "issue": "..." }], "filesReviewed": ["..."] }. Wrap in a ```json code block.',
+  test: 'When you are done, output a JSON object: { "summary": "...", "passed": N, "failed": N, "skipped": N, "failures": [{ "test": "...", "error": "..." }] }. Wrap in a ```json code block.'
+};
+function formatPriorContext(results) {
+  const parts = results.map((r) => {
+    const status = r.status === "completed" ? "completed" : `${r.status}`;
+    let outputSummary;
+    if (r.output.format === "summary") {
+      outputSummary = r.output.summary;
+    } else if (r.output.format === "raw") {
+      outputSummary = r.output.raw.slice(0, 500);
+    } else if ("summary" in r.output) {
+      outputSummary = r.output.summary;
+    } else {
+      outputSummary = JSON.stringify(r.output).slice(0, 500);
+    }
+    return `[Step "${r.stepId}" \u2014 ${status}]
+${outputSummary}`;
+  });
+  return parts.join("\n\n");
+}
+function enrichInstruction(taskSpec) {
+  const parts = [];
+  if (taskSpec.priorContext && taskSpec.priorContext.length > 0) {
+    parts.push("## Context from prior steps\n");
+    parts.push(formatPriorContext(taskSpec.priorContext));
+    parts.push("");
+  }
+  parts.push(taskSpec.instruction);
+  const formatInstr = FORMAT_INSTRUCTIONS[taskSpec.expectedResult.format];
+  if (formatInstr) {
+    parts.push("");
+    parts.push("## Output format");
+    parts.push(formatInstr);
+  }
+  if (taskSpec.expectedResult.format === "structured" && taskSpec.expectedResult.fields?.length) {
+    parts.push(
+      `Include these fields: ${taskSpec.expectedResult.fields.join(", ")}`
+    );
+  }
+  if (taskSpec.expectedResult.maxLength) {
+    parts.push(
+      `Keep your output under ${taskSpec.expectedResult.maxLength} characters.`
+    );
+  }
+  return parts.join("\n");
+}
+
+// src/output-parser.ts
+function extractJsonBlock(text) {
+  const match = text.match(/```json\s*([\s\S]*?)```/);
+  if (match) return match[1].trim();
+  const objMatch = text.match(/\{[\s\S]*\}/);
+  if (objMatch) return objMatch[0];
+  return null;
+}
+function tryParse(text) {
+  const json = extractJsonBlock(text);
+  if (!json) return null;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function parseSummary(text, spec) {
+  const summary = spec.maxLength ? text.slice(0, spec.maxLength) : text;
+  return { format: "summary", summary };
+}
+function parseDiff(text) {
+  const obj = tryParse(text);
+  if (!obj || typeof obj.summary !== "string") return null;
+  return {
+    format: "diff",
+    summary: obj.summary,
+    filesChanged: Array.isArray(obj.filesChanged) ? obj.filesChanged.map((f) => ({
+      path: String(f.path ?? ""),
+      linesAdded: Number(f.linesAdded ?? 0),
+      linesRemoved: Number(f.linesRemoved ?? 0)
+    })) : []
+  };
+}
+function parseReview(text) {
+  const obj = tryParse(text);
+  if (!obj || typeof obj.summary !== "string") return null;
+  return {
+    format: "review",
+    summary: obj.summary,
+    findings: Array.isArray(obj.findings) ? obj.findings.map((f) => ({
+      severity: f.severity ?? "info",
+      location: String(f.location ?? ""),
+      issue: String(f.issue ?? "")
+    })) : [],
+    filesReviewed: Array.isArray(obj.filesReviewed) ? obj.filesReviewed.map(String) : []
+  };
+}
+function parseTest(text) {
+  const obj = tryParse(text);
+  if (!obj || typeof obj.summary !== "string") return null;
+  return {
+    format: "test",
+    summary: obj.summary,
+    passed: Number(obj.passed ?? 0),
+    failed: Number(obj.failed ?? 0),
+    skipped: Number(obj.skipped ?? 0),
+    failures: Array.isArray(obj.failures) ? obj.failures.map((f) => ({
+      test: String(f.test ?? ""),
+      error: String(f.error ?? "")
+    })) : []
+  };
+}
+function parseStructured(text, spec) {
+  const obj = tryParse(text);
+  if (!obj) return null;
+  const fields = {};
+  if (spec.fields?.length) {
+    for (const key of spec.fields) {
+      fields[key] = obj[key];
+    }
+  } else {
+    Object.assign(fields, obj);
+  }
+  return { format: "structured", fields };
+}
+function rawFallback(text, parseError) {
+  return { format: "raw", raw: text, parseError };
+}
+function parseOutput(rawText, spec) {
+  if (!rawText || rawText.trim().length === 0) {
+    return rawFallback(rawText, "Empty output");
+  }
+  switch (spec.format) {
+    case "summary":
+      return parseSummary(rawText, spec);
+    case "diff": {
+      const result = parseDiff(rawText);
+      return result ?? rawFallback(rawText, "Failed to parse diff output");
+    }
+    case "review": {
+      const result = parseReview(rawText);
+      return result ?? rawFallback(rawText, "Failed to parse review output");
+    }
+    case "test": {
+      const result = parseTest(rawText);
+      return result ?? rawFallback(rawText, "Failed to parse test output");
+    }
+    case "structured": {
+      const result = parseStructured(rawText, spec);
+      return result ?? rawFallback(rawText, "Failed to parse structured output");
+    }
+    default:
+      return rawFallback(rawText);
+  }
+}
+
+// src/adapter.ts
+var OpenClawAdapter = class {
+  name = "openclaw";
+  description = "OpenClaw gateway runtime adapter";
+  ws;
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  eventHandlers = [];
+  unsubscribeEvents = null;
+  constructor(config) {
+    this.config = config;
+    this.ws = new GatewayWebSocketClient({
+      gatewayUrl: config.gatewayUrl,
+      scopes: config.scopes,
+      reconnect: true
+    });
+  }
+  async connect() {
+    await this.ws.connect();
+    this.unsubscribeEvents = this.ws.onEvent(
+      (frame) => this.handleGatewayEvent(frame)
+    );
+  }
+  async spawn(opts) {
+    const instruction = enrichInstruction(opts.task);
+    const agentId = this.config.defaultAgentId ?? "test-orchestrator";
+    const res = await this.ws.request("sessions.create", {
+      agentId,
+      message: instruction
+    });
+    if (!res.ok || !res.payload) {
+      throw new Error(
+        `Failed to create session: ${res.error?.message ?? "unknown"}`
+      );
+    }
+    const sessionKey = res.payload.sessionKey;
+    const sessionId = res.payload.sessionId;
+    const handle = {
+      id: sessionId,
+      adapter: this.name,
+      metadata: {
+        sessionKey,
+        runId: res.payload.runId,
+        agentId
+      }
+    };
+    this.sessions.set(sessionId, {
+      handle,
+      sessionKey,
+      spawnOptions: opts,
+      startedAt: Date.now(),
+      accumulatedText: ""
+    });
+    await this.ws.subscribeToSession(sessionKey);
+    this.emitEvent({
+      id: (0, import_node_crypto2.randomUUID)(),
+      type: import_core.EventType.SessionSpawned,
+      source: this.name,
+      timestamp: Date.now(),
+      sessionId,
+      workflowId: opts.context?.workflowId,
+      stepId: opts.context?.stepId,
+      payload: {
+        agentId,
+        runtime: opts.runtime,
+        decision: opts.decision
+      }
+    });
+    return handle;
+  }
+  async send(session, message) {
+    const tracked = this.sessions.get(session.id);
+    if (!tracked) throw new Error(`Unknown session: ${session.id}`);
+    await this.ws.request("sessions.send", {
+      sessionKey: tracked.sessionKey,
+      message
+    });
+  }
+  async kill(session) {
+    const tracked = this.sessions.get(session.id);
+    if (!tracked) return;
+    try {
+      await this.ws.request("subagents", {
+        action: "kill",
+        target: session.id
+      });
+    } catch {
+    }
+    this.sessions.delete(session.id);
+    this.emitEvent({
+      id: (0, import_node_crypto2.randomUUID)(),
+      type: import_core.EventType.SessionKilled,
+      source: this.name,
+      timestamp: Date.now(),
+      sessionId: session.id,
+      payload: {}
+    });
+  }
+  async status(session) {
+    try {
+      const res = await this.ws.request("subagents", { action: "list" });
+      if (!res.ok) return "unknown";
+      const agents = res.payload?.agents ?? [];
+      const match = agents.find((a) => a.id === session.id);
+      if (!match) return this.sessions.has(session.id) ? "running" : null;
+      const statusMap = {
+        running: "running",
+        completed: "completed",
+        failed: "failed",
+        killed: "killed"
+      };
+      return statusMap[match.status] ?? "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+  }
+  async dispose() {
+    for (const [, tracked] of this.sessions) {
+      try {
+        await this.kill(tracked.handle);
+      } catch {
+      }
+    }
+    this.sessions.clear();
+    if (this.unsubscribeEvents) {
+      this.unsubscribeEvents();
+    }
+    await this.ws.disconnect();
+  }
+  // --- Internal ---
+  handleGatewayEvent(frame) {
+    if (frame.event === "agent") {
+      this.handleAgentEvent(frame);
+    } else if (frame.event === "chat") {
+      this.handleChatEvent(frame);
+    }
+  }
+  handleAgentEvent(frame) {
+    const payload = frame.payload;
+    if (payload.stream === "lifecycle") {
+      const lifecycle = payload;
+      if (lifecycle.phase === "complete") {
+        this.handleSessionComplete(frame);
+      } else if (lifecycle.phase === "error") {
+        this.handleSessionError(frame, lifecycle.error ?? "Unknown error");
+      }
+    } else if (payload.stream === "assistant") {
+      const delta = payload.delta;
+      if (delta) {
+        for (const [, tracked] of this.sessions) {
+          tracked.accumulatedText += delta;
+        }
+      }
+      this.emitEvent({
+        id: (0, import_node_crypto2.randomUUID)(),
+        type: import_core.EventType.SessionMessage,
+        source: this.name,
+        timestamp: Date.now(),
+        payload: { stream: "assistant", delta }
+      });
+    }
+  }
+  handleChatEvent(frame) {
+    const payload = frame.payload;
+    if (payload.state === "error") {
+      for (const [sessionId] of this.sessions) {
+        this.handleSessionError(
+          frame,
+          payload.errorMessage ?? "Chat error",
+          sessionId
+        );
+        break;
+      }
+    }
+  }
+  handleSessionComplete(frame) {
+    const sessionId = this.findSessionId(frame);
+    const tracked = sessionId ? this.sessions.get(sessionId) : null;
+    if (!tracked) return;
+    const lifecycle = frame.payload;
+    const durationMs = Date.now() - tracked.startedAt;
+    const cost = {
+      tokens: {
+        input: lifecycle.cost?.input ?? 0,
+        output: lifecycle.cost?.output ?? 0,
+        cacheRead: lifecycle.cost?.cacheRead,
+        cacheWrite: lifecycle.cost?.cacheWrite
+      },
+      usd: lifecycle.cost?.totalCost ?? 0,
+      runtime: tracked.spawnOptions.runtime
+    };
+    const output = parseOutput(
+      tracked.accumulatedText,
+      tracked.spawnOptions.task.expectedResult
+    );
+    const stepResult = {
+      stepId: tracked.spawnOptions.context?.stepId ?? sessionId,
+      status: "completed",
+      output,
+      meta: {
+        runtime: tracked.spawnOptions.runtime,
+        decision: tracked.spawnOptions.decision,
+        cost,
+        durationMs,
+        retries: (tracked.spawnOptions.context?.attempt ?? 1) - 1
+      }
+    };
+    this.sessions.delete(sessionId);
+    this.emitEvent({
+      id: (0, import_node_crypto2.randomUUID)(),
+      type: import_core.EventType.SessionCompleted,
+      source: this.name,
+      timestamp: Date.now(),
+      sessionId,
+      workflowId: tracked.spawnOptions.context?.workflowId,
+      stepId: tracked.spawnOptions.context?.stepId,
+      payload: { stepResult },
+      metadata: { cost, duration: durationMs }
+    });
+  }
+  handleSessionError(frame, error, overrideSessionId) {
+    const sessionId = overrideSessionId ?? this.findSessionId(frame);
+    const tracked = sessionId ? this.sessions.get(sessionId) : null;
+    if (!tracked) return;
+    const durationMs = Date.now() - tracked.startedAt;
+    this.sessions.delete(sessionId);
+    this.emitEvent({
+      id: (0, import_node_crypto2.randomUUID)(),
+      type: import_core.EventType.SessionFailed,
+      source: this.name,
+      timestamp: Date.now(),
+      sessionId,
+      workflowId: tracked.spawnOptions.context?.workflowId,
+      stepId: tracked.spawnOptions.context?.stepId,
+      payload: { error },
+      metadata: { duration: durationMs }
+    });
+  }
+  findSessionId(frame) {
+    const fromPayload = frame.payload.sessionId;
+    if (fromPayload && this.sessions.has(fromPayload)) return fromPayload;
+    if (this.sessions.size === 1) {
+      return this.sessions.keys().next().value;
+    }
+    return void 0;
+  }
+  emitEvent(event) {
+    for (const handler of this.eventHandlers) {
+      handler(event);
+    }
+  }
+};
+
+// src/mcp-server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_core2 = require("@yesod/core");
+function createYesodMcpServer(engine) {
+  const server = new import_mcp.McpServer({
+    name: "yesod",
+    version: "0.0.2"
+  });
+  server.tool(
+    import_core2.YESOD_TOOLS.yesod_create_workflow.name,
+    import_core2.YESOD_TOOLS.yesod_create_workflow.description,
+    import_core2.YESOD_TOOLS.yesod_create_workflow.inputSchema.properties,
+    async (args) => {
+      const name = args.name;
+      const steps = args.steps.map(
+        (s) => ({
+          id: s.id,
+          name: s.name,
+          task: s.task,
+          expectedResult: s.expectedResult,
+          runtime: s.runtime,
+          decision: s.decision,
+          dependsOn: s.dependsOn ?? [],
+          timeout: s.timeout
+        })
+      );
+      const workflow = {
+        id: "",
+        name,
+        steps,
+        state: "created",
+        createdAt: Date.now()
+      };
+      const created = engine.createWorkflow(workflow);
+      await engine.startWorkflow(created.id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                workflowId: created.id,
+                status: "started",
+                steps: created.steps.map((s) => s.id)
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    import_core2.YESOD_TOOLS.yesod_workflow_status.name,
+    import_core2.YESOD_TOOLS.yesod_workflow_status.description,
+    import_core2.YESOD_TOOLS.yesod_workflow_status.inputSchema.properties,
+    async (args) => {
+      const workflowId = args.workflowId;
+      try {
+        const status = engine.getWorkflowStatus(workflowId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(status, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    import_core2.YESOD_TOOLS.yesod_cancel_workflow.name,
+    import_core2.YESOD_TOOLS.yesod_cancel_workflow.description,
+    import_core2.YESOD_TOOLS.yesod_cancel_workflow.inputSchema.properties,
+    async (args) => {
+      const workflowId = args.workflowId;
+      try {
+        await engine.cancelWorkflow(workflowId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ workflowId, status: "cancelled" })
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    import_core2.YESOD_TOOLS.yesod_cost_summary.name,
+    import_core2.YESOD_TOOLS.yesod_cost_summary.description,
+    import_core2.YESOD_TOOLS.yesod_cost_summary.inputSchema.properties ?? {},
+    async (args) => {
+      const workflowId = args.workflowId;
+      const summary = engine.getCostSummary(workflowId);
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(summary, null, 2) }
+        ]
+      };
+    }
+  );
+  return server;
+}
+async function startMcpServer(engine) {
+  const server = createYesodMcpServer(engine);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/mcp-entry.ts
+var GATEWAY_URL = process.env.YESOD_GATEWAY_URL ?? "ws://127.0.0.1:3578";
+var AGENT_ID = process.env.YESOD_AGENT_ID ?? "test-orchestrator";
+async function main() {
+  const bus = new import_core3.EventBus();
+  const storage = new import_core3.InMemoryStorageAdapter();
+  const _vantage = new import_core3.VantageEngine();
+  const adapter = new OpenClawAdapter({
+    gatewayUrl: GATEWAY_URL,
+    defaultAgentId: AGENT_ID
+  });
+  try {
+    await adapter.connect();
+  } catch (err) {
+    console.error(
+      `[yesod] Failed to connect to gateway at ${GATEWAY_URL}:`,
+      err instanceof Error ? err.message : err
+    );
+    process.exit(1);
+  }
+  const engine = new import_core3.OrchestrationEngine(adapter, bus, storage);
+  adapter.onEvent((event) => bus.emit(event));
+  await startMcpServer(engine);
+  const shutdown = async () => {
+    await adapter.dispose();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  console.error("[yesod] Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp-entry.cjs.map