@seastudio/sdk 3.0.0

package/dist/chunk-TFOJLA2F.cjs

@@ -0,0 +1,588 @@
+'use strict';
+
+// src/mcp/core/types.ts
+function isNotification(message) {
+  return !("id" in message) && "method" in message;
+}
+function isMCPMessage(data) {
+  return typeof data === "object" && data !== null && data.type === "mcp" && "payload" in data;
+}
+function createRequest(method, params) {
+  return {
+    jsonrpc: "2.0",
+    id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    method,
+    params
+  };
+}
+function createResponse(id, result, error) {
+  const response = { jsonrpc: "2.0", id };
+  if (error) {
+    response.error = error;
+  } else {
+    response.result = result;
+  }
+  return response;
+}
+function createNotification(method, params) {
+  return {
+    jsonrpc: "2.0",
+    method,
+    params
+  };
+}
+
+// src/mcp/core/schema.ts
+var DEFAULT_OBJECT_SCHEMA = {
+  type: "object",
+  properties: {}
+};
+function cloneProperties(properties) {
+  if (!properties || typeof properties !== "object") {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(properties).map(([key, value]) => [
+      key,
+      normalizeMCPToolInputSchema(value)
+    ])
+  );
+}
+function readSchemaType(schema) {
+  const rawType = schema.type;
+  if (typeof rawType === "string") {
+    return rawType;
+  }
+  if (Array.isArray(rawType)) {
+    const supportedType = rawType.find(
+      (value) => ["object", "array", "string", "number", "integer", "boolean", "null"].includes(String(value))
+    );
+    return typeof supportedType === "string" ? supportedType : void 0;
+  }
+  return void 0;
+}
+function inferSchemaType(schema, fallbackType) {
+  const explicitType = readSchemaType(schema);
+  if (explicitType) {
+    return explicitType;
+  }
+  if (schema.properties || schema.required || Object.prototype.hasOwnProperty.call(schema, "additionalProperties")) {
+    return "object";
+  }
+  if (schema.items) {
+    return "array";
+  }
+  if (schema.enum || schema.oneOf || schema.anyOf || schema.allOf) {
+    return fallbackType ?? "string";
+  }
+  return fallbackType ?? "string";
+}
+function normalizeMCPToolInputSchema(schema, options = {}) {
+  const fallbackType = options.defaultType ?? "string";
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return {
+      ...DEFAULT_OBJECT_SCHEMA,
+      type: fallbackType
+    };
+  }
+  const normalized = { ...schema };
+  normalized.type = inferSchemaType(normalized, fallbackType);
+  const properties = cloneProperties(normalized.properties);
+  if (properties) {
+    normalized.properties = properties;
+  } else if (normalized.type === "object") {
+    normalized.properties = {};
+  } else {
+    delete normalized.properties;
+  }
+  if (Array.isArray(normalized.required)) {
+    normalized.required = [...normalized.required];
+  }
+  if (Array.isArray(normalized.enum)) {
+    normalized.enum = [...normalized.enum];
+  }
+  if (Array.isArray(normalized.oneOf)) {
+    normalized.oneOf = normalized.oneOf.map(
+      (item) => normalizeMCPToolInputSchema(item)
+    );
+  }
+  if (Array.isArray(normalized.anyOf)) {
+    normalized.anyOf = normalized.anyOf.map(
+      (item) => normalizeMCPToolInputSchema(item)
+    );
+  }
+  if (Array.isArray(normalized.allOf)) {
+    normalized.allOf = normalized.allOf.map(
+      (item) => normalizeMCPToolInputSchema(item)
+    );
+  }
+  if (Array.isArray(normalized.items)) {
+    normalized.items = normalized.items.map(
+      (item) => normalizeMCPToolInputSchema(item)
+    );
+  } else if (normalized.items && typeof normalized.items === "object") {
+    normalized.items = normalizeMCPToolInputSchema(normalized.items);
+  }
+  if (normalized.additionalProperties && typeof normalized.additionalProperties === "object" && !Array.isArray(normalized.additionalProperties)) {
+    normalized.additionalProperties = normalizeMCPToolInputSchema(
+      normalized.additionalProperties
+    );
+  }
+  if (normalized.type === "array" && !normalized.items) {
+    normalized.items = { type: "string" };
+  }
+  return normalized;
+}
+function normalizeMCPToolObjectSchema(schema) {
+  return normalizeMCPToolInputSchema(schema, { defaultType: "object" });
+}
+function normalizeMCPTool(tool) {
+  return {
+    ...tool,
+    inputSchema: normalizeMCPToolObjectSchema(tool.inputSchema),
+    ...tool.outputSchema ? { outputSchema: normalizeMCPToolObjectSchema(tool.outputSchema) } : {},
+    ...tool.annotations ? { annotations: { ...tool.annotations } } : {}
+  };
+}
+
+// src/mcp/core/transport.ts
+var PostMessageTransport = class {
+  constructor(options = {}) {
+    this.handlers = /* @__PURE__ */ new Set();
+    this.messageListener = null;
+    this.target = options.target ?? window.parent;
+    this.origin = options.origin ?? "*";
+    this.setupListener();
+  }
+  setupListener() {
+    this.messageListener = (event) => {
+      if (this.origin !== "*" && event.origin !== this.origin) {
+        return;
+      }
+      if (!isMCPMessage(event.data)) {
+        return;
+      }
+      const { payload } = event.data;
+      this.handlers.forEach((handler) => {
+        try {
+          handler(payload);
+        } catch (error) {
+          console.error("[MCPTransport] Handler error:", error);
+        }
+      });
+    };
+    window.addEventListener("message", this.messageListener);
+  }
+  send(message) {
+    const envelope = {
+      type: "mcp",
+      payload: message
+    };
+    this.target.postMessage(envelope, this.origin);
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  destroy() {
+    if (this.messageListener) {
+      window.removeEventListener("message", this.messageListener);
+      this.messageListener = null;
+    }
+    this.handlers.clear();
+  }
+};
+var defaultTransport = null;
+function getDefaultTransport() {
+  if (!defaultTransport) {
+    defaultTransport = new PostMessageTransport();
+  }
+  return defaultTransport;
+}
+function setDefaultTransport(transport) {
+  defaultTransport = transport;
+}
+
+// src/mcp/core/client.ts
+var LONG_RUNNING_TOOL_TIMEOUTS = /* @__PURE__ */ new Set([
+  "seaflow-canvas_task_wait_result",
+  "seaflow-canvas_execute_node_and_wait",
+  "seaflow-canvas_task_reconnect"
+]);
+var LONG_RUNNING_TOOL_TIMEOUT_MS = 125e3;
+var readPositiveTimeout = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return Math.floor(value);
+};
+var MCPClient = class {
+  constructor(options = {}) {
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.notificationHandlers = /* @__PURE__ */ new Map();
+    this.unsubscribe = null;
+    this.transport = options.transport ?? getDefaultTransport();
+    this.timeout = options.timeout ?? 3e4;
+    this.setupResponseHandler();
+  }
+  setupResponseHandler() {
+    this.unsubscribe = this.transport.onMessage((message) => {
+      if (isNotification(message)) {
+        this.handleNotification(message);
+        return;
+      }
+      if (!("id" in message) || message.id === void 0) {
+        return;
+      }
+      const pending = this.pendingRequests.get(message.id);
+      if (!pending) {
+        return;
+      }
+      clearTimeout(pending.timer);
+      this.pendingRequests.delete(message.id);
+      const response = message;
+      if (response.error) {
+        pending.reject(new Error(response.error.message));
+      } else {
+        pending.resolve(response.result);
+      }
+    });
+  }
+  handleNotification(notification) {
+    const { method, params } = notification;
+    const handlers = this.notificationHandlers.get(method);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(params ?? {});
+        } catch (error) {
+          console.error(`Notification handler error for ${method}:`, error);
+        }
+      }
+    }
+  }
+  async request(method, params, options) {
+    const req = createRequest(method, params);
+    const timeoutMs = readPositiveTimeout(options?.timeout) ?? this.timeout;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(req.id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, timeoutMs);
+      this.pendingRequests.set(req.id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.transport.send(req);
+    });
+  }
+  resolveToolCallTimeout(name, args, options) {
+    const explicitTimeout = readPositiveTimeout(options?.timeout);
+    if (explicitTimeout != null) {
+      return explicitTimeout;
+    }
+    const argTimeout = readPositiveTimeout(args.timeoutMs) ?? readPositiveTimeout(args.timeout);
+    if (argTimeout != null) {
+      return Math.max(this.timeout, argTimeout + 5e3);
+    }
+    if (LONG_RUNNING_TOOL_TIMEOUTS.has(name)) {
+      return Math.max(this.timeout, LONG_RUNNING_TOOL_TIMEOUT_MS);
+    }
+    return this.timeout;
+  }
+  async callTool(name, args = {}, options) {
+    return this.request("tools/call", {
+      name,
+      arguments: args
+    }, {
+      timeout: this.resolveToolCallTimeout(name, args, options)
+    });
+  }
+  async callToolText(name, args = {}, options) {
+    const result = await this.callTool(name, args, options);
+    if (result.isError) {
+      const errorText = result.content.find((c) => c.type === "text")?.text ?? "Unknown error";
+      throw new Error(errorText);
+    }
+    return result.content.find((c) => c.type === "text")?.text ?? "";
+  }
+  async ping() {
+    try {
+      await this.request("ping");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async subscribe(topics) {
+    await this.request("notifications/subscribe", { topics });
+  }
+  async unsubscribeTopics(topics) {
+    await this.request("notifications/unsubscribe", { topics });
+  }
+  async publish(topic, data = {}) {
+    await this.request("notifications/publish", { topic, data });
+  }
+  onNotification(topic, handler) {
+    let handlers = this.notificationHandlers.get(topic);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.notificationHandlers.set(topic, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers?.delete(handler);
+      if (handlers?.size === 0) {
+        this.notificationHandlers.delete(topic);
+      }
+    };
+  }
+  offNotification(topic, handler) {
+    if (!handler) {
+      this.notificationHandlers.delete(topic);
+      return;
+    }
+    const handlers = this.notificationHandlers.get(topic);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.notificationHandlers.delete(topic);
+      }
+    }
+  }
+  destroy() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Client destroyed"));
+    }
+    this.pendingRequests.clear();
+    this.notificationHandlers.clear();
+  }
+};
+var defaultClient = null;
+function createMCPClient(options) {
+  return new MCPClient(options);
+}
+function getDefaultClient() {
+  if (!defaultClient) {
+    defaultClient = createMCPClient();
+  }
+  return defaultClient;
+}
+function setDefaultClient(client) {
+  defaultClient = client;
+}
+async function callHostTool(toolName, args = {}) {
+  return getDefaultClient().callTool(toolName, args);
+}
+async function callHostToolText(toolName, args = {}) {
+  return getDefaultClient().callToolText(toolName, args);
+}
+
+// src/mcp/core/server.ts
+var MCPServer = class {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+    this.notificationHandlers = /* @__PURE__ */ new Map();
+    this.unsubscribe = null;
+  }
+  registerTool(definition, handler) {
+    this.tools.set(definition.name, { definition, handler });
+  }
+  registerTools(definitions, handlers) {
+    for (const def of definitions) {
+      const handler = handlers[def.name];
+      if (handler) {
+        this.registerTool(def, handler);
+      }
+    }
+  }
+  getTools() {
+    return Array.from(this.tools.values()).map((t) => t.definition);
+  }
+  async handleMessage(request) {
+    const { id, method, params } = request;
+    if (method === "tools/list") {
+      return createResponse(id, { tools: this.getTools() });
+    }
+    if (method === "tools/call") {
+      const name = params?.name;
+      const args = params?.arguments ?? {};
+      if (!name) {
+        return createResponse(id, void 0, {
+          code: -32602,
+          message: "Missing tool name"
+        });
+      }
+      const tool = this.tools.get(name);
+      if (!tool) {
+        return createResponse(id, void 0, {
+          code: -32601,
+          message: `Tool not found: ${name}`
+        });
+      }
+      try {
+        const result = await tool.handler(args);
+        return createResponse(id, result);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createResponse(id, {
+          content: [{ type: "text", text: message }],
+          isError: true
+        });
+      }
+    }
+    if (method === "ping") {
+      return createResponse(id, { pong: true });
+    }
+    return null;
+  }
+  sendNotification(method, params) {
+    const notification = createNotification(method, params);
+    window.parent.postMessage({ type: "mcp", payload: notification }, "*");
+  }
+  onNotification(topic, handler) {
+    let handlers = this.notificationHandlers.get(topic);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.notificationHandlers.set(topic, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers?.delete(handler);
+      if (handlers?.size === 0) {
+        this.notificationHandlers.delete(topic);
+      }
+    };
+  }
+  offNotification(topic, handler) {
+    if (!handler) {
+      this.notificationHandlers.delete(topic);
+      return;
+    }
+    const handlers = this.notificationHandlers.get(topic);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.notificationHandlers.delete(topic);
+      }
+    }
+  }
+  handleNotification(notification) {
+    const { method, params } = notification;
+    const handlers = this.notificationHandlers.get(method);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(params ?? {});
+        } catch (error) {
+          console.error(`Server notification handler error for ${method}:`, error);
+        }
+      }
+    }
+  }
+  start() {
+    if (this.unsubscribe) return;
+    const handler = async (event) => {
+      const data = event.data;
+      if (data?.type === "mcp:tool-call") {
+        const { callId, toolName, args } = data;
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+          window.parent.postMessage(
+            {
+              type: "mcp:tool-result",
+              callId,
+              result: {
+                content: [{ type: "text", text: `Tool not found: ${toolName}` }],
+                isError: true
+              }
+            },
+            "*"
+          );
+          return;
+        }
+        try {
+          const result = await tool.handler(args ?? {});
+          window.parent.postMessage({ type: "mcp:tool-result", callId, result }, "*");
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          window.parent.postMessage(
+            {
+              type: "mcp:tool-result",
+              callId,
+              result: {
+                content: [{ type: "text", text: message }],
+                isError: true
+              }
+            },
+            "*"
+          );
+        }
+        return;
+      }
+      if (!isMCPMessage(data)) return;
+      const { payload } = data;
+      if (isNotification(payload)) {
+        this.handleNotification(payload);
+        return;
+      }
+      if (!("id" in payload) || !("method" in payload)) return;
+      const response = await this.handleMessage(payload);
+      if (response) {
+        window.parent.postMessage({ type: "mcp", payload: response }, "*");
+      }
+    };
+    window.addEventListener("message", handler);
+    this.unsubscribe = () => window.removeEventListener("message", handler);
+  }
+  stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    this.notificationHandlers.clear();
+  }
+};
+var defaultServer = null;
+function createMCPServer() {
+  return new MCPServer();
+}
+function getDefaultServer() {
+  if (!defaultServer) {
+    defaultServer = createMCPServer();
+  }
+  return defaultServer;
+}
+function startDefaultServer() {
+  getDefaultServer().start();
+}
+
+exports.MCPClient = MCPClient;
+exports.MCPServer = MCPServer;
+exports.PostMessageTransport = PostMessageTransport;
+exports.callHostTool = callHostTool;
+exports.callHostToolText = callHostToolText;
+exports.createMCPClient = createMCPClient;
+exports.createMCPServer = createMCPServer;
+exports.createNotification = createNotification;
+exports.createRequest = createRequest;
+exports.createResponse = createResponse;
+exports.getDefaultClient = getDefaultClient;
+exports.getDefaultServer = getDefaultServer;
+exports.getDefaultTransport = getDefaultTransport;
+exports.isMCPMessage = isMCPMessage;
+exports.isNotification = isNotification;
+exports.normalizeMCPTool = normalizeMCPTool;
+exports.normalizeMCPToolInputSchema = normalizeMCPToolInputSchema;
+exports.normalizeMCPToolObjectSchema = normalizeMCPToolObjectSchema;
+exports.setDefaultClient = setDefaultClient;
+exports.setDefaultTransport = setDefaultTransport;
+exports.startDefaultServer = startDefaultServer;