@qqbrowser/openclaw-qbot 0.10.17 → 0.10.18

package/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js

@@ -1,209 +0,0 @@
-// zod-compat.ts
-// ----------------------------------------------------
-// Unified types + helpers to accept Zod v3 and v4 (Mini)
-// ----------------------------------------------------
-import * as z3rt from 'zod/v3';
-import * as z4mini from 'zod/v4-mini';
-// --- Runtime detection ---
-export function isZ4Schema(s) {
-    // Present on Zod 4 (Classic & Mini) schemas; absent on Zod 3
-    const schema = s;
-    return !!schema._zod;
-}
-// --- Schema construction ---
-export function objectFromShape(shape) {
-    const values = Object.values(shape);
-    if (values.length === 0)
-        return z4mini.object({}); // default to v4 Mini
-    const allV4 = values.every(isZ4Schema);
-    const allV3 = values.every(s => !isZ4Schema(s));
-    if (allV4)
-        return z4mini.object(shape);
-    if (allV3)
-        return z3rt.object(shape);
-    throw new Error('Mixed Zod versions detected in object shape.');
-}
-// --- Unified parsing ---
-export function safeParse(schema, data) {
-    if (isZ4Schema(schema)) {
-        // Mini exposes top-level safeParse
-        const result = z4mini.safeParse(schema, data);
-        return result;
-    }
-    const v3Schema = schema;
-    const result = v3Schema.safeParse(data);
-    return result;
-}
-export async function safeParseAsync(schema, data) {
-    if (isZ4Schema(schema)) {
-        // Mini exposes top-level safeParseAsync
-        const result = await z4mini.safeParseAsync(schema, data);
-        return result;
-    }
-    const v3Schema = schema;
-    const result = await v3Schema.safeParseAsync(data);
-    return result;
-}
-// --- Shape extraction ---
-export function getObjectShape(schema) {
-    if (!schema)
-        return undefined;
-    // Zod v3 exposes `.shape`; Zod v4 keeps the shape on `_zod.def.shape`
-    let rawShape;
-    if (isZ4Schema(schema)) {
-        const v4Schema = schema;
-        rawShape = v4Schema._zod?.def?.shape;
-    }
-    else {
-        const v3Schema = schema;
-        rawShape = v3Schema.shape;
-    }
-    if (!rawShape)
-        return undefined;
-    if (typeof rawShape === 'function') {
-        try {
-            return rawShape();
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return rawShape;
-}
-// --- Schema normalization ---
-/**
- * Normalizes a schema to an object schema. Handles both:
- * - Already-constructed object schemas (v3 or v4)
- * - Raw shapes that need to be wrapped into object schemas
- */
-export function normalizeObjectSchema(schema) {
-    if (!schema)
-        return undefined;
-    // First check if it's a raw shape (Record<string, AnySchema>)
-    // Raw shapes don't have _def or _zod properties and aren't schemas themselves
-    if (typeof schema === 'object') {
-        // Check if it's actually a ZodRawShapeCompat (not a schema instance)
-        // by checking if it lacks schema-like internal properties
-        const asV3 = schema;
-        const asV4 = schema;
-        // If it's not a schema instance (no _def or _zod), it might be a raw shape
-        if (!asV3._def && !asV4._zod) {
-            // Check if all values are schemas (heuristic to confirm it's a raw shape)
-            const values = Object.values(schema);
-            if (values.length > 0 &&
-                values.every(v => typeof v === 'object' &&
-                    v !== null &&
-                    (v._def !== undefined ||
-                        v._zod !== undefined ||
-                        typeof v.parse === 'function'))) {
-                return objectFromShape(schema);
-            }
-        }
-    }
-    // If we get here, it should be an AnySchema (not a raw shape)
-    // Check if it's already an object schema
-    if (isZ4Schema(schema)) {
-        // Check if it's a v4 object
-        const v4Schema = schema;
-        const def = v4Schema._zod?.def;
-        if (def && (def.type === 'object' || def.shape !== undefined)) {
-            return schema;
-        }
-    }
-    else {
-        // Check if it's a v3 object
-        const v3Schema = schema;
-        if (v3Schema.shape !== undefined) {
-            return schema;
-        }
-    }
-    return undefined;
-}
-// --- Error message extraction ---
-/**
- * Safely extracts an error message from a parse result error.
- * Zod errors can have different structures, so we handle various cases.
- */
-export function getParseErrorMessage(error) {
-    if (error && typeof error === 'object') {
-        // Try common error structures
-        if ('message' in error && typeof error.message === 'string') {
-            return error.message;
-        }
-        if ('issues' in error && Array.isArray(error.issues) && error.issues.length > 0) {
-            const firstIssue = error.issues[0];
-            if (firstIssue && typeof firstIssue === 'object' && 'message' in firstIssue) {
-                return String(firstIssue.message);
-            }
-        }
-        // Fallback: try to stringify the error
-        try {
-            return JSON.stringify(error);
-        }
-        catch {
-            return String(error);
-        }
-    }
-    return String(error);
-}
-// --- Schema metadata access ---
-/**
- * Gets the description from a schema, if available.
- * Works with both Zod v3 and v4.
- *
- * Both versions expose a `.description` getter that returns the description
- * from their respective internal storage (v3: _def, v4: globalRegistry).
- */
-export function getSchemaDescription(schema) {
-    return schema.description;
-}
-/**
- * Checks if a schema is optional.
- * Works with both Zod v3 and v4.
- */
-export function isSchemaOptional(schema) {
-    if (isZ4Schema(schema)) {
-        const v4Schema = schema;
-        return v4Schema._zod?.def?.type === 'optional';
-    }
-    const v3Schema = schema;
-    // v3 has isOptional() method
-    if (typeof schema.isOptional === 'function') {
-        return schema.isOptional();
-    }
-    return v3Schema._def?.typeName === 'ZodOptional';
-}
-/**
- * Gets the literal value from a schema, if it's a literal schema.
- * Works with both Zod v3 and v4.
- * Returns undefined if the schema is not a literal or the value cannot be determined.
- */
-export function getLiteralValue(schema) {
-    if (isZ4Schema(schema)) {
-        const v4Schema = schema;
-        const def = v4Schema._zod?.def;
-        if (def) {
-            // Try various ways to get the literal value
-            if (def.value !== undefined)
-                return def.value;
-            if (Array.isArray(def.values) && def.values.length > 0) {
-                return def.values[0];
-            }
-        }
-    }
-    const v3Schema = schema;
-    const def = v3Schema._def;
-    if (def) {
-        if (def.value !== undefined)
-            return def.value;
-        if (Array.isArray(def.values) && def.values.length > 0) {
-            return def.values[0];
-        }
-    }
-    // Fallback: check for direct value property (some Zod versions)
-    const directValue = schema.value;
-    if (directValue !== undefined)
-        return directValue;
-    return undefined;
-}
-//# sourceMappingURL=zod-compat.js.map

package/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js

@@ -1,51 +0,0 @@
-// zod-json-schema-compat.ts
-// ----------------------------------------------------
-// JSON Schema conversion for both Zod v3 and Zod v4 (Mini)
-// v3 uses your vendored converter; v4 uses Mini's toJSONSchema
-// ----------------------------------------------------
-import * as z4mini from 'zod/v4-mini';
-import { getObjectShape, safeParse, isZ4Schema, getLiteralValue } from './zod-compat.js';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-function mapMiniTarget(t) {
-    if (!t)
-        return 'draft-7';
-    if (t === 'jsonSchema7' || t === 'draft-7')
-        return 'draft-7';
-    if (t === 'jsonSchema2019-09' || t === 'draft-2020-12')
-        return 'draft-2020-12';
-    return 'draft-7'; // fallback
-}
-export function toJsonSchemaCompat(schema, opts) {
-    if (isZ4Schema(schema)) {
-        // v4 branch — use Mini's built-in toJSONSchema
-        return z4mini.toJSONSchema(schema, {
-            target: mapMiniTarget(opts?.target),
-            io: opts?.pipeStrategy ?? 'input'
-        });
-    }
-    // v3 branch — use vendored converter
-    return zodToJsonSchema(schema, {
-        strictUnions: opts?.strictUnions ?? true,
-        pipeStrategy: opts?.pipeStrategy ?? 'input'
-    });
-}
-export function getMethodLiteral(schema) {
-    const shape = getObjectShape(schema);
-    const methodSchema = shape?.method;
-    if (!methodSchema) {
-        throw new Error('Schema is missing a method literal');
-    }
-    const value = getLiteralValue(methodSchema);
-    if (typeof value !== 'string') {
-        throw new Error('Schema method literal must be a string');
-    }
-    return value;
-}
-export function parseWithCompat(schema, data) {
-    const result = safeParse(schema, data);
-    if (!result.success) {
-        throw result.error;
-    }
-    return result.data;
-}
-//# sourceMappingURL=zod-json-schema-compat.js.map

package/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js

@@ -1,44 +0,0 @@
-/**
- * Utilities for handling OAuth resource URIs.
- */
-/**
- * Converts a server URL to a resource URL by removing the fragment.
- * RFC 8707 section 2 states that resource URIs "MUST NOT include a fragment component".
- * Keeps everything else unchanged (scheme, domain, port, path, query).
- */
-export function resourceUrlFromServerUrl(url) {
-    const resourceURL = typeof url === 'string' ? new URL(url) : new URL(url.href);
-    resourceURL.hash = ''; // Remove fragment
-    return resourceURL;
-}
-/**
- * Checks if a requested resource URL matches a configured resource URL.
- * A requested resource matches if it has the same scheme, domain, port,
- * and its path starts with the configured resource's path.
- *
- * @param requestedResource The resource URL being requested
- * @param configuredResource The resource URL that has been configured
- * @returns true if the requested resource matches the configured resource, false otherwise
- */
-export function checkResourceAllowed({ requestedResource, configuredResource }) {
-    const requested = typeof requestedResource === 'string' ? new URL(requestedResource) : new URL(requestedResource.href);
-    const configured = typeof configuredResource === 'string' ? new URL(configuredResource) : new URL(configuredResource.href);
-    // Compare the origin (scheme, domain, and port)
-    if (requested.origin !== configured.origin) {
-        return false;
-    }
-    // Handle cases like requested=/foo and configured=/foo/
-    if (requested.pathname.length < configured.pathname.length) {
-        return false;
-    }
-    // Check if the requested path starts with the configured path
-    // Ensure both paths end with / for proper comparison
-    // This ensures that if we have paths like "/api" and "/api/users",
-    // we properly detect that "/api/users" is a subpath of "/api"
-    // By adding a trailing slash if missing, we avoid false positives
-    // where paths like "/api123" would incorrectly match "/api"
-    const requestedPath = requested.pathname.endsWith('/') ? requested.pathname : requested.pathname + '/';
-    const configuredPath = configured.pathname.endsWith('/') ? configured.pathname : configured.pathname + '/';
-    return requestedPath.startsWith(configuredPath);
-}
-//# sourceMappingURL=auth-utils.js.map

package/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js

@@ -1,198 +0,0 @@
-import * as z from 'zod/v4';
-/**
- * Reusable URL validation that disallows javascript: scheme
- */
-export const SafeUrlSchema = z
-    .url()
-    .superRefine((val, ctx) => {
-    if (!URL.canParse(val)) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'URL must be parseable',
-            fatal: true
-        });
-        return z.NEVER;
-    }
-})
-    .refine(url => {
-    const u = new URL(url);
-    return u.protocol !== 'javascript:' && u.protocol !== 'data:' && u.protocol !== 'vbscript:';
-}, { message: 'URL cannot use javascript:, data:, or vbscript: scheme' });
-/**
- * RFC 9728 OAuth Protected Resource Metadata
- */
-export const OAuthProtectedResourceMetadataSchema = z.looseObject({
-    resource: z.string().url(),
-    authorization_servers: z.array(SafeUrlSchema).optional(),
-    jwks_uri: z.string().url().optional(),
-    scopes_supported: z.array(z.string()).optional(),
-    bearer_methods_supported: z.array(z.string()).optional(),
-    resource_signing_alg_values_supported: z.array(z.string()).optional(),
-    resource_name: z.string().optional(),
-    resource_documentation: z.string().optional(),
-    resource_policy_uri: z.string().url().optional(),
-    resource_tos_uri: z.string().url().optional(),
-    tls_client_certificate_bound_access_tokens: z.boolean().optional(),
-    authorization_details_types_supported: z.array(z.string()).optional(),
-    dpop_signing_alg_values_supported: z.array(z.string()).optional(),
-    dpop_bound_access_tokens_required: z.boolean().optional()
-});
-/**
- * RFC 8414 OAuth 2.0 Authorization Server Metadata
- */
-export const OAuthMetadataSchema = z.looseObject({
-    issuer: z.string(),
-    authorization_endpoint: SafeUrlSchema,
-    token_endpoint: SafeUrlSchema,
-    registration_endpoint: SafeUrlSchema.optional(),
-    scopes_supported: z.array(z.string()).optional(),
-    response_types_supported: z.array(z.string()),
-    response_modes_supported: z.array(z.string()).optional(),
-    grant_types_supported: z.array(z.string()).optional(),
-    token_endpoint_auth_methods_supported: z.array(z.string()).optional(),
-    token_endpoint_auth_signing_alg_values_supported: z.array(z.string()).optional(),
-    service_documentation: SafeUrlSchema.optional(),
-    revocation_endpoint: SafeUrlSchema.optional(),
-    revocation_endpoint_auth_methods_supported: z.array(z.string()).optional(),
-    revocation_endpoint_auth_signing_alg_values_supported: z.array(z.string()).optional(),
-    introspection_endpoint: z.string().optional(),
-    introspection_endpoint_auth_methods_supported: z.array(z.string()).optional(),
-    introspection_endpoint_auth_signing_alg_values_supported: z.array(z.string()).optional(),
-    code_challenge_methods_supported: z.array(z.string()).optional(),
-    client_id_metadata_document_supported: z.boolean().optional()
-});
-/**
- * OpenID Connect Discovery 1.0 Provider Metadata
- * see: https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata
- */
-export const OpenIdProviderMetadataSchema = z.looseObject({
-    issuer: z.string(),
-    authorization_endpoint: SafeUrlSchema,
-    token_endpoint: SafeUrlSchema,
-    userinfo_endpoint: SafeUrlSchema.optional(),
-    jwks_uri: SafeUrlSchema,
-    registration_endpoint: SafeUrlSchema.optional(),
-    scopes_supported: z.array(z.string()).optional(),
-    response_types_supported: z.array(z.string()),
-    response_modes_supported: z.array(z.string()).optional(),
-    grant_types_supported: z.array(z.string()).optional(),
-    acr_values_supported: z.array(z.string()).optional(),
-    subject_types_supported: z.array(z.string()),
-    id_token_signing_alg_values_supported: z.array(z.string()),
-    id_token_encryption_alg_values_supported: z.array(z.string()).optional(),
-    id_token_encryption_enc_values_supported: z.array(z.string()).optional(),
-    userinfo_signing_alg_values_supported: z.array(z.string()).optional(),
-    userinfo_encryption_alg_values_supported: z.array(z.string()).optional(),
-    userinfo_encryption_enc_values_supported: z.array(z.string()).optional(),
-    request_object_signing_alg_values_supported: z.array(z.string()).optional(),
-    request_object_encryption_alg_values_supported: z.array(z.string()).optional(),
-    request_object_encryption_enc_values_supported: z.array(z.string()).optional(),
-    token_endpoint_auth_methods_supported: z.array(z.string()).optional(),
-    token_endpoint_auth_signing_alg_values_supported: z.array(z.string()).optional(),
-    display_values_supported: z.array(z.string()).optional(),
-    claim_types_supported: z.array(z.string()).optional(),
-    claims_supported: z.array(z.string()).optional(),
-    service_documentation: z.string().optional(),
-    claims_locales_supported: z.array(z.string()).optional(),
-    ui_locales_supported: z.array(z.string()).optional(),
-    claims_parameter_supported: z.boolean().optional(),
-    request_parameter_supported: z.boolean().optional(),
-    request_uri_parameter_supported: z.boolean().optional(),
-    require_request_uri_registration: z.boolean().optional(),
-    op_policy_uri: SafeUrlSchema.optional(),
-    op_tos_uri: SafeUrlSchema.optional(),
-    client_id_metadata_document_supported: z.boolean().optional()
-});
-/**
- * OpenID Connect Discovery metadata that may include OAuth 2.0 fields
- * This schema represents the real-world scenario where OIDC providers
- * return a mix of OpenID Connect and OAuth 2.0 metadata fields
- */
-export const OpenIdProviderDiscoveryMetadataSchema = z.object({
-    ...OpenIdProviderMetadataSchema.shape,
-    ...OAuthMetadataSchema.pick({
-        code_challenge_methods_supported: true
-    }).shape
-});
-/**
- * OAuth 2.1 token response
- */
-export const OAuthTokensSchema = z
-    .object({
-    access_token: z.string(),
-    id_token: z.string().optional(), // Optional for OAuth 2.1, but necessary in OpenID Connect
-    token_type: z.string(),
-    expires_in: z.coerce.number().optional(),
-    scope: z.string().optional(),
-    refresh_token: z.string().optional()
-})
-    .strip();
-/**
- * OAuth 2.1 error response
- */
-export const OAuthErrorResponseSchema = z.object({
-    error: z.string(),
-    error_description: z.string().optional(),
-    error_uri: z.string().optional()
-});
-/**
- * Optional version of SafeUrlSchema that allows empty string for retrocompatibility on tos_uri and logo_uri
- */
-export const OptionalSafeUrlSchema = SafeUrlSchema.optional().or(z.literal('').transform(() => undefined));
-/**
- * RFC 7591 OAuth 2.0 Dynamic Client Registration metadata
- */
-export const OAuthClientMetadataSchema = z
-    .object({
-    redirect_uris: z.array(SafeUrlSchema),
-    token_endpoint_auth_method: z.string().optional(),
-    grant_types: z.array(z.string()).optional(),
-    response_types: z.array(z.string()).optional(),
-    client_name: z.string().optional(),
-    client_uri: SafeUrlSchema.optional(),
-    logo_uri: OptionalSafeUrlSchema,
-    scope: z.string().optional(),
-    contacts: z.array(z.string()).optional(),
-    tos_uri: OptionalSafeUrlSchema,
-    policy_uri: z.string().optional(),
-    jwks_uri: SafeUrlSchema.optional(),
-    jwks: z.any().optional(),
-    software_id: z.string().optional(),
-    software_version: z.string().optional(),
-    software_statement: z.string().optional()
-})
-    .strip();
-/**
- * RFC 7591 OAuth 2.0 Dynamic Client Registration client information
- */
-export const OAuthClientInformationSchema = z
-    .object({
-    client_id: z.string(),
-    client_secret: z.string().optional(),
-    client_id_issued_at: z.number().optional(),
-    client_secret_expires_at: z.number().optional()
-})
-    .strip();
-/**
- * RFC 7591 OAuth 2.0 Dynamic Client Registration full response (client information plus metadata)
- */
-export const OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
-/**
- * RFC 7591 OAuth 2.0 Dynamic Client Registration error response
- */
-export const OAuthClientRegistrationErrorSchema = z
-    .object({
-    error: z.string(),
-    error_description: z.string().optional()
-})
-    .strip();
-/**
- * RFC 7009 OAuth 2.0 Token Revocation request
- */
-export const OAuthTokenRevocationRequestSchema = z
-    .object({
-    token: z.string(),
-    token_type_hint: z.string().optional()
-})
-    .strip();
-//# sourceMappingURL=auth.js.map

package/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/metadataUtils.js

@@ -1,22 +0,0 @@
-/**
- * Utilities for working with BaseMetadata objects.
- */
-/**
- * Gets the display name for an object with BaseMetadata.
- * For tools, the precedence is: title → annotations.title → name
- * For other objects: title → name
- * This implements the spec requirement: "if no title is provided, name should be used for display purposes"
- */
-export function getDisplayName(metadata) {
-    // First check for title (not undefined and not empty string)
-    if (metadata.title !== undefined && metadata.title !== '') {
-        return metadata.title;
-    }
-    // Then check for annotations.title (only present in Tool objects)
-    if ('annotations' in metadata && metadata.annotations?.title) {
-        return metadata.annotations.title;
-    }
-    // Finally fall back to name
-    return metadata.name;
-}
-//# sourceMappingURL=metadataUtils.js.map