@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/WebContainerManager-SHXC5VKI.js

@@ -0,0 +1,22 @@
+import {
+  ProcessPriority,
+  WebContainerManager,
+  WebContainerManager_default
+} from "./chunk-SHPGIVDH.js";
+import "./chunk-DKFJIILR.js";
+import "./chunk-KHR7ZYCX.js";
+import "./chunk-QWZRZKLZ.js";
+import "./chunk-OSSRZOGC.js";
+import "./chunk-TSQ3BGLA.js";
+import "./chunk-2WTYE4SW.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-WGBCRNMB.js";
+import "./chunk-3LFMIVJM.js";
+import "./chunk-AFDUOYHD.js";
+import "./chunk-NTMBOESX.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  ProcessPriority,
+  WebContainerManager,
+  WebContainerManager_default as default
+};

package/dist/browser-http-client-ZQLDWZMU.js

@@ -0,0 +1,317 @@
+import {
+  ErrorCodes,
+  MCPError
+} from "./chunk-OSSRZOGC.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/interfaces/mcp/browser-http-client.ts
+var MCPHTTPClient = class {
+  config;
+  baseUrl;
+  sessionId = null;
+  requestId = 0;
+  notificationPollingInterval = null;
+  isPolling = false;
+  notificationHandlers = /* @__PURE__ */ new Map();
+  elicitationHandlers = /* @__PURE__ */ new Map();
+  protocolVersion = "2025-06-18";
+  authToken = null;
+  resourceIndicator = null;
+  constructor(config, auth) {
+    this.config = {
+      ...config,
+      capabilities: {
+        experimental: {},
+        elicitation: true,
+        structuredContent: true,
+        ...config.capabilities
+      }
+    };
+    this.baseUrl = "";
+    this.authToken = auth?.token || null;
+    this.resourceIndicator = auth?.resourceIndicator || null;
+  }
+  async connect(url) {
+    this.baseUrl = url;
+    try {
+      const initRequest = {
+        jsonrpc: "2.0",
+        id: this.getNextId(),
+        method: "initialize",
+        params: {
+          protocolVersion: this.protocolVersion,
+          capabilities: this.config.capabilities,
+          clientInfo: {
+            name: this.config.name,
+            version: this.config.version
+          }
+        }
+      };
+      const response = await this.sendRequestWithRetry(initRequest, 3);
+      if (response.error) {
+        throw new MCPError(
+          `Failed to initialize: ${response.error.message}`,
+          ErrorCodes.MCP_CONNECTION_FAILED,
+          { url, errorCode: response.error.code, errorData: response.error.data }
+        );
+      }
+      await this.sendNotification("initialized", {});
+      if (this.sessionId) {
+        this.startNotificationPolling();
+      }
+      console.log(
+        "[MCPHTTPClient] Connected to",
+        url,
+        "using protocol version",
+        this.protocolVersion
+      );
+    } catch (error) {
+      console.error("[MCPHTTPClient] Connection failed:", error);
+      throw new MCPError(
+        `Failed to connect to MCP server: ${error instanceof Error ? error.message : String(error)}`,
+        ErrorCodes.MCP_CONNECTION_FAILED,
+        { url, originalError: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  }
+  startNotificationPolling() {
+    if (this.isPolling || !this.sessionId) return;
+    this.isPolling = true;
+    this.notificationPollingInterval = setInterval(async () => {
+      try {
+        const response = await fetch(`${this.baseUrl}?action=poll`, {
+          method: "GET",
+          headers: {
+            "MCP-Protocol-Version": this.protocolVersion,
+            "mcp-session-id": this.sessionId,
+            ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {},
+            ...this.resourceIndicator ? { "Resource-Indicator": this.resourceIndicator } : {}
+          }
+        });
+        if (response.ok) {
+          const notifications = await response.json();
+          if (Array.isArray(notifications)) {
+            notifications.forEach((notification) => this.handleNotification(notification));
+          }
+        }
+      } catch (error) {
+        console.warn("[MCPHTTPClient] Notification polling error:", error);
+      }
+    }, 1e3);
+  }
+  stopNotificationPolling() {
+    if (this.notificationPollingInterval) {
+      clearInterval(this.notificationPollingInterval);
+      this.notificationPollingInterval = null;
+    }
+    this.isPolling = false;
+  }
+  async sendRequestWithRetry(request, maxRetries = 3) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await this.sendRequest(request);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        console.warn(
+          `[MCPHTTPClient] Request attempt ${attempt}/${maxRetries} failed:`,
+          lastError.message
+        );
+        if (attempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, attempt - 1)));
+        }
+      }
+    }
+    if (lastError) {
+      throw lastError;
+    }
+    throw new Error("Request failed after max retries");
+  }
+  handleNotification(notification) {
+    if (!notification.method) return;
+    if (notification.method === "elicitationRequest") {
+      this.handleElicitationRequest(notification.params);
+      return;
+    }
+    const handler = this.notificationHandlers.get(notification.method);
+    if (handler) {
+      handler(notification.params || {});
+    }
+  }
+  async handleElicitationRequest(params) {
+    const handler = this.elicitationHandlers.get("default");
+    if (handler) {
+      try {
+        const response = await handler(params);
+        await this.request("continueElicitation", response);
+      } catch (error) {
+        console.error("[MCPHTTPClient] Elicitation handler error:", error);
+      }
+    }
+  }
+  onNotification(method, handler) {
+    this.notificationHandlers.set(method, handler);
+  }
+  onElicitation(handler) {
+    this.elicitationHandlers.set("default", handler);
+  }
+  getNextId() {
+    return `${++this.requestId}`;
+  }
+  async sendRequest(request) {
+    const headers = {
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": this.protocolVersion
+      // Required in 2025-06-18 spec
+    };
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    if (this.resourceIndicator) {
+      headers["Resource-Indicator"] = this.resourceIndicator;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const newSessionId = response.headers.get("mcp-session-id");
+      if (newSessionId && !this.sessionId) {
+        this.sessionId = newSessionId;
+        this.startNotificationPolling();
+      }
+      if (!response.ok) {
+        throw new MCPError(
+          `HTTP error! status: ${response.status}`,
+          ErrorCodes.MCP_CONNECTION_FAILED,
+          { baseUrl: this.baseUrl, status: response.status, method: request.method }
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new MCPError("Request timeout after 30 seconds", ErrorCodes.MCP_CONNECTION_FAILED, {
+          baseUrl: this.baseUrl,
+          method: request.method,
+          timeout: 3e4
+        });
+      }
+      if (error instanceof MCPError) {
+        throw error;
+      }
+      throw new MCPError(
+        `Request failed: ${error instanceof Error ? error.message : String(error)}`,
+        ErrorCodes.MCP_CONNECTION_FAILED,
+        {
+          baseUrl: this.baseUrl,
+          method: request.method,
+          originalError: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  async sendNotification(method, params) {
+    const notification = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    const headers = {
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": this.protocolVersion
+    };
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    if (this.resourceIndicator) {
+      headers["Resource-Indicator"] = this.resourceIndicator;
+    }
+    await fetch(this.baseUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(notification)
+    });
+  }
+  async request(method, params) {
+    const request = {
+      jsonrpc: "2.0",
+      id: this.getNextId(),
+      method,
+      params
+    };
+    const response = await this.sendRequest(request);
+    if (response.error) {
+      throw new MCPError(
+        `RPC error ${response.error.code}: ${response.error.message}`,
+        ErrorCodes.MCP_TOOL_EXECUTION_FAILED,
+        { method, errorCode: response.error.code, errorData: response.error.data }
+      );
+    }
+    return response.result;
+  }
+  async listTools() {
+    return await this.request("tools/list");
+  }
+  async callTool(toolRequest) {
+    return await this.request("tools/call", {
+      name: toolRequest.name,
+      arguments: toolRequest.arguments,
+      _meta: toolRequest._meta
+    });
+  }
+  async listResources() {
+    return await this.request("resources/list");
+  }
+  async readResource(uri, _meta) {
+    return await this.request("resources/read", { uri, _meta });
+  }
+  async listPrompts() {
+    return await this.request("prompts/list");
+  }
+  async getPrompt(name, args, context) {
+    return await this.request("prompts/get", {
+      name,
+      arguments: args,
+      context
+      // New context field support
+    });
+  }
+  // New completion support with context
+  async complete(request) {
+    return await this.request("completion/complete", request);
+  }
+  // Elicitation continuation support
+  async continueElicitation(response) {
+    return await this.request("continueElicitation", response);
+  }
+  async close() {
+    this.stopNotificationPolling();
+    if (this.sessionId) {
+      await fetch(this.baseUrl, {
+        method: "DELETE",
+        headers: {
+          "MCP-Protocol-Version": this.protocolVersion,
+          "mcp-session-id": this.sessionId,
+          ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {},
+          ...this.resourceIndicator ? { "Resource-Indicator": this.resourceIndicator } : {}
+        }
+      });
+      this.sessionId = null;
+    }
+  }
+};
+export {
+  MCPHTTPClient
+};

package/dist/cache-VKYSQRXX.js

@@ -0,0 +1,45 @@
+import {
+  getGlobalStore
+} from "./chunk-VZA2NUH3.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-EXI3LJVJ.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/cache.ts
+function stableStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (v) => {
+    if (v === null || typeof v !== "object") return v;
+    if (seen.has(v)) return v;
+    seen.add(v);
+    if (Array.isArray(v)) return v.map(walk);
+    const out = {};
+    for (const k of Object.keys(v).sort())
+      out[k] = walk(v[k]);
+    return out;
+  };
+  return JSON.stringify(walk(value));
+}
+var store = getGlobalStore("output_cache");
+var enabled = true;
+function makeKey(shapeHash, nodeId, input) {
+  return `${shapeHash || "shape:none"}::${nodeId}::${stableStringify(input)}`;
+}
+function getCachedOutput(key) {
+  if (!enabled) return null;
+  const rec = store.get(key);
+  return rec ? rec.output : null;
+}
+function setCachedOutput(key, output) {
+  if (!enabled) return;
+  store.set(key, { output, ts: Date.now() });
+}
+function setCacheEnabled(on) {
+  enabled = on;
+}
+export {
+  getCachedOutput,
+  makeKey,
+  setCacheEnabled,
+  setCachedOutput
+};

package/dist/capabilities-MIPUMBLL.js

@@ -0,0 +1,96 @@
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/capabilities.ts
+async function probeCapabilities() {
+  const g = globalThis;
+  const snap = {
+    vector: false,
+    pgTrgm: false,
+    webgpu: typeof g.navigator !== "undefined" && !!g.navigator?.gpu,
+    wasm: await supportsWasm(),
+    sab: typeof g.SharedArrayBuffer !== "undefined",
+    coi: typeof g.window !== "undefined" ? g.window.crossOriginIsolated === true : false,
+    storageBytes: void 0,
+    timestamp: Date.now()
+  };
+  try {
+    const nav = navigator;
+    if (typeof navigator !== "undefined" && nav.storage?.estimate) {
+      const est = await nav.storage.estimate();
+      snap.storageBytes = est?.usage || 0;
+    }
+  } catch {
+  }
+  return snap;
+}
+async function checkWebGPUSupportDetailed() {
+  const g = globalThis;
+  const nav = g.navigator;
+  if (typeof nav === "undefined" || !nav?.gpu) {
+    return { supported: false, reason: "WebGPU not available on navigator" };
+  }
+  try {
+    const adapter = await nav.gpu.requestAdapter();
+    if (!adapter) {
+      return { supported: false, reason: "No GPU adapter available" };
+    }
+    return { supported: true };
+  } catch (error) {
+    return {
+      supported: false,
+      reason: `Adapter error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function hasSharedArrayBuffer() {
+  try {
+    const g = globalThis;
+    return typeof g.SharedArrayBuffer !== "undefined";
+  } catch {
+    return false;
+  }
+}
+function isCrossOriginIsolated() {
+  try {
+    const g = globalThis;
+    return typeof g.window !== "undefined" && !!g.window?.crossOriginIsolated;
+  } catch {
+    return false;
+  }
+}
+async function supportsWasm() {
+  try {
+    const g = globalThis;
+    if (typeof g.WebAssembly === "undefined") return false;
+    const wasmModule = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0]);
+    await WebAssembly.instantiate(wasmModule);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDefaultOnnxExecutionProviders() {
+  const webgpu = await checkWebGPUSupportDetailed();
+  if (webgpu.supported) {
+    return ["webgpu", "wasm"];
+  }
+  if (await supportsWasm()) {
+    return ["wasm"];
+  }
+  return [];
+}
+async function getPreferredEmbeddingBackend() {
+  const providers = await getDefaultOnnxExecutionProviders();
+  if (providers.includes("webgpu")) return "webgpu";
+  if (providers.includes("wasm")) return "wasm";
+  return "api";
+}
+export {
+  checkWebGPUSupportDetailed,
+  getDefaultOnnxExecutionProviders,
+  getPreferredEmbeddingBackend,
+  hasSharedArrayBuffer,
+  isCrossOriginIsolated,
+  probeCapabilities,
+  supportsWasm
+};

package/dist/chunk-2ESYSVXG.js

@@ -0,0 +1,48 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};