@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/types.d.ts

@@ -0,0 +1,299 @@
+import type { ToolInputSchema, ToolOutputSchema } from "./schema.js";
+export interface JSONRPCRequest {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JSONRPCResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: JSONRPCError;
+}
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export declare const JSON_RPC_ERROR_CODES: Readonly<{
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly RESOURCE_NOT_FOUND: -32002;
+    readonly UNSUPPORTED_PROTOCOL_VERSION: -32022;
+}>;
+export declare class ToolError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+export interface ToolsCapability {
+    listChanged?: boolean;
+}
+export interface PromptsCapability {
+    listChanged?: boolean;
+}
+export interface ResourcesCapability {
+    subscribe?: boolean;
+    listChanged?: boolean;
+}
+export interface Implementation {
+    name: string;
+    title?: string;
+    version: string;
+    description?: string;
+    websiteUrl?: string;
+    icons?: Icon[];
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        extensions?: Record<string, Record<string, unknown>>;
+        tools?: ToolsCapability;
+        prompts?: PromptsCapability;
+        resources?: ResourcesCapability;
+    };
+    serverInfo: Implementation;
+}
+export interface DiscoverResult {
+    resultType: "complete";
+    supportedVersions: string[];
+    capabilities: InitializeResult["capabilities"];
+    _meta: {
+        "io.modelcontextprotocol/serverInfo": InitializeResult["serverInfo"];
+    };
+    ttlMs: number;
+    cacheScope: "public" | "private";
+}
+export interface Tool {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JSONSchema;
+    outputSchema?: OutputSchema;
+    annotations?: ToolAnnotations;
+    execution?: ToolExecution;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export interface CallToolResult {
+    content: ContentItem[];
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolExecution {
+    taskSupport?: "optional" | "required" | "forbidden";
+}
+export interface Icon {
+    src: string;
+    mimeType?: string;
+    sizes?: string[];
+    theme?: "light" | "dark";
+}
+export interface ContentAnnotations {
+    audience?: Array<"user" | "assistant">;
+    priority?: number;
+    lastModified?: string;
+}
+export interface ResourceLink extends Resource {
+    type: "resource_link";
+}
+export interface PromptArgument {
+    name: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+}
+export interface Prompt {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: PromptArgument[];
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export interface PromptMessage {
+    role: "user" | "assistant";
+    content: ContentItem;
+}
+export interface GetPromptResult {
+    description?: string;
+    messages: PromptMessage[];
+}
+export type PromptHandler = (args: Record<string, string>, context: HandlerRequestContext) => Promise<GetPromptResult | InputRequiredResult> | GetPromptResult | InputRequiredResult;
+export interface PromptDefinition extends Prompt {
+    handler: PromptHandler;
+}
+export interface Resource {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: ContentAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export interface ResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    annotations?: ContentAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export type ResourceContents = {
+    uri: string;
+    mimeType?: string;
+    text: string;
+    _meta?: Record<string, unknown>;
+} | {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+    _meta?: Record<string, unknown>;
+};
+export interface ReadResourceResult {
+    contents: ResourceContents[];
+}
+export type ResourceHandler = (uri: string, context: HandlerRequestContext) => Promise<ReadResourceResult | InputRequiredResult> | ReadResourceResult | InputRequiredResult;
+export interface ResourceDefinition extends Resource {
+    handler: ResourceHandler;
+}
+export interface ResourceTemplateDefinition extends ResourceTemplate {
+    handler: ResourceHandler;
+}
+export interface HandleResult {
+    result?: unknown;
+    error?: JSONRPCError;
+}
+export type PromptContentItem = {
+    type: "text";
+    text: string;
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+} | {
+    type: "audio";
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+} | {
+    type: "resource";
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text: string;
+        _meta?: Record<string, unknown>;
+    } | {
+        uri: string;
+        mimeType?: string;
+        blob: string;
+        _meta?: Record<string, unknown>;
+    };
+};
+export type ContentItem = PromptContentItem | ResourceLink;
+export interface JSONSchema {
+    type: "object";
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    [keyword: string]: unknown;
+}
+export interface OutputSchema {
+    $schema?: string;
+    [keyword: string]: unknown;
+}
+export interface JSONSchemaProperty extends Record<string, unknown> {
+    type?: string | string[];
+    description?: string;
+    [keyword: string]: unknown;
+}
+export interface ServerOptions {
+    name: string;
+    version: string;
+    toolCallTimeoutMs?: number;
+    /** Shared active tool-handler capacity across sessions; defaults to four. */
+    maxConcurrentToolCalls?: number;
+    /** Maximum tool calls waiting for capacity; defaults to 64. Zero disables waiting. */
+    maxQueuedToolCalls?: number;
+    /** Per-stdio-connection UTF-8 bytes queued or submitted but unsettled; defaults to 1 MiB. */
+    maxStdioOutputBytes?: number;
+    /** Per-stdio-connection messages awaiting handler/output settlement; defaults to 128. */
+    maxPendingStdioMessages?: number;
+    /** Shared in-flight requests retained until their work settles; defaults to 128. */
+    maxActiveRequests?: number;
+    maxStdioLineBytes?: number;
+    validateToolArguments?: boolean;
+    supportNotifications?: boolean;
+    supportResourceSubscriptions?: boolean;
+}
+import type { ToolReturn } from "./content/index.js";
+export interface InputRequiredResult {
+    resultType: "input_required";
+    inputRequests?: Record<string, {
+        method: "elicitation/create" | "sampling/createMessage" | "roots/list";
+        params?: Record<string, unknown>;
+    }>;
+    requestState?: string;
+    _meta?: Record<string, unknown>;
+}
+export interface HandlerRequestContext {
+    readonly signal: AbortSignal;
+    /** Opaque state provided by the transport, separate from untrusted request metadata. */
+    readonly localContext?: unknown;
+    readonly requestState?: string;
+    readonly inputResponses?: Record<string, unknown>;
+    readonly clientCapabilities: Record<string, unknown>;
+}
+export type ToolHandler<T = Record<string, unknown>, TOut = ToolReturn> = (args: T, context: HandlerRequestContext) => Promise<TOut | CallToolResult | InputRequiredResult> | TOut | CallToolResult | InputRequiredResult;
+export interface ToolDefinition<T = Record<string, unknown>, TOut = ToolReturn> {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: ToolInputSchema<T>;
+    outputSchema?: ToolOutputSchema<TOut>;
+    annotations?: ToolAnnotations;
+    execution?: ToolExecution;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+    handler: ToolHandler<T, TOut>;
+}
+export interface Transport {
+    readable: NodeJS.ReadableStream;
+    writable: NodeJS.WritableStream;
+}
+export interface SDKTransport {
+    onmessage?: (message: JSONRPCMessage) => void;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+    send: (message: JSONRPCMessage) => Promise<void>;
+}
+export type JSONRPCMessage = JSONRPCRequest | JSONRPCResponse | JSONRPCNotification;
+export interface JSONRPCNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/types.js

@@ -0,0 +1,23 @@
+// JSON-RPC error codes
+export const JSON_RPC_ERROR_CODES = Object.freeze({
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    RESOURCE_NOT_FOUND: -32002,
+    UNSUPPORTED_PROTOCOL_VERSION: -32022
+});
+export class ToolError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        if (!Number.isFinite(code)) {
+            throw new Error("ToolError code must be a finite number");
+        }
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "ToolError";
+    }
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/uri-template.d.ts

@@ -0,0 +1,6 @@
+export type UriTemplateValue = string | string[] | Record<string, string>;
+export interface UriTemplate {
+    expand(variables: Record<string, UriTemplateValue>): string;
+    match(uri: string): Record<string, string> | null;
+}
+export declare function parseUriTemplate(template: string): UriTemplate;

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/uri-template.js

@@ -0,0 +1,363 @@
+const operatorOptions = {
+    "": { prefix: "", separator: ",", named: false, ifEmpty: "", allowReserved: false },
+    "+": { prefix: "", separator: ",", named: false, ifEmpty: "", allowReserved: true },
+    "#": { prefix: "#", separator: ",", named: false, ifEmpty: "", allowReserved: true },
+    ".": { prefix: ".", separator: ".", named: false, ifEmpty: "", allowReserved: false },
+    "/": { prefix: "/", separator: "/", named: false, ifEmpty: "", allowReserved: false },
+    ";": { prefix: ";", separator: ";", named: true, ifEmpty: "", allowReserved: false },
+    "?": { prefix: "?", separator: "&", named: true, ifEmpty: "=", allowReserved: false },
+    "&": { prefix: "&", separator: "&", named: true, ifEmpty: "=", allowReserved: false }
+};
+const operators = new Set(["", "+", "#", ".", "/", ";", "?", "&"]);
+const reservedCharacters = new Set(":/?#[]@!$&'()*+,;=".split(""));
+class ParsedUriTemplate {
+    segments;
+    constructor(segments) {
+        this.segments = segments;
+    }
+    expand(variables) {
+        return this.segments
+            .map((segment) => segment.kind === "literal" ? segment.value : expandExpression(segment, variables))
+            .join("");
+    }
+    match(uri) {
+        return matchSegments(this.segments, uri, 0, 0, {});
+    }
+}
+export function parseUriTemplate(template) {
+    if (typeof template !== "string") {
+        throw new Error("URI template must be a string.");
+    }
+    const segments = [];
+    let literalStart = 0;
+    let index = 0;
+    while (index < template.length) {
+        const character = template[index];
+        if (character === "}") {
+            throw syntaxError(template, index, "unmatched closing brace");
+        }
+        if (character !== "{") {
+            index += 1;
+            continue;
+        }
+        if (index > literalStart) {
+            segments.push({ kind: "literal", value: template.slice(literalStart, index) });
+        }
+        const closeIndex = template.indexOf("}", index + 1);
+        if (closeIndex === -1) {
+            throw syntaxError(template, index, "unclosed expression");
+        }
+        const expression = template.slice(index + 1, closeIndex);
+        if (expression.includes("{")) {
+            throw syntaxError(template, index, "nested expression");
+        }
+        segments.push(parseExpression(template, expression, index));
+        index = closeIndex + 1;
+        literalStart = index;
+    }
+    if (literalStart < template.length) {
+        segments.push({ kind: "literal", value: template.slice(literalStart) });
+    }
+    if (segments.length === 0) {
+        segments.push({ kind: "literal", value: "" });
+    }
+    return new ParsedUriTemplate(segments);
+}
+function parseExpression(template, expression, offset) {
+    if (expression.length === 0) {
+        throw syntaxError(template, offset, "empty expression");
+    }
+    const first = expression[0];
+    const operator = operators.has(first) && first !== "" ? first : "";
+    const variableList = operator === "" ? expression : expression.slice(1);
+    if (variableList.length === 0) {
+        throw syntaxError(template, offset, "expression has no variables");
+    }
+    if (operator === "" && isReservedOperatorCharacter(first)) {
+        throw syntaxError(template, offset, `unsupported operator ${first}`);
+    }
+    const variables = variableList
+        .split(",")
+        .map((variable) => parseVariableSpec(template, variable, offset));
+    return { kind: "expression", operator, variables };
+}
+function parseVariableSpec(template, source, offset) {
+    if (source.length === 0) {
+        throw syntaxError(template, offset, "empty variable specification");
+    }
+    const explode = source.endsWith("*");
+    const withoutExplode = explode ? source.slice(0, -1) : source;
+    const colonIndex = withoutExplode.indexOf(":");
+    if (explode && colonIndex !== -1) {
+        throw syntaxError(template, offset, "explode and prefix modifiers cannot be combined");
+    }
+    const name = colonIndex === -1 ? withoutExplode : withoutExplode.slice(0, colonIndex);
+    if (!isValidVariableName(name)) {
+        throw syntaxError(template, offset, `invalid variable name ${name}`);
+    }
+    if (colonIndex === -1) {
+        return { name, explode };
+    }
+    const prefixSource = withoutExplode.slice(colonIndex + 1);
+    if (!isValidPrefix(prefixSource)) {
+        throw syntaxError(template, offset, `invalid prefix modifier ${prefixSource}`);
+    }
+    return { name, explode: false, prefixLength: Number(prefixSource) };
+}
+function isValidVariableName(name) {
+    if (name.length === 0) {
+        return false;
+    }
+    let componentLength = 0;
+    for (let index = 0; index < name.length; index += 1) {
+        const character = name[index];
+        if (character === ".") {
+            if (componentLength === 0)
+                return false;
+            componentLength = 0;
+            continue;
+        }
+        if (character === "%") {
+            if (!isHex(name[index + 1]) || !isHex(name[index + 2]))
+                return false;
+            index += 2;
+            componentLength += 1;
+            continue;
+        }
+        if (!isVariableCharacter(character))
+            return false;
+        componentLength += 1;
+    }
+    return componentLength > 0;
+}
+function isValidPrefix(value) {
+    if (value.length === 0 || value.length > 4 || value[0] === "0") {
+        return false;
+    }
+    return [...value].every((character) => character >= "0" && character <= "9");
+}
+function isReservedOperatorCharacter(character) {
+    return "=,!@|".includes(character);
+}
+function isVariableCharacter(character) {
+    return ((character >= "a" && character <= "z") ||
+        (character >= "A" && character <= "Z") ||
+        (character >= "0" && character <= "9") ||
+        character === "_");
+}
+function isHex(character) {
+    return (character !== undefined &&
+        ((character >= "0" && character <= "9") ||
+            (character >= "a" && character <= "f") ||
+            (character >= "A" && character <= "F")));
+}
+function syntaxError(template, index, detail) {
+    return new Error(`Invalid URI template at ${index}: ${detail} (${template})`);
+}
+function expandExpression(expression, variables) {
+    const options = operatorOptions[expression.operator];
+    const parts = [];
+    for (const variable of expression.variables) {
+        const value = variables[variable.name];
+        if (value === undefined || value === null) {
+            continue;
+        }
+        parts.push(...expandVariable(variable, value, options));
+    }
+    return parts.length === 0 ? "" : `${options.prefix}${parts.join(options.separator)}`;
+}
+function expandVariable(variable, value, options) {
+    if (Array.isArray(value)) {
+        if (variable.prefixLength !== undefined) {
+            throw new Error(`Prefix modifier requires a scalar value: ${variable.name}`);
+        }
+        return expandList(variable, value, options);
+    }
+    if (isRecord(value)) {
+        if (variable.prefixLength !== undefined) {
+            throw new Error(`Prefix modifier requires a scalar value: ${variable.name}`);
+        }
+        return expandAssociative(variable, value, options);
+    }
+    const original = String(value);
+    const scalar = variable.prefixLength === undefined
+        ? original
+        : [...original].slice(0, variable.prefixLength).join("");
+    const encoded = encodeValue(scalar, options.allowReserved);
+    return [namedValue(variable.name, encoded, options)];
+}
+function expandList(variable, value, options) {
+    if (value.length === 0) {
+        return [];
+    }
+    const encoded = value.map((item) => encodeValue(String(item), options.allowReserved));
+    if (!variable.explode) {
+        return [namedValue(variable.name, encoded.join(","), options)];
+    }
+    if (!options.named) {
+        return encoded;
+    }
+    return encoded.map((item) => namedValue(variable.name, item, options));
+}
+function expandAssociative(variable, value, options) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+        return [];
+    }
+    const encoded = entries.map(([key, item]) => [
+        encodeValue(key, options.allowReserved),
+        encodeValue(String(item), options.allowReserved)
+    ]);
+    if (!variable.explode) {
+        return [namedValue(variable.name, encoded.flat().join(","), options)];
+    }
+    return encoded.map(([key, item]) => `${key}=${item}`);
+}
+function namedValue(name, value, options) {
+    if (!options.named) {
+        return value;
+    }
+    const encodedName = encodeValue(name, true);
+    if (value.length === 0) {
+        return `${encodedName}${options.ifEmpty}`;
+    }
+    return `${encodedName}=${value}`;
+}
+function encodeValue(value, allowReserved) {
+    let result = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (allowReserved && character === "%" && isHex(value[index + 1]) && isHex(value[index + 2])) {
+            result += value.slice(index, index + 3);
+            index += 2;
+            continue;
+        }
+        const codePoint = value.codePointAt(index);
+        if (codePoint === undefined)
+            continue;
+        const scalar = String.fromCodePoint(codePoint);
+        if (scalar.length === 2)
+            index += 1;
+        if (isUnreserved(scalar) || (allowReserved && reservedCharacters.has(scalar))) {
+            result += scalar;
+            continue;
+        }
+        for (const byte of new TextEncoder().encode(scalar)) {
+            result += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+        }
+    }
+    return result;
+}
+function isUnreserved(character) {
+    return ((character >= "a" && character <= "z") ||
+        (character >= "A" && character <= "Z") ||
+        (character >= "0" && character <= "9") ||
+        "-._~".includes(character));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function matchSegments(segments, uri, segmentIndex, uriIndex, captures) {
+    if (segmentIndex === segments.length) {
+        return uriIndex === uri.length ? captures : null;
+    }
+    const segment = segments[segmentIndex];
+    if (segment.kind === "literal") {
+        return uri.startsWith(segment.value, uriIndex)
+            ? matchSegments(segments, uri, segmentIndex + 1, uriIndex + segment.value.length, captures)
+            : null;
+    }
+    for (const endIndex of candidateExpressionEnds(segments, uri, segmentIndex, uriIndex)) {
+        const expressionCaptures = matchExpression(segment, uri.slice(uriIndex, endIndex));
+        if (expressionCaptures === null)
+            continue;
+        const result = matchSegments(segments, uri, segmentIndex + 1, endIndex, {
+            ...captures,
+            ...expressionCaptures
+        });
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+function candidateExpressionEnds(segments, uri, segmentIndex, uriIndex) {
+    const next = segments[segmentIndex + 1];
+    if (next === undefined) {
+        return [uri.length];
+    }
+    const boundary = next.kind === "literal" ? next.value : operatorOptions[next.operator].prefix;
+    if (boundary.length === 0) {
+        return descendingRange(uriIndex, uri.length);
+    }
+    const indices = [];
+    let searchIndex = uri.length;
+    while (searchIndex >= uriIndex) {
+        const found = uri.lastIndexOf(boundary, searchIndex);
+        if (found < uriIndex)
+            break;
+        indices.push(found);
+        searchIndex = found - 1;
+    }
+    return indices;
+}
+function descendingRange(start, end) {
+    const values = [];
+    for (let value = end; value >= start; value -= 1)
+        values.push(value);
+    return values;
+}
+function matchExpression(expression, expansion) {
+    const options = operatorOptions[expression.operator];
+    if (expansion.length === 0) {
+        return {};
+    }
+    if (options.prefix.length > 0 && !expansion.startsWith(options.prefix)) {
+        return null;
+    }
+    const body = options.prefix.length === 0 ? expansion : expansion.slice(options.prefix.length);
+    if (options.named) {
+        return matchNamedExpression(expression.variables, body, options.separator);
+    }
+    return matchPositionalExpression(expression.variables, body, options.separator);
+}
+function matchNamedExpression(variables, body, separator) {
+    const captures = {};
+    const fields = body.length === 0 ? [] : body.split(separator);
+    for (const variable of variables) {
+        const encodedName = encodeValue(variable.name, true);
+        const values = [];
+        for (const field of fields) {
+            const equalsIndex = field.indexOf("=");
+            const key = equalsIndex === -1 ? field : field.slice(0, equalsIndex);
+            if (key === encodedName) {
+                values.push(equalsIndex === -1 ? "" : field.slice(equalsIndex + 1));
+            }
+        }
+        if (values.length > 0) {
+            captures[variable.name] = decodeValue(values.join(variable.explode ? "," : ""));
+        }
+        else if (variable.explode && variables.length === 1 && body.length > 0) {
+            captures[variable.name] = decodeValue(body);
+        }
+    }
+    return captures;
+}
+function matchPositionalExpression(variables, body, separator) {
+    if (variables.length === 1) {
+        return { [variables[0].name]: decodeValue(body) };
+    }
+    const captures = {};
+    const fields = body.split(separator);
+    for (let index = 0; index < variables.length && index < fields.length; index += 1) {
+        captures[variables[index].name] = decodeValue(index === variables.length - 1 ? fields.slice(index).join(separator) : fields[index]);
+    }
+    return captures;
+}
+function decodeValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/uri.d.ts

@@ -0,0 +1 @@
+export declare function isValidUri(uri: string): boolean;