agentworkshop 0.5.1 → 0.5.3

package/.output/server/node_modules/@ctrl/tinycolor/dist/random.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bounds = exports.random = void 0;
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+// randomColor by David Merfield under the CC0 license
+// https://github.com/davidmerfield/randomColor/
+var index_js_1 = require("./index.js");
+function random(options) {
+    if (options === void 0) { options = {}; }
+    // Check if we need to generate multiple colors
+    if (options.count !== undefined &&
+        options.count !== null) {
+        var totalColors = options.count;
+        var colors = [];
+        options.count = undefined;
+        while (totalColors > colors.length) {
+            // Since we're generating multiple colors,
+            // incremement the seed. Otherwise we'd just
+            // generate the same color each time...
+            options.count = null;
+            if (options.seed) {
+                options.seed += 1;
+            }
+            colors.push(random(options));
+        }
+        options.count = totalColors;
+        return colors;
+    }
+    // First we pick a hue (H)
+    var h = pickHue(options.hue, options.seed);
+    // Then use H to determine saturation (S)
+    var s = pickSaturation(h, options);
+    // Then use S and H to determine brightness (B).
+    var v = pickBrightness(h, s, options);
+    var res = { h: h, s: s, v: v };
+    if (options.alpha !== undefined) {
+        res.a = options.alpha;
+    }
+    // Then we return the HSB color in the desired format
+    return new index_js_1.TinyColor(res);
+}
+exports.random = random;
+function pickHue(hue, seed) {
+    var hueRange = getHueRange(hue);
+    var res = randomWithin(hueRange, seed);
+    // Instead of storing red as two seperate ranges,
+    // we group them, using negative numbers
+    if (res < 0) {
+        res = 360 + res;
+    }
+    return res;
+}
+function pickSaturation(hue, options) {
+    if (options.hue === 'monochrome') {
+        return 0;
+    }
+    if (options.luminosity === 'random') {
+        return randomWithin([0, 100], options.seed);
+    }
+    var saturationRange = getColorInfo(hue).saturationRange;
+    var sMin = saturationRange[0];
+    var sMax = saturationRange[1];
+    switch (options.luminosity) {
+        case 'bright':
+            sMin = 55;
+            break;
+        case 'dark':
+            sMin = sMax - 10;
+            break;
+        case 'light':
+            sMax = 55;
+            break;
+        default:
+            break;
+    }
+    return randomWithin([sMin, sMax], options.seed);
+}
+function pickBrightness(H, S, options) {
+    var bMin = getMinimumBrightness(H, S);
+    var bMax = 100;
+    switch (options.luminosity) {
+        case 'dark':
+            bMax = bMin + 20;
+            break;
+        case 'light':
+            bMin = (bMax + bMin) / 2;
+            break;
+        case 'random':
+            bMin = 0;
+            bMax = 100;
+            break;
+        default:
+            break;
+    }
+    return randomWithin([bMin, bMax], options.seed);
+}
+function getMinimumBrightness(H, S) {
+    var lowerBounds = getColorInfo(H).lowerBounds;
+    for (var i = 0; i < lowerBounds.length - 1; i++) {
+        var s1 = lowerBounds[i][0];
+        var v1 = lowerBounds[i][1];
+        var s2 = lowerBounds[i + 1][0];
+        var v2 = lowerBounds[i + 1][1];
+        if (S >= s1 && S <= s2) {
+            var m = (v2 - v1) / (s2 - s1);
+            var b = v1 - m * s1;
+            return m * S + b;
+        }
+    }
+    return 0;
+}
+function getHueRange(colorInput) {
+    var num = parseInt(colorInput, 10);
+    if (!Number.isNaN(num) && num < 360 && num > 0) {
+        return [num, num];
+    }
+    if (typeof colorInput === 'string') {
+        var namedColor = exports.bounds.find(function (n) { return n.name === colorInput; });
+        if (namedColor) {
+            var color = defineColor(namedColor);
+            if (color.hueRange) {
+                return color.hueRange;
+            }
+        }
+        var parsed = new index_js_1.TinyColor(colorInput);
+        if (parsed.isValid) {
+            var hue = parsed.toHsv().h;
+            return [hue, hue];
+        }
+    }
+    return [0, 360];
+}
+function getColorInfo(hue) {
+    // Maps red colors to make picking hue easier
+    if (hue >= 334 && hue <= 360) {
+        hue -= 360;
+    }
+    for (var _i = 0, bounds_1 = exports.bounds; _i < bounds_1.length; _i++) {
+        var bound = bounds_1[_i];
+        var color = defineColor(bound);
+        if (color.hueRange && hue >= color.hueRange[0] && hue <= color.hueRange[1]) {
+            return color;
+        }
+    }
+    throw Error('Color not found');
+}
+function randomWithin(range, seed) {
+    if (seed === undefined) {
+        return Math.floor(range[0] + Math.random() * (range[1] + 1 - range[0]));
+    }
+    // Seeded random algorithm from http://indiegamr.com/generate-repeatable-random-numbers-in-js/
+    var max = range[1] || 1;
+    var min = range[0] || 0;
+    seed = (seed * 9301 + 49297) % 233280;
+    var rnd = seed / 233280.0;
+    return Math.floor(min + rnd * (max - min));
+}
+function defineColor(bound) {
+    var sMin = bound.lowerBounds[0][0];
+    var sMax = bound.lowerBounds[bound.lowerBounds.length - 1][0];
+    var bMin = bound.lowerBounds[bound.lowerBounds.length - 1][1];
+    var bMax = bound.lowerBounds[0][1];
+    return {
+        name: bound.name,
+        hueRange: bound.hueRange,
+        lowerBounds: bound.lowerBounds,
+        saturationRange: [sMin, sMax],
+        brightnessRange: [bMin, bMax],
+    };
+}
+/**
+ * @hidden
+ */
+exports.bounds = [
+    {
+        name: 'monochrome',
+        hueRange: null,
+        lowerBounds: [
+            [0, 0],
+            [100, 0],
+        ],
+    },
+    {
+        name: 'red',
+        hueRange: [-26, 18],
+        lowerBounds: [
+            [20, 100],
+            [30, 92],
+            [40, 89],
+            [50, 85],
+            [60, 78],
+            [70, 70],
+            [80, 60],
+            [90, 55],
+            [100, 50],
+        ],
+    },
+    {
+        name: 'orange',
+        hueRange: [19, 46],
+        lowerBounds: [
+            [20, 100],
+            [30, 93],
+            [40, 88],
+            [50, 86],
+            [60, 85],
+            [70, 70],
+            [100, 70],
+        ],
+    },
+    {
+        name: 'yellow',
+        hueRange: [47, 62],
+        lowerBounds: [
+            [25, 100],
+            [40, 94],
+            [50, 89],
+            [60, 86],
+            [70, 84],
+            [80, 82],
+            [90, 80],
+            [100, 75],
+        ],
+    },
+    {
+        name: 'green',
+        hueRange: [63, 178],
+        lowerBounds: [
+            [30, 100],
+            [40, 90],
+            [50, 85],
+            [60, 81],
+            [70, 74],
+            [80, 64],
+            [90, 50],
+            [100, 40],
+        ],
+    },
+    {
+        name: 'blue',
+        hueRange: [179, 257],
+        lowerBounds: [
+            [20, 100],
+            [30, 86],
+            [40, 80],
+            [50, 74],
+            [60, 60],
+            [70, 52],
+            [80, 44],
+            [90, 39],
+            [100, 35],
+        ],
+    },
+    {
+        name: 'purple',
+        hueRange: [258, 282],
+        lowerBounds: [
+            [20, 100],
+            [30, 87],
+            [40, 79],
+            [50, 70],
+            [60, 65],
+            [70, 59],
+            [80, 52],
+            [90, 45],
+            [100, 42],
+        ],
+    },
+    {
+        name: 'pink',
+        hueRange: [283, 334],
+        lowerBounds: [
+            [20, 100],
+            [30, 90],
+            [40, 86],
+            [60, 84],
+            [80, 80],
+            [90, 75],
+            [100, 73],
+        ],
+    },
+];

package/.output/server/node_modules/@ctrl/tinycolor/dist/readability.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mostReadable = exports.isReadable = exports.readability = void 0;
+var index_js_1 = require("./index.js");
+// Readability Functions
+// ---------------------
+// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
+/**
+ * AKA `contrast`
+ *
+ * Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
+ */
+function readability(color1, color2) {
+    var c1 = new index_js_1.TinyColor(color1);
+    var c2 = new index_js_1.TinyColor(color2);
+    return ((Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) /
+        (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05));
+}
+exports.readability = readability;
+/**
+ * Ensure that foreground and background color combinations meet WCAG2 guidelines.
+ * The third argument is an object.
+ *      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
+ *      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
+ * If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
+ *
+ * Example
+ * ```ts
+ * new TinyColor().isReadable('#000', '#111') => false
+ * new TinyColor().isReadable('#000', '#111', { level: 'AA', size: 'large' }) => false
+ * ```
+ */
+function isReadable(color1, color2, wcag2) {
+    var _a, _b;
+    if (wcag2 === void 0) { wcag2 = { level: 'AA', size: 'small' }; }
+    var readabilityLevel = readability(color1, color2);
+    switch (((_a = wcag2.level) !== null && _a !== void 0 ? _a : 'AA') + ((_b = wcag2.size) !== null && _b !== void 0 ? _b : 'small')) {
+        case 'AAsmall':
+        case 'AAAlarge':
+            return readabilityLevel >= 4.5;
+        case 'AAlarge':
+            return readabilityLevel >= 3;
+        case 'AAAsmall':
+            return readabilityLevel >= 7;
+        default:
+            return false;
+    }
+}
+exports.isReadable = isReadable;
+/**
+ * Given a base color and a list of possible foreground or background
+ * colors for that base, returns the most readable color.
+ * Optionally returns Black or White if the most readable color is unreadable.
+ *
+ * @param baseColor - the base color.
+ * @param colorList - array of colors to pick the most readable one from.
+ * @param args - and object with extra arguments
+ *
+ * Example
+ * ```ts
+ * new TinyColor().mostReadable('#123', ['#124", "#125'], { includeFallbackColors: false }).toHexString(); // "#112255"
+ * new TinyColor().mostReadable('#123', ['#124", "#125'],{ includeFallbackColors: true }).toHexString();  // "#ffffff"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'large' }).toHexString(); // "#faf3f3"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'small' }).toHexString(); // "#ffffff"
+ * ```
+ */
+function mostReadable(baseColor, colorList, args) {
+    if (args === void 0) { args = { includeFallbackColors: false, level: 'AA', size: 'small' }; }
+    var bestColor = null;
+    var bestScore = 0;
+    var includeFallbackColors = args.includeFallbackColors, level = args.level, size = args.size;
+    for (var _i = 0, colorList_1 = colorList; _i < colorList_1.length; _i++) {
+        var color = colorList_1[_i];
+        var score = readability(baseColor, color);
+        if (score > bestScore) {
+            bestScore = score;
+            bestColor = new index_js_1.TinyColor(color);
+        }
+    }
+    if (isReadable(baseColor, bestColor, { level: level, size: size }) || !includeFallbackColors) {
+        return bestColor;
+    }
+    args.includeFallbackColors = false;
+    return mostReadable(baseColor, ['#fff', '#000'], args);
+}
+exports.mostReadable = mostReadable;

package/.output/server/node_modules/@ctrl/tinycolor/dist/to-ms-filter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMsFilter = void 0;
+var conversion_js_1 = require("./conversion.js");
+var index_js_1 = require("./index.js");
+/**
+ * Returns the color represented as a Microsoft filter for use in old versions of IE.
+ */
+function toMsFilter(firstColor, secondColor) {
+    var color = new index_js_1.TinyColor(firstColor);
+    var hex8String = '#' + (0, conversion_js_1.rgbaToArgbHex)(color.r, color.g, color.b, color.a);
+    var secondHex8String = hex8String;
+    var gradientType = color.gradientType ? 'GradientType = 1, ' : '';
+    if (secondColor) {
+        var s = new index_js_1.TinyColor(secondColor);
+        secondHex8String = '#' + (0, conversion_js_1.rgbaToArgbHex)(s.r, s.g, s.b, s.a);
+    }
+    return "progid:DXImageTransform.Microsoft.gradient(".concat(gradientType, "startColorstr=").concat(hex8String, ",endColorstr=").concat(secondHex8String, ")");
+}
+exports.toMsFilter = toMsFilter;

package/.output/server/node_modules/@ctrl/tinycolor/dist/util.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pad2 = exports.convertToPercentage = exports.boundAlpha = exports.isPercentage = exports.isOnePointZero = exports.clamp01 = exports.bound01 = void 0;
+/**
+ * Take input from [0, n] and return it as [0, 1]
+ * @hidden
+ */
+function bound01(n, max) {
+    if (isOnePointZero(n)) {
+        n = '100%';
+    }
+    var isPercent = isPercentage(n);
+    n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
+    // Automatically convert percentage into number
+    if (isPercent) {
+        n = parseInt(String(n * max), 10) / 100;
+    }
+    // Handle floating point rounding errors
+    if (Math.abs(n - max) < 0.000001) {
+        return 1;
+    }
+    // Convert into [0, 1] range if it isn't already
+    if (max === 360) {
+        // If n is a hue given in degrees,
+        // wrap around out-of-range values into [0, 360] range
+        // then convert into [0, 1].
+        n = (n < 0 ? (n % max) + max : n % max) / parseFloat(String(max));
+    }
+    else {
+        // If n not a hue given in degrees
+        // Convert into [0, 1] range if it isn't already.
+        n = (n % max) / parseFloat(String(max));
+    }
+    return n;
+}
+exports.bound01 = bound01;
+/**
+ * Force a number between 0 and 1
+ * @hidden
+ */
+function clamp01(val) {
+    return Math.min(1, Math.max(0, val));
+}
+exports.clamp01 = clamp01;
+/**
+ * Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
+ * <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
+ * @hidden
+ */
+function isOnePointZero(n) {
+    return typeof n === 'string' && n.indexOf('.') !== -1 && parseFloat(n) === 1;
+}
+exports.isOnePointZero = isOnePointZero;
+/**
+ * Check to see if string passed in is a percentage
+ * @hidden
+ */
+function isPercentage(n) {
+    return typeof n === 'string' && n.indexOf('%') !== -1;
+}
+exports.isPercentage = isPercentage;
+/**
+ * Return a valid alpha value [0,1] with all invalid values being set to 1
+ * @hidden
+ */
+function boundAlpha(a) {
+    a = parseFloat(a);
+    if (isNaN(a) || a < 0 || a > 1) {
+        a = 1;
+    }
+    return a;
+}
+exports.boundAlpha = boundAlpha;
+/**
+ * Replace a decimal with it's percentage value
+ * @hidden
+ */
+function convertToPercentage(n) {
+    if (n <= 1) {
+        return "".concat(Number(n) * 100, "%");
+    }
+    return n;
+}
+exports.convertToPercentage = convertToPercentage;
+/**
+ * Force a hex value to have 2 characters
+ * @hidden
+ */
+function pad2(c) {
+    return c.length === 1 ? '0' + c : String(c);
+}
+exports.pad2 = pad2;

package/.output/server/node_modules/@ctrl/tinycolor/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@ctrl/tinycolor",
+  "version": "3.6.1",
+  "description": "Fast, small color manipulation and conversion for JavaScript",
+  "author": "Scott Cooper <scttcper@gmail.com>",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "homepage": "https://tinycolor.vercel.app",
+  "repository": "scttcper/tinycolor",
+  "keywords": [
+    "typescript",
+    "color",
+    "manipulation",
+    "tinycolor",
+    "hsa",
+    "rgb"
+  ],
+  "main": "dist/public_api.js",
+  "module": "dist/module/public_api.js",
+  "typings": "dist/public_api.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build:demo": "rollup -c rollup.demo.js",
+    "watch:demo": "rollup -c rollup.demo.js -w",
+    "lint": "eslint --ext .js,.ts, .",
+    "lint:fix": "eslint --fix --ext .js,.ts, .",
+    "prepare": "npm run build",
+    "build": "del-cli dist && tsc -p tsconfig.build.json && tsc -p tsconfig.module.json && ts-node build",
+    "build:docs": "typedoc --out demo/public/docs --hideGenerator --tsconfig tsconfig.build.json src/public_api.ts",
+    "test": "jest",
+    "test:ci": "jest --ci --runInBand --reporters=default --reporters=jest-junit --coverage",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/plugin-transform-modules-commonjs": "7.19.6",
+    "@babel/preset-typescript": "7.18.6",
+    "@ctrl/eslint-config": "3.5.6",
+    "@jest/globals": "29.3.1",
+    "@types/node": "18.11.11",
+    "del-cli": "5.0.0",
+    "jest": "29.3.1",
+    "jest-junit": "15.0.0",
+    "rollup": "2.70.1",
+    "rollup-plugin-livereload": "2.0.5",
+    "rollup-plugin-serve": "1.1.0",
+    "rollup-plugin-sourcemaps": "0.6.3",
+    "rollup-plugin-terser": "7.0.2",
+    "rollup-plugin-typescript2": "0.34.1",
+    "ts-node": "10.9.1",
+    "typedoc": "0.23.21",
+    "typescript": "4.9.3"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageProvider": "v8",
+    "moduleNameMapper": {
+      "(.+)\\.js": "$1"
+    }
+  },
+  "babel": {
+    "presets": [
+      "@babel/preset-typescript"
+    ],
+    "plugins": [
+      "@babel/plugin-transform-modules-commonjs"
+    ]
+  },
+  "release": {
+    "branch": "master"
+  },
+  "engines": {
+    "node": ">=10"
+  }
+}

package/.output/server/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js

@@ -0,0 +1,64 @@
+/**
+ * Experimental task capability assertion helpers.
+ * WARNING: These APIs are experimental and may change without notice.
+ *
+ * @experimental
+ */
+/**
+ * Asserts that task creation is supported for tools/call.
+ * Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
+ *
+ * @param requests - The task requests capability object
+ * @param method - The method being checked
+ * @param entityName - 'Server' or 'Client' for error messages
+ * @throws Error if the capability is not supported
+ *
+ * @experimental
+ */
+export function assertToolsCallTaskCapability(requests, method, entityName) {
+    if (!requests) {
+        throw new Error(`${entityName} does not support task creation (required for ${method})`);
+    }
+    switch (method) {
+        case 'tools/call':
+            if (!requests.tools?.call) {
+                throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+            }
+            break;
+        default:
+            // Method doesn't support tasks, which is fine - no error
+            break;
+    }
+}
+/**
+ * Asserts that task creation is supported for sampling/createMessage or elicitation/create.
+ * Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
+ *
+ * @param requests - The task requests capability object
+ * @param method - The method being checked
+ * @param entityName - 'Server' or 'Client' for error messages
+ * @throws Error if the capability is not supported
+ *
+ * @experimental
+ */
+export function assertClientRequestTaskCapability(requests, method, entityName) {
+    if (!requests) {
+        throw new Error(`${entityName} does not support task creation (required for ${method})`);
+    }
+    switch (method) {
+        case 'sampling/createMessage':
+            if (!requests.sampling?.createMessage) {
+                throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+            }
+            break;
+        case 'elicitation/create':
+            if (!requests.elicitation?.create) {
+                throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+            }
+            break;
+        default:
+            // Method doesn't support tasks, which is fine - no error
+            break;
+    }
+}
+//# sourceMappingURL=helpers.js.map

package/.output/server/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js

@@ -0,0 +1,16 @@
+/**
+ * Experimental task interfaces for MCP SDK.
+ * WARNING: These APIs are experimental and may change without notice.
+ */
+/**
+ * Checks if a task status represents a terminal state.
+ * Terminal states are those where the task has finished and will not change.
+ *
+ * @param status - The task status to check
+ * @returns True if the status is terminal (completed, failed, or cancelled)
+ * @experimental
+ */
+export function isTerminal(status) {
+    return status === 'completed' || status === 'failed' || status === 'cancelled';
+}
+//# sourceMappingURL=interfaces.js.map

package/.output/server/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js

@@ -0,0 +1,32 @@
+/**
+ * Experimental McpServer task features for MCP SDK.
+ * WARNING: These APIs are experimental and may change without notice.
+ *
+ * @experimental
+ */
+/**
+ * Experimental task features for McpServer.
+ *
+ * Access via `server.experimental.tasks`:
+ * ```typescript
+ * server.experimental.tasks.registerToolTask('long-running', config, handler);
+ * ```
+ *
+ * @experimental
+ */
+export class ExperimentalMcpServerTasks {
+    constructor(_mcpServer) {
+        this._mcpServer = _mcpServer;
+    }
+    registerToolTask(name, config, handler) {
+        // Validate that taskSupport is not 'forbidden' for task-based tools
+        const execution = { taskSupport: 'required', ...config.execution };
+        if (execution.taskSupport === 'forbidden') {
+            throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
+        }
+        // Access McpServer's internal _createRegisteredTool method
+        const mcpServerInternal = this._mcpServer;
+        return mcpServerInternal._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);
+    }
+}
+//# sourceMappingURL=mcp-server.js.map