Initial commit: Complete Hive distributed AI orchestration platform

This comprehensive implementation includes:
- FastAPI backend with MCP server integration
- React/TypeScript frontend with Vite
- PostgreSQL database with Redis caching
- Grafana/Prometheus monitoring stack
- Docker Compose orchestration
- Full MCP protocol support for Claude Code integration

Features:
- Agent discovery and management across network
- Visual workflow editor and execution engine
- Real-time task coordination and monitoring
- Multi-model support with specialized agents
- Distributed development task allocation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

mcp-server/node_modules/eventsource-parser/dist/index.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+class ParseError extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+}
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = !0, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = !1;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = !0, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+exports.ParseError = ParseError;
+exports.createParser = createParser;
+//# sourceMappingURL=index.cjs.map

mcp-server/node_modules/eventsource-parser/dist/index.d.cts

@@ -0,0 +1,144 @@
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param callbacks - Callbacks to invoke on different parsing events:
+ *   - `onEvent` when a new event is parsed
+ *   - `onError` when an error occurs
+ *   - `onRetry` when a new reconnection interval has been sent from the server
+ *   - `onComment` when a comment is encountered in the stream
+ *
+ * @returns A new EventSource parser, with `parse` and `reset` methods.
+ * @public
+ */
+export declare function createParser(callbacks: ParserCallbacks): EventSourceParser
+
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export declare type ErrorType = 'invalid-retry' | 'unknown-field'
+
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+export declare interface EventSourceMessage {
+  /**
+   * The event type sent from the server. Note that this differs from the browser `EventSource`
+   * implementation in that browsers will default this to `message`, whereas this parser will
+   * leave this as `undefined` if not explicitly declared.
+   */
+  event?: string
+  /**
+   * ID of the message, if any was provided by the server. Can be used by clients to keep the
+   * last received message ID in sync when reconnecting.
+   */
+  id?: string
+  /**
+   * The data received for this message
+   */
+  data: string
+}
+
+/**
+ * EventSource parser instance.
+ *
+ * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
+ *
+ * @public
+ */
+export declare interface EventSourceParser {
+  /**
+   * Feeds the parser another chunk. The method _does not_ return a parsed message.
+   * Instead, if the chunk was a complete message (or completed a previously incomplete message),
+   * it will invoke the `onParse` callback used to create the parsers.
+   *
+   * @param chunk - The chunk to parse. Can be a partial, eg in the case of streaming messages.
+   * @public
+   */
+  feed(chunk: string): void
+  /**
+   * Resets the parser state. This is required when you have a new stream of messages -
+   * for instance in the case of a client being disconnected and reconnecting.
+   *
+   * Previously received, incomplete data will NOT be parsed unless you pass `consume: true`,
+   * which tells the parser to attempt to consume any incomplete data as if it ended with a newline
+   * character. This is useful for cases when a server sends a non-EventSource message that you
+   * want to be able to react to in an `onError` callback.
+   *
+   * @public
+   */
+  reset(options?: {consume?: boolean}): void
+}
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export declare class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string
+  constructor(
+    message: string,
+    options: {
+      type: ErrorType
+      field?: string
+      value?: string
+      line?: string
+    },
+  )
+}
+
+/**
+ * Callbacks that can be passed to the parser to handle different types of parsed messages
+ * and errors.
+ *
+ * @public
+ */
+export declare interface ParserCallbacks {
+  /**
+   * Callback for when a new event/message is parsed from the stream.
+   * This is the main callback that clients will use to handle incoming messages.
+   *
+   * @param event - The parsed event/message
+   */
+  onEvent?: (event: EventSourceMessage) => void
+  /**
+   * Callback for when the server sends a new reconnection interval through the `retry` field.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: (retry: number) => void
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: (comment: string) => void
+  /**
+   * Callback for when an error occurs during parsing. This is a catch-all for any errors
+   * that occur during parsing, and can be used to handle them in a custom way. Most clients
+   * tend to silently ignore any errors and instead retry, but it can be helpful to log/debug.
+   *
+   * @param error - The error that occurred during parsing
+   */
+  onError?: (error: ParseError) => void
+}
+
+export {}

mcp-server/node_modules/eventsource-parser/dist/index.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param callbacks - Callbacks to invoke on different parsing events:
+ *   - `onEvent` when a new event is parsed
+ *   - `onError` when an error occurs
+ *   - `onRetry` when a new reconnection interval has been sent from the server
+ *   - `onComment` when a comment is encountered in the stream
+ *
+ * @returns A new EventSource parser, with `parse` and `reset` methods.
+ * @public
+ */
+export declare function createParser(callbacks: ParserCallbacks): EventSourceParser
+
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export declare type ErrorType = 'invalid-retry' | 'unknown-field'
+
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+export declare interface EventSourceMessage {
+  /**
+   * The event type sent from the server. Note that this differs from the browser `EventSource`
+   * implementation in that browsers will default this to `message`, whereas this parser will
+   * leave this as `undefined` if not explicitly declared.
+   */
+  event?: string
+  /**
+   * ID of the message, if any was provided by the server. Can be used by clients to keep the
+   * last received message ID in sync when reconnecting.
+   */
+  id?: string
+  /**
+   * The data received for this message
+   */
+  data: string
+}
+
+/**
+ * EventSource parser instance.
+ *
+ * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
+ *
+ * @public
+ */
+export declare interface EventSourceParser {
+  /**
+   * Feeds the parser another chunk. The method _does not_ return a parsed message.
+   * Instead, if the chunk was a complete message (or completed a previously incomplete message),
+   * it will invoke the `onParse` callback used to create the parsers.
+   *
+   * @param chunk - The chunk to parse. Can be a partial, eg in the case of streaming messages.
+   * @public
+   */
+  feed(chunk: string): void
+  /**
+   * Resets the parser state. This is required when you have a new stream of messages -
+   * for instance in the case of a client being disconnected and reconnecting.
+   *
+   * Previously received, incomplete data will NOT be parsed unless you pass `consume: true`,
+   * which tells the parser to attempt to consume any incomplete data as if it ended with a newline
+   * character. This is useful for cases when a server sends a non-EventSource message that you
+   * want to be able to react to in an `onError` callback.
+   *
+   * @public
+   */
+  reset(options?: {consume?: boolean}): void
+}
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export declare class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string
+  constructor(
+    message: string,
+    options: {
+      type: ErrorType
+      field?: string
+      value?: string
+      line?: string
+    },
+  )
+}
+
+/**
+ * Callbacks that can be passed to the parser to handle different types of parsed messages
+ * and errors.
+ *
+ * @public
+ */
+export declare interface ParserCallbacks {
+  /**
+   * Callback for when a new event/message is parsed from the stream.
+   * This is the main callback that clients will use to handle incoming messages.
+   *
+   * @param event - The parsed event/message
+   */
+  onEvent?: (event: EventSourceMessage) => void
+  /**
+   * Callback for when the server sends a new reconnection interval through the `retry` field.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: (retry: number) => void
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: (comment: string) => void
+  /**
+   * Callback for when an error occurs during parsing. This is a catch-all for any errors
+   * that occur during parsing, and can be used to handle them in a custom way. Most clients
+   * tend to silently ignore any errors and instead retry, but it can be helpful to log/debug.
+   *
+   * @param error - The error that occurred during parsing
+   */
+  onError?: (error: ParseError) => void
+}
+
+export {}

mcp-server/node_modules/eventsource-parser/dist/index.js

@@ -0,0 +1,106 @@
+class ParseError extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+}
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = !0, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = !1;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = !0, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+export {
+  ParseError,
+  createParser
+};
+//# sourceMappingURL=index.js.map

mcp-server/node_modules/eventsource-parser/dist/stream.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var index = require("./index.cjs");
+class EventSourceParserStream extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = index.createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+}
+exports.ParseError = index.ParseError;
+exports.EventSourceParserStream = EventSourceParserStream;
+//# sourceMappingURL=stream.cjs.map

mcp-server/node_modules/eventsource-parser/dist/stream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.cjs","sources":["../src/stream.ts"],"sourcesContent":["import {createParser} from './parse.ts'\nimport type {EventSourceMessage, EventSourceParser} from './types.ts'\n\n/**\n * Options for the EventSourceParserStream.\n *\n * @public\n */\nexport interface StreamOptions {\n  /**\n   * Behavior when a parsing error occurs.\n   *\n   * - A custom function can be provided to handle the error.\n   * - `'terminate'` will error the stream and stop parsing.\n   * - Any other value will ignore the error and continue parsing.\n   *\n   * @defaultValue `undefined`\n   */\n  onError?: 'terminate' | ((error: Error) => void)\n\n  /**\n   * Callback for when a reconnection interval is sent from the server.\n   *\n   * @param retry - The number of milliseconds to wait before reconnecting.\n   */\n  onRetry?: (retry: number) => void\n\n  /**\n   * Callback for when a comment is encountered in the stream.\n   *\n   * @param comment - The comment encountered in the stream.\n   */\n  onComment?: (comment: string) => void\n}\n\n/**\n * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.\n *\n * @example Basic usage\n * ```\n * const eventStream =\n *   response.body\n *     .pipeThrough(new TextDecoderStream())\n *     .pipeThrough(new EventSourceParserStream())\n * ```\n *\n * @example Terminate stream on parsing errors\n * ```\n * const eventStream =\n *  response.body\n *   .pipeThrough(new TextDecoderStream())\n *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))\n * ```\n *\n * @public\n */\nexport class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {\n  constructor({onError, onRetry, onComment}: StreamOptions = {}) {\n    let parser!: EventSourceParser\n\n    super({\n      start(controller) {\n        parser = createParser({\n          onEvent: (event) => {\n            controller.enqueue(event)\n          },\n          onError(error) {\n            if (onError === 'terminate') {\n              controller.error(error)\n            } else if (typeof onError === 'function') {\n              onError(error)\n            }\n\n            // Ignore by default\n          },\n          onRetry,\n          onComment,\n        })\n      },\n      transform(chunk) {\n        parser.feed(chunk)\n      },\n    })\n  }\n}\n\nexport {type ErrorType, ParseError} from './errors.ts'\nexport type {EventSourceMessage} from './types.ts'\n"],"names":["createParser"],"mappings":";;;AAwDO,MAAM,gCAAgC,gBAA4C;AAAA,EACvF,YAAY,EAAC,SAAS,SAAS,UAAS,IAAmB,CAAA,GAAI;AACzD,QAAA;AAEE,UAAA;AAAA,MACJ,MAAM,YAAY;AAChB,iBAASA,MAAAA,aAAa;AAAA,UACpB,SAAS,CAAC,UAAU;AAClB,uBAAW,QAAQ,KAAK;AAAA,UAC1B;AAAA,UACA,QAAQ,OAAO;AACT,wBAAY,cACd,WAAW,MAAM,KAAK,IACb,OAAO,WAAY,cAC5B,QAAQ,KAAK;AAAA,UAIjB;AAAA,UACA;AAAA,UACA;AAAA,QAAA,CACD;AAAA,MACH;AAAA,MACA,UAAU,OAAO;AACf,eAAO,KAAK,KAAK;AAAA,MAAA;AAAA,IACnB,CACD;AAAA,EAAA;AAEL;;;"}

mcp-server/node_modules/eventsource-parser/dist/stream.d.cts

@@ -0,0 +1,118 @@
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export declare type ErrorType = 'invalid-retry' | 'unknown-field'
+
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+export declare interface EventSourceMessage {
+  /**
+   * The event type sent from the server. Note that this differs from the browser `EventSource`
+   * implementation in that browsers will default this to `message`, whereas this parser will
+   * leave this as `undefined` if not explicitly declared.
+   */
+  event?: string
+  /**
+   * ID of the message, if any was provided by the server. Can be used by clients to keep the
+   * last received message ID in sync when reconnecting.
+   */
+  id?: string
+  /**
+   * The data received for this message
+   */
+  data: string
+}
+
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
+ *
+ * @example Basic usage
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ *
+ * @example Terminate stream on parsing errors
+ * ```
+ * const eventStream =
+ *  response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))
+ * ```
+ *
+ * @public
+ */
+export declare class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
+  constructor({onError, onRetry, onComment}?: StreamOptions)
+}
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export declare class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string
+  constructor(
+    message: string,
+    options: {
+      type: ErrorType
+      field?: string
+      value?: string
+      line?: string
+    },
+  )
+}
+
+/**
+ * Options for the EventSourceParserStream.
+ *
+ * @public
+ */
+export declare interface StreamOptions {
+  /**
+   * Behavior when a parsing error occurs.
+   *
+   * - A custom function can be provided to handle the error.
+   * - `'terminate'` will error the stream and stop parsing.
+   * - Any other value will ignore the error and continue parsing.
+   *
+   * @defaultValue `undefined`
+   */
+  onError?: 'terminate' | ((error: Error) => void)
+  /**
+   * Callback for when a reconnection interval is sent from the server.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: (retry: number) => void
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: (comment: string) => void
+}
+
+export {}

mcp-server/node_modules/eventsource-parser/dist/stream.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export declare type ErrorType = 'invalid-retry' | 'unknown-field'
+
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+export declare interface EventSourceMessage {
+  /**
+   * The event type sent from the server. Note that this differs from the browser `EventSource`
+   * implementation in that browsers will default this to `message`, whereas this parser will
+   * leave this as `undefined` if not explicitly declared.
+   */
+  event?: string
+  /**
+   * ID of the message, if any was provided by the server. Can be used by clients to keep the
+   * last received message ID in sync when reconnecting.
+   */
+  id?: string
+  /**
+   * The data received for this message
+   */
+  data: string
+}
+
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
+ *
+ * @example Basic usage
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ *
+ * @example Terminate stream on parsing errors
+ * ```
+ * const eventStream =
+ *  response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))
+ * ```
+ *
+ * @public
+ */
+export declare class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
+  constructor({onError, onRetry, onComment}?: StreamOptions)
+}
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export declare class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string
+  constructor(
+    message: string,
+    options: {
+      type: ErrorType
+      field?: string
+      value?: string
+      line?: string
+    },
+  )
+}
+
+/**
+ * Options for the EventSourceParserStream.
+ *
+ * @public
+ */
+export declare interface StreamOptions {
+  /**
+   * Behavior when a parsing error occurs.
+   *
+   * - A custom function can be provided to handle the error.
+   * - `'terminate'` will error the stream and stop parsing.
+   * - Any other value will ignore the error and continue parsing.
+   *
+   * @defaultValue `undefined`
+   */
+  onError?: 'terminate' | ((error: Error) => void)
+  /**
+   * Callback for when a reconnection interval is sent from the server.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: (retry: number) => void
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: (comment: string) => void
+}
+
+export {}

mcp-server/node_modules/eventsource-parser/dist/stream.js

@@ -0,0 +1,29 @@
+import { createParser } from "./index.js";
+import { ParseError } from "./index.js";
+class EventSourceParserStream extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+}
+export {
+  EventSourceParserStream,
+  ParseError
+};
+//# sourceMappingURL=stream.js.map

mcp-server/node_modules/eventsource-parser/dist/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sources":["../src/stream.ts"],"sourcesContent":["import {createParser} from './parse.ts'\nimport type {EventSourceMessage, EventSourceParser} from './types.ts'\n\n/**\n * Options for the EventSourceParserStream.\n *\n * @public\n */\nexport interface StreamOptions {\n  /**\n   * Behavior when a parsing error occurs.\n   *\n   * - A custom function can be provided to handle the error.\n   * - `'terminate'` will error the stream and stop parsing.\n   * - Any other value will ignore the error and continue parsing.\n   *\n   * @defaultValue `undefined`\n   */\n  onError?: 'terminate' | ((error: Error) => void)\n\n  /**\n   * Callback for when a reconnection interval is sent from the server.\n   *\n   * @param retry - The number of milliseconds to wait before reconnecting.\n   */\n  onRetry?: (retry: number) => void\n\n  /**\n   * Callback for when a comment is encountered in the stream.\n   *\n   * @param comment - The comment encountered in the stream.\n   */\n  onComment?: (comment: string) => void\n}\n\n/**\n * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.\n *\n * @example Basic usage\n * ```\n * const eventStream =\n *   response.body\n *     .pipeThrough(new TextDecoderStream())\n *     .pipeThrough(new EventSourceParserStream())\n * ```\n *\n * @example Terminate stream on parsing errors\n * ```\n * const eventStream =\n *  response.body\n *   .pipeThrough(new TextDecoderStream())\n *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))\n * ```\n *\n * @public\n */\nexport class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {\n  constructor({onError, onRetry, onComment}: StreamOptions = {}) {\n    let parser!: EventSourceParser\n\n    super({\n      start(controller) {\n        parser = createParser({\n          onEvent: (event) => {\n            controller.enqueue(event)\n          },\n          onError(error) {\n            if (onError === 'terminate') {\n              controller.error(error)\n            } else if (typeof onError === 'function') {\n              onError(error)\n            }\n\n            // Ignore by default\n          },\n          onRetry,\n          onComment,\n        })\n      },\n      transform(chunk) {\n        parser.feed(chunk)\n      },\n    })\n  }\n}\n\nexport {type ErrorType, ParseError} from './errors.ts'\nexport type {EventSourceMessage} from './types.ts'\n"],"names":[],"mappings":";;AAwDO,MAAM,gCAAgC,gBAA4C;AAAA,EACvF,YAAY,EAAC,SAAS,SAAS,UAAS,IAAmB,CAAA,GAAI;AACzD,QAAA;AAEE,UAAA;AAAA,MACJ,MAAM,YAAY;AAChB,iBAAS,aAAa;AAAA,UACpB,SAAS,CAAC,UAAU;AAClB,uBAAW,QAAQ,KAAK;AAAA,UAC1B;AAAA,UACA,QAAQ,OAAO;AACT,wBAAY,cACd,WAAW,MAAM,KAAK,IACb,OAAO,WAAY,cAC5B,QAAQ,KAAK;AAAA,UAIjB;AAAA,UACA;AAAA,UACA;AAAA,QAAA,CACD;AAAA,MACH;AAAA,MACA,UAAU,OAAO;AACf,eAAO,KAAK,KAAK;AAAA,MAAA;AAAA,IACnB,CACD;AAAA,EAAA;AAEL;"}