@standardagents/builder 0.9.12 → 0.9.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardagents/builder",
-  "version": "0.9.12",
+  "version": "0.9.15",
   "private": false,
   "publishConfig": {
     "access": "restricted",
@@ -33,11 +33,6 @@
       "import": "./dist/built-in-routes.js",
       "default": "./dist/built-in-routes.js"
     },
-    "./mcp": {
-      "workerd": "./dist/mcp.js",
-      "import": "./dist/mcp.js",
-      "default": "./dist/mcp.js"
-    },
     "./rou3": {
       "workerd": "./dist/rou3.js",
       "import": "./dist/rou3.js",
@@ -59,11 +54,15 @@
     "build:ui:test": "KEEP_TEST_IDS=true vite build --config vite.config.ui.ts",
     "dev": "tsup --watch",
     "dev:ui": "vite --config vite.config.ui.ts --port 5177",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:unit": "vitest --config vitest.config.ts",
+    "test:integration": "vitest --config vitest.workerd.config.ts",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@formkit/drag-and-drop": "^0.5.3",
-    "@modelcontextprotocol/sdk": "^1.17.4",
     "@vueuse/core": "^14.0.0",
     "lucide-vue-next": "^0.546.0",
     "monaco-editor": "^0.52.2",
@@ -76,11 +75,13 @@
     "zodown": "^0.2.1"
   },
   "devDependencies": {
+    "@cloudflare/vitest-pool-workers": "^0.10.14",
     "@cloudflare/workers-types": "^4.0.0",
     "@iconify-json/lucide": "^1.2.62",
     "@tailwindcss/vite": "^4.1.12",
     "@types/node": "^22.16.5",
     "@vitejs/plugin-vue": "^6.0.1",
+    "@vitest/coverage-istanbul": "^4.0.15",
     "@vue/tsconfig": "^0.7.0",
     "esbuild-plugin-alias": "^0.2.1",
     "tailwindcss": "^4.1.12",
@@ -91,6 +92,7 @@
     "unplugin-vue": "^7.0.4",
     "vite": "^7.0.6",
     "vite-plugin-monaco-editor": "^1.1.0",
+    "vitest": "^2.1.9",
     "vue-tsc": "^2.0.0"
   },
   "peerDependencies": {

package/dist/mcp.js

@@ -1,663 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { tools } from 'virtual:@standardagents-tools';
-import { zodown } from 'zodown';
-
-// src/mcp/server.ts
-
-// src/utils/ServerResponseProxy.ts
-var ServerResponseProxy = class {
-  _statusCode = 200;
-  _statusMessage;
-  _headers = {};
-  _cookies = [];
-  _body = [];
-  _finished = false;
-  _headersSent = false;
-  _listeners = /* @__PURE__ */ new Map();
-  _closed = false;
-  _streamController;
-  _isStreaming = false;
-  constructor() {
-  }
-  get statusCode() {
-    return this._statusCode;
-  }
-  set statusCode(code) {
-    if (this._headersSent) {
-      throw new Error("Cannot set status code after headers have been sent");
-    }
-    this._statusCode = code;
-  }
-  get statusMessage() {
-    return this._statusMessage;
-  }
-  set statusMessage(message) {
-    if (this._headersSent) {
-      throw new Error("Cannot set status message after headers have been sent");
-    }
-    this._statusMessage = message;
-  }
-  get headersSent() {
-    return this._headersSent;
-  }
-  get finished() {
-    return this._finished;
-  }
-  writeHead(statusCode, statusMessage, headers) {
-    if (this._headersSent) {
-      throw new Error("Cannot set headers after they are sent");
-    }
-    this._statusCode = statusCode;
-    if (typeof statusMessage === "string") {
-      this._statusMessage = statusMessage;
-      if (headers) {
-        this._setHeaders(headers);
-      }
-    } else if (statusMessage) {
-      this._setHeaders(statusMessage);
-    }
-    return this;
-  }
-  setHeader(name, value) {
-    if (this._headersSent) {
-      throw new Error("Cannot set headers after they are sent");
-    }
-    this._headers[name.toLowerCase()] = String(value);
-    return this;
-  }
-  getHeader(name) {
-    return this._headers[name.toLowerCase()];
-  }
-  getHeaders() {
-    return { ...this._headers };
-  }
-  getHeaderNames() {
-    return Object.keys(this._headers);
-  }
-  hasHeader(name) {
-    return name.toLowerCase() in this._headers;
-  }
-  removeHeader(name) {
-    if (this._headersSent) {
-      throw new Error("Cannot remove headers after they are sent");
-    }
-    delete this._headers[name.toLowerCase()];
-    return this;
-  }
-  write(chunk, encoding, callback) {
-    if (this._finished) {
-      throw new Error("Cannot write after end");
-    }
-    if (!this._headersSent) {
-      this._headersSent = true;
-    }
-    let data;
-    if (typeof chunk === "string") {
-      data = new TextEncoder().encode(chunk);
-    } else {
-      data = chunk;
-    }
-    const contentType = this._headers["content-type"];
-    if (typeof contentType === "string" && contentType.includes("text/event-stream")) {
-      this._isStreaming = true;
-      if (this._streamController) {
-        this._streamController.enqueue(data);
-      } else {
-        this._body.push(data);
-      }
-    } else {
-      this._body.push(data);
-    }
-    if (typeof encoding === "function") {
-      encoding();
-    } else if (callback) {
-      callback();
-    }
-    return true;
-  }
-  end(chunk, encoding, callback) {
-    if (this._finished) {
-      return this;
-    }
-    if (chunk !== void 0) {
-      this.write(chunk, encoding, callback);
-    } else if (typeof encoding === "function") {
-      encoding();
-    } else if (callback) {
-      callback();
-    }
-    if (!this._headersSent) {
-      this._headersSent = true;
-    }
-    this._finished = true;
-    if (this._streamController) {
-      this._streamController.close();
-    }
-    this.emit("finish");
-    return this;
-  }
-  writeContinue() {
-  }
-  writeProcessing() {
-  }
-  flushHeaders() {
-    if (!this._headersSent) {
-      this._headersSent = true;
-    }
-  }
-  setTimeout(msecs, callback) {
-    return this;
-  }
-  addTrailers(headers) {
-  }
-  cork() {
-  }
-  uncork() {
-  }
-  destroy(error) {
-    if (!this._closed) {
-      this._closed = true;
-      this.emit("close");
-    }
-    this._finished = true;
-    return true;
-  }
-  // Event emitter methods
-  on(event, listener) {
-    if (!this._listeners.has(event)) {
-      this._listeners.set(event, []);
-    }
-    this._listeners.get(event).push(listener);
-    return this;
-  }
-  once(event, listener) {
-    const onceWrapper = (...args) => {
-      this.off(event, onceWrapper);
-      listener(...args);
-    };
-    return this.on(event, onceWrapper);
-  }
-  off(event, listener) {
-    const listeners = this._listeners.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-    return this;
-  }
-  emit(event, ...args) {
-    const listeners = this._listeners.get(event);
-    if (listeners && listeners.length > 0) {
-      listeners.forEach((listener) => {
-        try {
-          listener(...args);
-        } catch (error) {
-          setTimeout(() => this.emit("error", error), 0);
-        }
-      });
-      return true;
-    }
-    return false;
-  }
-  addListener(event, listener) {
-    return this.on(event, listener);
-  }
-  removeListener(event, listener) {
-    return this.off(event, listener);
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this._listeners.delete(event);
-    } else {
-      this._listeners.clear();
-    }
-    return this;
-  }
-  // Cookie handling methods
-  cookie(name, value, options) {
-    if (this._headersSent) {
-      throw new Error("Cannot set headers after they are sent");
-    }
-    let cookie = `${name}=${value}`;
-    if (options) {
-      if (options.domain) cookie += `; Domain=${options.domain}`;
-      if (options.expires)
-        cookie += `; Expires=${options.expires.toUTCString()}`;
-      if (options.httpOnly) cookie += "; HttpOnly";
-      if (options.maxAge) cookie += `; Max-Age=${options.maxAge}`;
-      if (options.path) cookie += `; Path=${options.path}`;
-      if (options.secure) cookie += "; Secure";
-      if (options.sameSite) {
-        if (typeof options.sameSite === "boolean") {
-          cookie += "; SameSite=Strict";
-        } else {
-          cookie += `; SameSite=${options.sameSite}`;
-        }
-      }
-    }
-    this._cookies.push(cookie);
-    return this;
-  }
-  clearCookie(name, options) {
-    if (this._headersSent) {
-      throw new Error("Cannot set headers after they are sent");
-    }
-    let cookie = `${name}=; Expires=Thu, 01 Jan 1970 00:00:00 GMT`;
-    if (options) {
-      if (options.domain) cookie += `; Domain=${options.domain}`;
-      if (options.path) cookie += `; Path=${options.path}`;
-    }
-    this._cookies.push(cookie);
-    return this;
-  }
-  _setHeaders(headers) {
-    for (const [key, value] of Object.entries(headers)) {
-      if (value !== void 0) {
-        this._headers[key.toLowerCase()] = Array.isArray(value) ? value : String(value);
-      }
-    }
-  }
-  toResponse() {
-    const headers = new Headers();
-    for (const [key, value] of Object.entries(this._headers)) {
-      if (Array.isArray(value)) {
-        value.forEach((v) => headers.append(key, v));
-      } else {
-        headers.set(key, value);
-      }
-    }
-    this._cookies.forEach((cookie) => {
-      headers.append("set-cookie", cookie);
-    });
-    const contentType = headers.get("content-type");
-    if (contentType && contentType.includes("text/event-stream")) {
-      const stream = new ReadableStream({
-        start: (controller) => {
-          this._streamController = controller;
-          if (this._body.length > 0) {
-            for (const chunk of this._body) {
-              controller.enqueue(chunk);
-            }
-            this._body = [];
-          }
-          if (this._finished) {
-            controller.close();
-          }
-        },
-        cancel: () => {
-          this._streamController = void 0;
-          this._closed = true;
-          this.emit("close");
-        }
-      });
-      return new Response(stream, {
-        status: this._statusCode,
-        statusText: this._statusMessage,
-        headers
-      });
-    } else {
-      let body = null;
-      if (this._body.length > 0) {
-        const totalLength = this._body.reduce(
-          (sum, chunk) => sum + chunk.length,
-          0
-        );
-        const combined = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of this._body) {
-          combined.set(chunk, offset);
-          offset += chunk.length;
-        }
-        body = combined;
-      }
-      return new Response(body, {
-        status: this._statusCode,
-        statusText: this._statusMessage,
-        headers
-      });
-    }
-  }
-};
-
-// src/utils/IncomingMessageProxy.ts
-var IncomingMessageProxy = class {
-  _request;
-  _url;
-  _body;
-  _bodyRead = false;
-  _streaming = false;
-  _streamEnded = false;
-  _streamDestroyed = false;
-  _listeners = /* @__PURE__ */ new Map();
-  _encoding;
-  constructor(request) {
-    this._request = request;
-    this._url = new URL(request.url);
-  }
-  // HTTP version (mock)
-  get httpVersion() {
-    return "1.1";
-  }
-  get httpVersionMajor() {
-    return 1;
-  }
-  get httpVersionMinor() {
-    return 1;
-  }
-  // Request method
-  get method() {
-    return this._request.method;
-  }
-  // URL and path properties
-  get url() {
-    return this._url.pathname + this._url.search;
-  }
-  get pathname() {
-    return this._url.pathname;
-  }
-  get search() {
-    return this._url.search;
-  }
-  get query() {
-    return this._url.search.slice(1);
-  }
-  get path() {
-    return this._url.pathname + this._url.search;
-  }
-  // Headers proxy
-  get headers() {
-    const headers = {};
-    this._request.headers.forEach((value, key) => {
-      const lowerKey = key.toLowerCase();
-      if (headers[lowerKey]) {
-        if (Array.isArray(headers[lowerKey])) {
-          headers[lowerKey].push(value);
-        } else {
-          headers[lowerKey] = [headers[lowerKey], value];
-        }
-      } else {
-        headers[lowerKey] = value;
-      }
-    });
-    return headers;
-  }
-  get rawHeaders() {
-    const raw = [];
-    this._request.headers.forEach((value, key) => {
-      raw.push(key, value);
-    });
-    return raw;
-  }
-  // Host and connection info
-  get host() {
-    return this._url.host;
-  }
-  get hostname() {
-    return this._url.hostname;
-  }
-  get port() {
-    return this._url.port || (this._url.protocol === "https:" ? "443" : "80");
-  }
-  get protocol() {
-    return this._url.protocol;
-  }
-  // Socket properties (mocked for compatibility)
-  get connection() {
-    return {
-      remoteAddress: this._request.headers.get("cf-connecting-ip") || this._request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "127.0.0.1",
-      remotePort: null,
-      localAddress: this._url.hostname,
-      localPort: parseInt(this.port),
-      encrypted: this._url.protocol === "https:"
-    };
-  }
-  get socket() {
-    return this.connection;
-  }
-  // Complete flag (always true for Request objects)
-  get complete() {
-    return true;
-  }
-  // Readable stream properties
-  get readable() {
-    return !this._streamEnded && !this._streamDestroyed;
-  }
-  get readableEnded() {
-    return this._streamEnded;
-  }
-  get destroyed() {
-    return this._streamDestroyed;
-  }
-  // Status code (only available on responses, null for requests)
-  get statusCode() {
-    return null;
-  }
-  get statusMessage() {
-    return null;
-  }
-  // Trailer support (not supported by fetch API)
-  get trailers() {
-    return {};
-  }
-  get rawTrailers() {
-    return [];
-  }
-  // Body reading methods
-  async read() {
-    if (this._bodyRead) {
-      return null;
-    }
-    if (!this._body) {
-      this._body = await this._request.arrayBuffer();
-    }
-    this._bodyRead = true;
-    return new Uint8Array(this._body);
-  }
-  async text() {
-    if (!this._body) {
-      this._body = await this._request.arrayBuffer();
-    }
-    return new TextDecoder().decode(this._body);
-  }
-  async json() {
-    const text = await this.text();
-    return JSON.parse(text);
-  }
-  async arrayBuffer() {
-    if (!this._body) {
-      this._body = await this._request.arrayBuffer();
-    }
-    return this._body;
-  }
-  // Event emitter methods
-  on(event, listener) {
-    if (!this._listeners.has(event)) {
-      this._listeners.set(event, []);
-    }
-    this._listeners.get(event).push(listener);
-    if (event === "data" && !this._streaming && !this._streamEnded) {
-      this._startStreaming();
-    }
-    return this;
-  }
-  once(event, listener) {
-    const onceWrapper = (...args) => {
-      this.off(event, onceWrapper);
-      listener(...args);
-    };
-    return this.on(event, onceWrapper);
-  }
-  off(event, listener) {
-    const listeners = this._listeners.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-    return this;
-  }
-  emit(event, ...args) {
-    const listeners = this._listeners.get(event);
-    if (listeners && listeners.length > 0) {
-      listeners.forEach((listener) => {
-        try {
-          listener(...args);
-        } catch (error) {
-          setTimeout(() => this.emit("error", error), 0);
-        }
-      });
-      return true;
-    }
-    return false;
-  }
-  addListener(event, listener) {
-    return this.on(event, listener);
-  }
-  removeListener(event, listener) {
-    return this.off(event, listener);
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this._listeners.delete(event);
-    } else {
-      this._listeners.clear();
-    }
-    return this;
-  }
-  setEncoding(encoding) {
-    this._encoding = encoding;
-    return this;
-  }
-  pause() {
-    return this;
-  }
-  resume() {
-    return this;
-  }
-  isPaused() {
-    return false;
-  }
-  pipe(destination) {
-    return destination;
-  }
-  unpipe(destination) {
-    return this;
-  }
-  wrap(stream) {
-    return this;
-  }
-  push(chunk, encoding) {
-    return false;
-  }
-  unshift(chunk, encoding) {
-  }
-  setTimeout(msecs, callback) {
-    return this;
-  }
-  destroy(error) {
-    if (this._streamDestroyed) {
-      return this;
-    }
-    this._streamDestroyed = true;
-    this._streamEnded = true;
-    if (error) {
-      this.emit("error", error);
-    }
-    this.emit("close");
-    return this;
-  }
-  // Utility methods
-  header(name) {
-    return this.headers[name.toLowerCase()];
-  }
-  get(name) {
-    const header = this.headers[name.toLowerCase()];
-    return Array.isArray(header) ? header[0] : header;
-  }
-  // Private method to start streaming the body
-  async _startStreaming() {
-    if (this._streaming || this._streamEnded || this._streamDestroyed) {
-      return;
-    }
-    this._streaming = true;
-    try {
-      if (!this._request.body) {
-        this._streamEnded = true;
-        this.emit("end");
-        return;
-      }
-      const reader = this._request.body.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (this._streamDestroyed) {
-          reader.cancel();
-          break;
-        }
-        if (done) {
-          this._streamEnded = true;
-          this.emit("end");
-          break;
-        }
-        if (value) {
-          let chunk = value;
-          if (this._encoding) {
-            chunk = new TextDecoder(this._encoding).decode(value);
-          }
-          this.emit("data", chunk);
-        }
-      }
-    } catch (error) {
-      this._streamEnded = true;
-      this.emit("error", error);
-    }
-  }
-};
-async function handle(req, env) {
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: void 0,
-    enableJsonResponse: true
-  });
-  const server = await createMCPServer();
-  await server.connect(transport);
-  const res = new ServerResponseProxy();
-  await transport.handleRequest(new IncomingMessageProxy(req), res);
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  return res.toResponse();
-}
-async function createMCPServer(env, req) {
-  const server = new McpServer({
-    name: "agent-kit",
-    version: "1.0.0"
-  });
-  for (const name in tools) {
-    const [description, args, tool] = await tools[name]();
-    const v3Args = zodown(args);
-    server.tool(
-      name,
-      description,
-      args ? v3Args.shape : {},
-      (args2) => {
-        const flow = {
-          id: "stateless",
-          active: {
-            tool: "1",
-            args: {},
-            retries: 0,
-            reasons: []
-          },
-          queue: []
-        };
-        return tool(flow, args2);
-      }
-    );
-  }
-  return server;
-}
-
-export { createMCPServer, handle };
-//# sourceMappingURL=mcp.js.map
-//# sourceMappingURL=mcp.js.map