aiexecode 1.0.91 → 1.0.94

package/mcp-agent-lib/node_modules/eventsource-parser/dist/stream.js

@@ -1,29 +0,0 @@
-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

package/mcp-agent-lib/node_modules/eventsource-parser/dist/stream.js.map

@@ -1 +0,0 @@
-{"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)) | undefined\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) | undefined\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) | undefined\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,UAAA,IAA4B,CAAA,GAAI;AAC7D,QAAI;AAEJ,UAAM;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,MACnB;AAAA,IAAA,CACD;AAAA,EACH;AACF;"}

package/mcp-agent-lib/node_modules/eventsource-parser/package.json

@@ -1,115 +0,0 @@
-{
-  "name": "eventsource-parser",
-  "version": "3.0.6",
-  "description": "Streaming, source-agnostic EventSource/Server-Sent Events parser",
-  "sideEffects": false,
-  "type": "module",
-  "types": "./dist/index.d.ts",
-  "module": "./dist/index.js",
-  "main": "./dist/index.cjs",
-  "exports": {
-    ".": {
-      "source": "./src/index.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
-    },
-    "./stream": {
-      "source": "./src/stream.ts",
-      "import": "./dist/stream.js",
-      "require": "./dist/stream.cjs",
-      "default": "./dist/stream.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "typesVersions": {
-    "*": {
-      "stream": [
-        "./dist/stream.d.ts"
-      ]
-    }
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "browserslist": [
-    "node >= 20",
-    "chrome >= 71",
-    "safari >= 14.1",
-    "firefox >= 105",
-    "edge >= 79"
-  ],
-  "files": [
-    "dist",
-    "!dist/stats.html",
-    "src",
-    "stream.js"
-  ],
-  "scripts": {
-    "build": "pkg-utils build && pkg-utils --strict",
-    "clean": "rimraf dist coverage",
-    "lint": "eslint . && tsc --noEmit",
-    "posttest": "npm run lint",
-    "prebuild": "npm run clean",
-    "prepublishOnly": "npm run build",
-    "test": "npm run test:node",
-    "test:bun": "bun test",
-    "test:deno": "deno run --allow-write --allow-net --allow-run --allow-sys --allow-ffi --allow-env --allow-read npm:vitest",
-    "test:node": "vitest --reporter=verbose"
-  },
-  "author": "Espen Hovlandsdal <espen@hovlandsdal.com>",
-  "keywords": [
-    "sse",
-    "eventsource",
-    "server-sent-events"
-  ],
-  "devDependencies": {
-    "@sanity/pkg-utils": "^8.0.0",
-    "@sanity/semantic-release-preset": "^5.0.0",
-    "@types/node": "^20.19.0",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
-    "eslint": "^8.51.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-config-sanity": "^7.1.2",
-    "eventsource-encoder": "^1.0.1",
-    "prettier": "^3.5.3",
-    "rimraf": "^6.0.1",
-    "rollup-plugin-visualizer": "^6.0.3",
-    "semantic-release": "^24.2.3",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
-  },
-  "homepage": "https://github.com/rexxars/eventsource-parser#readme",
-  "bugs": {
-    "url": "https://github.com/rexxars/eventsource-parser/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/rexxars/eventsource-parser.git"
-  },
-  "license": "MIT",
-  "prettier": {
-    "bracketSpacing": false,
-    "printWidth": 100,
-    "semi": false,
-    "singleQuote": true
-  },
-  "eslintConfig": {
-    "parserOptions": {
-      "ecmaFeatures": {
-        "modules": true
-      },
-      "ecmaVersion": 9,
-      "sourceType": "module"
-    },
-    "extends": [
-      "sanity",
-      "sanity/typescript",
-      "prettier"
-    ],
-    "ignorePatterns": [
-      "lib/**/"
-    ]
-  }
-}

package/mcp-agent-lib/node_modules/eventsource-parser/src/errors.ts

@@ -1,44 +0,0 @@
-/**
- * The type of error that occurred.
- * @public
- */
-export type ErrorType = 'invalid-retry' | 'unknown-field'
-
-/**
- * Error thrown when encountering an issue during parsing.
- *
- * @public
- */
-export 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 | undefined
-
-  /**
-   * In the case of an unknown field encountered in the stream, this will be the value of the field.
-   */
-  value?: string | undefined
-
-  /**
-   * The line that caused the error, if available.
-   */
-  line?: string | undefined
-
-  constructor(
-    message: string,
-    options: {type: ErrorType; field?: string; value?: string; line?: string},
-  ) {
-    super(message)
-    this.name = 'ParseError'
-    this.type = options.type
-    this.field = options.field
-    this.value = options.value
-    this.line = options.line
-  }
-}

package/mcp-agent-lib/node_modules/eventsource-parser/src/index.ts

@@ -1,3 +0,0 @@
-export {type ErrorType, ParseError} from './errors.ts'
-export {createParser} from './parse.ts'
-export type {EventSourceMessage, EventSourceParser, ParserCallbacks} from './types.ts'

package/mcp-agent-lib/node_modules/eventsource-parser/src/parse.ts

@@ -1,232 +0,0 @@
-/**
- * EventSource/Server-Sent Events parser
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- */
-import {ParseError} from './errors.ts'
-import type {EventSourceParser, ParserCallbacks} from './types.ts'
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function noop(_arg: unknown) {
-  // intentional noop
-}
-
-/**
- * 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 function createParser(callbacks: ParserCallbacks): EventSourceParser {
-  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 = ''
-
-  let isFirstChunk = true
-  let id: string | undefined
-  let data = ''
-  let eventType = ''
-
-  function feed(newChunk: string) {
-    // Strip any UTF8 byte order mark (BOM) at the start of the stream
-    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, '') : newChunk
-
-    // If there was a previous incomplete line, append it to the new chunk,
-    // so we may process it together as a new (hopefully complete) chunk.
-    const [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`)
-
-    for (const line of complete) {
-      parseLine(line)
-    }
-
-    incompleteLine = incomplete
-    isFirstChunk = false
-  }
-
-  function parseLine(line: string) {
-    // If the line is empty (a blank line), dispatch the event
-    if (line === '') {
-      dispatchEvent()
-      return
-    }
-
-    // If the line starts with a U+003A COLON character (:), ignore the line.
-    if (line.startsWith(':')) {
-      if (onComment) {
-        onComment(line.slice(line.startsWith(': ') ? 2 : 1))
-      }
-      return
-    }
-
-    // If the line contains a U+003A COLON character (:)
-    const fieldSeparatorIndex = line.indexOf(':')
-    if (fieldSeparatorIndex !== -1) {
-      // Collect the characters on the line before the first U+003A COLON character (:),
-      // and let `field` be that string.
-      const field = line.slice(0, fieldSeparatorIndex)
-
-      // Collect the characters on the line after the first U+003A COLON character (:),
-      // and let `value` be that string. If value starts with a U+0020 SPACE character,
-      // remove it from value.
-      const offset = line[fieldSeparatorIndex + 1] === ' ' ? 2 : 1
-      const value = line.slice(fieldSeparatorIndex + offset)
-
-      processField(field, value, line)
-      return
-    }
-
-    // Otherwise, the string is not empty but does not contain a U+003A COLON character (:)
-    // Process the field using the whole line as the field name, and an empty string as the field value.
-    // 👆 This is according to spec. That means that a line that has the value `data` will result in
-    // a newline being added to the current `data` buffer, for instance.
-    processField(line, '', line)
-  }
-
-  function processField(field: string, value: string, line: string) {
-    // Field names must be compared literally, with no case folding performed.
-    switch (field) {
-      case 'event':
-        // Set the `event type` buffer to field value
-        eventType = value
-        break
-      case 'data':
-        // Append the field value to the `data` buffer, then append a single U+000A LINE FEED(LF)
-        // character to the `data` buffer.
-        data = `${data}${value}\n`
-        break
-      case 'id':
-        // If the field value does not contain U+0000 NULL, then set the `ID` buffer to
-        // the field value. Otherwise, ignore the field.
-        id = value.includes('\0') ? undefined : value
-        break
-      case 'retry':
-        // If the field value consists of only ASCII digits, then interpret the field value as an
-        // integer in base ten, and set the event stream's reconnection time to that integer.
-        // Otherwise, ignore the field.
-        if (/^\d+$/.test(value)) {
-          onRetry(parseInt(value, 10))
-        } else {
-          onError(
-            new ParseError(`Invalid \`retry\` value: "${value}"`, {
-              type: 'invalid-retry',
-              value,
-              line,
-            }),
-          )
-        }
-        break
-      default:
-        // Otherwise, the field is ignored.
-        onError(
-          new ParseError(
-            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}…` : field}"`,
-            {type: 'unknown-field', field, value, line},
-          ),
-        )
-        break
-    }
-  }
-
-  function dispatchEvent() {
-    const shouldDispatch = data.length > 0
-    if (shouldDispatch) {
-      onEvent({
-        id,
-        event: eventType || undefined,
-        // 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('\n') ? data.slice(0, -1) : data,
-      })
-    }
-
-    // Reset for the next event
-    id = undefined
-    data = ''
-    eventType = ''
-  }
-
-  function reset(options: {consume?: boolean} = {}) {
-    if (incompleteLine && options.consume) {
-      parseLine(incompleteLine)
-    }
-
-    isFirstChunk = true
-    id = undefined
-    data = ''
-    eventType = ''
-    incompleteLine = ''
-  }
-
-  return {feed, reset}
-}
-
-/**
- * For the given `chunk`, split it into lines according to spec, and return any remaining incomplete line.
- *
- * @param chunk - The chunk to split into lines
- * @returns A tuple containing an array of complete lines, and any remaining incomplete line
- * @internal
- */
-function splitLines(chunk: string): [complete: Array<string>, incomplete: string] {
-  /**
-   * According to the spec, a line is terminated by either:
-   * - U+000D CARRIAGE RETURN U+000A LINE FEED (CRLF) character pair
-   * - a single U+000A LINE FEED(LF) character not preceded by a U+000D CARRIAGE RETURN(CR) character
-   * - a single U+000D CARRIAGE RETURN(CR) character not followed by a U+000A LINE FEED(LF) character
-   */
-  const lines: Array<string> = []
-  let incompleteLine = ''
-  let searchIndex = 0
-
-  while (searchIndex < chunk.length) {
-    // Find next line terminator
-    const crIndex = chunk.indexOf('\r', searchIndex)
-    const lfIndex = chunk.indexOf('\n', searchIndex)
-
-    // Determine line end
-    let lineEnd = -1
-    if (crIndex !== -1 && lfIndex !== -1) {
-      // CRLF case
-      lineEnd = Math.min(crIndex, lfIndex)
-    } else if (crIndex !== -1) {
-      // CR at the end of a chunk might be part of a CRLF sequence that spans chunks,
-      // so we shouldn't treat it as a line terminator (yet)
-      if (crIndex === chunk.length - 1) {
-        lineEnd = -1
-      } else {
-        lineEnd = crIndex
-      }
-    } else if (lfIndex !== -1) {
-      lineEnd = lfIndex
-    }
-
-    // Extract line if terminator found
-    if (lineEnd === -1) {
-      // No terminator found, rest is incomplete
-      incompleteLine = chunk.slice(searchIndex)
-      break
-    } else {
-      const line = chunk.slice(searchIndex, lineEnd)
-      lines.push(line)
-
-      // Move past line terminator
-      searchIndex = lineEnd + 1
-      if (chunk[searchIndex - 1] === '\r' && chunk[searchIndex] === '\n') {
-        searchIndex++
-      }
-    }
-  }
-
-  return [lines, incompleteLine]
-}

package/mcp-agent-lib/node_modules/eventsource-parser/src/stream.ts

@@ -1,88 +0,0 @@
-import {createParser} from './parse.ts'
-import type {EventSourceMessage, EventSourceParser} from './types.ts'
-
-/**
- * Options for the EventSourceParserStream.
- *
- * @public
- */
-export 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)) | undefined
-
-  /**
-   * 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) | undefined
-
-  /**
-   * Callback for when a comment is encountered in the stream.
-   *
-   * @param comment - The comment encountered in the stream.
-   */
-  onComment?: ((comment: string) => void) | undefined
-}
-
-/**
- * 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 class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
-  constructor({onError, onRetry, onComment}: StreamOptions = {}) {
-    let parser!: EventSourceParser
-
-    super({
-      start(controller) {
-        parser = createParser({
-          onEvent: (event) => {
-            controller.enqueue(event)
-          },
-          onError(error) {
-            if (onError === 'terminate') {
-              controller.error(error)
-            } else if (typeof onError === 'function') {
-              onError(error)
-            }
-
-            // Ignore by default
-          },
-          onRetry,
-          onComment,
-        })
-      },
-      transform(chunk) {
-        parser.feed(chunk)
-      },
-    })
-  }
-}
-
-export {type ErrorType, ParseError} from './errors.ts'
-export type {EventSourceMessage} from './types.ts'

package/mcp-agent-lib/node_modules/eventsource-parser/src/types.ts

@@ -1,97 +0,0 @@
-import type {ParseError} from './errors.ts'
-
-/**
- * EventSource parser instance.
- *
- * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
- *
- * @public
- */
-export interface EventSourceParser {
-  /**
-   * Feeds the parser another chunk. The method _does not_ return a parsed message.
-   * Instead, callbacks passed when creating the parser will be triggered once we see enough data
-   * for a valid/invalid parsing step (see {@link ParserCallbacks}).
-   *
-   * @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
-}
-
-/**
- * A parsed EventSource message event
- *
- * @public
- */
-export 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 | undefined
-
-  /**
-   * 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 | undefined
-
-  /**
-   * The data received for this message
-   */
-  data: string
-}
-
-/**
- * Callbacks that can be passed to the parser to handle different types of parsed messages
- * and errors.
- *
- * @public
- */
-export 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) | undefined
-
-  /**
-   * 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) | undefined
-
-  /**
-   * Callback for when a comment is encountered in the stream.
-   *
-   * @param comment - The comment encountered in the stream.
-   */
-  onComment?: ((comment: string) => void) | undefined
-
-  /**
-   * 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) | undefined
-}

package/mcp-agent-lib/node_modules/eventsource-parser/stream.js

@@ -1,2 +0,0 @@
-/* included for compatibility with react-native without package exports support */
-module.exports = require('./dist/stream.cjs')