@lucern/sdk 0.2.0-alpha.5 → 0.2.0-alpha.7

package/dist/lib/platform/sdk/coreClient.js

@@ -1,366 +0,0 @@
-/**
- * Structured error thrown when a platform API request fails.
- *
- * Includes HTTP status, machine-readable error code, optional invariant
- * reference, and actionable suggestions for common failure modes.
- */
-export class LucernApiError extends Error {
-    code;
-    status;
-    invariant;
-    suggestion;
-    details;
-    requestId;
-    correlationId;
-    policyTraceId;
-    constructor(args) {
-        super(args.message);
-        this.name = "LucernApiError";
-        this.code = args.code;
-        this.status = args.status;
-        this.invariant = args.invariant;
-        this.suggestion = args.suggestion;
-        this.details = args.details;
-        this.requestId = args.requestId;
-        this.correlationId = args.correlationId;
-        this.policyTraceId = args.policyTraceId;
-    }
-}
-/**
- * Serialize a gateway query object into a URL query string.
- */
-export function toQueryString(scope) {
-    const params = new URLSearchParams();
-    if (scope.tenantId) {
-        params.set("tenantId", scope.tenantId);
-    }
-    if (scope.workspaceId) {
-        params.set("workspaceId", scope.workspaceId);
-    }
-    for (const [key, value] of Object.entries(scope)) {
-        if (key === "tenantId" || key === "workspaceId") {
-            continue;
-        }
-        if (value === undefined) {
-            continue;
-        }
-        params.set(key, String(value));
-    }
-    const serialized = params.toString();
-    return serialized.length > 0 ? `?${serialized}` : "";
-}
-function fillRandomBytes(length) {
-    const bytes = new Uint8Array(length);
-    if (typeof globalThis.crypto?.getRandomValues === "function") {
-        globalThis.crypto.getRandomValues(bytes);
-        return bytes;
-    }
-    for (let index = 0; index < length; index += 1) {
-        bytes[index] = Math.floor(Math.random() * 256);
-    }
-    return bytes;
-}
-function generatePortableRequestId() {
-    if (typeof globalThis.crypto?.randomUUID === "function") {
-        return globalThis.crypto.randomUUID();
-    }
-    const bytes = fillRandomBytes(16);
-    bytes[6] = (bytes[6] & 0x0f) | 0x40;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-    const hex = Array.from(bytes, (value) => value.toString(16).padStart(2, "0"));
-    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
-}
-/**
- * Generate a random idempotency key for retry-safe writes.
- */
-export function randomIdempotencyKey() {
-    return generatePortableRequestId();
-}
-function isRetryableStatus(status) {
-    return status >= 500 || status === 408 || status === 429;
-}
-function fallbackErrorCode(status) {
-    if (status === 401) {
-        return "AUTHENTICATION_REQUIRED";
-    }
-    if (status === 403) {
-        return "FORBIDDEN";
-    }
-    if (status === 404) {
-        return "NOT_FOUND";
-    }
-    if (status === 408) {
-        return "UPSTREAM_ERROR";
-    }
-    if (status === 409) {
-        return "CONFLICT";
-    }
-    if (status === 429) {
-        return "RATE_LIMIT_EXCEEDED";
-    }
-    if (status >= 500) {
-        return "UPSTREAM_ERROR";
-    }
-    return "INTERNAL_ERROR";
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function parseRetryAfterMs(value) {
-    if (!value) {
-        return null;
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return null;
-    }
-    const numeric = Number(trimmed);
-    if (Number.isFinite(numeric)) {
-        return Math.max(0, Math.round(numeric * 1000));
-    }
-    const parsedDate = Date.parse(trimmed);
-    if (Number.isFinite(parsedDate)) {
-        return Math.max(0, parsedDate - Date.now());
-    }
-    return null;
-}
-function computeRetryDelayMs(args) {
-    const baseDelay = args.status === 429
-        ? Math.max(args.retryAfterMs ?? 0, Math.min(1000 * 2 ** args.attempt, 10_000))
-        : Math.min(1000 * 2 ** args.attempt, 4000);
-    if (args.status !== 429) {
-        return baseDelay;
-    }
-    const jitterWindow = Math.max(250, Math.round(baseDelay * 0.25));
-    return baseDelay + Math.round(Math.random() * jitterWindow);
-}
-function timeoutError(timeoutMs) {
-    const error = new Error(`Request timed out after ${timeoutMs}ms`);
-    error.name = "AbortError";
-    return error;
-}
-function readPolicySummaryFromDetails(details) {
-    if (!details || typeof details !== "object" || Array.isArray(details)) {
-        return null;
-    }
-    const directSummary = details.summary;
-    if (typeof directSummary === "string" && directSummary.trim().length > 0) {
-        return directSummary.trim();
-    }
-    const policy = details.policy;
-    if (!policy || typeof policy !== "object" || Array.isArray(policy)) {
-        return null;
-    }
-    const explanation = policy.explanation;
-    if (!explanation || typeof explanation !== "object" || Array.isArray(explanation)) {
-        return null;
-    }
-    const nestedSummary = explanation.summary;
-    if (typeof nestedSummary === "string" && nestedSummary.trim().length > 0) {
-        return nestedSummary.trim();
-    }
-    return null;
-}
-/**
- * Create the transport client used by all SDK modules.
- */
-export function createGatewayRequestClient(config = {}) {
-    const fetchImpl = config.fetchImpl ?? fetch;
-    const baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "";
-    const maxRetries = config.maxRetries ?? 2;
-    const requestIdFactory = config.requestIdFactory ?? (() => generatePortableRequestId());
-    async function resolveAuthHeaders() {
-        if (!config.getAuthHeaders) {
-            return {};
-        }
-        return await config.getAuthHeaders();
-    }
-    async function fetchWithTimeout(url, init, timeoutMs) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            return await fetchImpl(url, { ...init, signal: controller.signal });
-        }
-        catch (error) {
-            if (controller.signal.aborted) {
-                throw timeoutError(timeoutMs);
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    async function parsePayload(response) {
-        const text = await response.text();
-        if (!text) {
-            return null;
-        }
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return null;
-        }
-    }
-    function resolveTimeoutMs(method, requestTimeoutMs) {
-        if (typeof requestTimeoutMs === "number") {
-            return requestTimeoutMs;
-        }
-        const methodTimeoutMs = config.timeoutMsByMethod?.[method];
-        if (typeof methodTimeoutMs === "number") {
-            return methodTimeoutMs;
-        }
-        return config.timeoutMs ?? 15_000;
-    }
-    function buildApiError(args) {
-        const failure = args.failure;
-        const legacyError = failure && typeof failure.error === "object" && failure.error !== null
-            ? failure.error
-            : failure?.legacyError;
-        const correlationId = failure?.correlationId ??
-            args.response.headers.get("x-lucern-correlation-id")?.trim() ??
-            args.requestId;
-        const policyTraceId = failure?.policyTraceId ??
-            args.response.headers.get("x-lucern-policy-trace-id")?.trim() ??
-            null;
-        const details = failure?.details ?? legacyError?.details;
-        const policySummary = readPolicySummaryFromDetails(details);
-        return new LucernApiError({
-            code: failure?.code ?? legacyError?.code ?? fallbackErrorCode(args.response.status),
-            message: policySummary ??
-                (typeof failure?.error === "string"
-                    ? failure.error
-                    : legacyError?.message ??
-                        (args.response.ok
-                            ? "Platform API returned an invalid success payload."
-                            : "Platform API request failed.")),
-            status: args.response.status,
-            invariant: failure?.invariant,
-            suggestion: failure?.suggestion,
-            details,
-            requestId: args.requestId,
-            correlationId,
-            policyTraceId,
-        });
-    }
-    async function request(args) {
-        const authHeaders = await resolveAuthHeaders();
-        const method = args.method ?? "GET";
-        const timeoutMs = resolveTimeoutMs(method, args.timeoutMs);
-        const headers = new Headers({
-            "content-type": "application/json",
-            ...authHeaders,
-        });
-        if (args.idempotencyKey) {
-            headers.set("idempotency-key", args.idempotencyKey);
-        }
-        const requestId = headers.get("x-correlation-id")?.trim() ||
-            headers.get("x-request-id")?.trim() ||
-            args.requestId ||
-            requestIdFactory();
-        if (!headers.has("x-correlation-id") && !headers.has("x-request-id")) {
-            headers.set("x-correlation-id", requestId);
-        }
-        const url = `${baseUrl}${args.path}`;
-        const serializedBody = args.body ? JSON.stringify(args.body) : undefined;
-        const init = {
-            method,
-            headers,
-            body: serializedBody,
-        };
-        let lastError;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            const hookRequestContext = {
-                requestId,
-                attempt,
-                maxRetries,
-                method,
-                path: args.path,
-                url,
-                headers: new Headers(headers),
-                body: serializedBody,
-                timeoutMs,
-            };
-            await config.onRequest?.(hookRequestContext);
-            const startedAt = Date.now();
-            try {
-                const response = await fetchWithTimeout(url, init, timeoutMs);
-                const responseClone = response.clone();
-                const payload = await parsePayload(response);
-                const retryAfterMs = parseRetryAfterMs(response.headers.get("Retry-After"));
-                if (!response.ok || !payload?.success) {
-                    const failure = payload && !payload.success ? payload : null;
-                    const apiError = buildApiError({
-                        requestId,
-                        response,
-                        failure,
-                    });
-                    const willRetry = attempt < maxRetries && isRetryableStatus(response.status);
-                    await config.onResponse?.({
-                        ...hookRequestContext,
-                        durationMs: Date.now() - startedAt,
-                        status: response.status,
-                        response: responseClone,
-                        error: apiError,
-                        correlationId: apiError.correlationId ?? requestId,
-                        policyTraceId: apiError.policyTraceId ?? null,
-                        retryAfterMs,
-                        willRetry,
-                    });
-                    if (willRetry) {
-                        lastError = apiError;
-                        await delay(computeRetryDelayMs({
-                            attempt,
-                            status: response.status,
-                            retryAfterMs,
-                        }));
-                        continue;
-                    }
-                    throw apiError;
-                }
-                const successPayload = payload;
-                await config.onResponse?.({
-                    ...hookRequestContext,
-                    durationMs: Date.now() - startedAt,
-                    status: response.status,
-                    response: responseClone,
-                    correlationId: successPayload.correlationId ??
-                        response.headers.get("x-lucern-correlation-id")?.trim() ??
-                        requestId,
-                    policyTraceId: successPayload.policyTraceId ??
-                        response.headers.get("x-lucern-policy-trace-id")?.trim() ??
-                        null,
-                    idempotentReplay: successPayload.idempotentReplay,
-                    retryAfterMs,
-                    willRetry: false,
-                });
-                return successPayload;
-            }
-            catch (fetchError) {
-                if (fetchError instanceof LucernApiError) {
-                    throw fetchError;
-                }
-                const willRetry = attempt < maxRetries;
-                await config.onResponse?.({
-                    ...hookRequestContext,
-                    durationMs: Date.now() - startedAt,
-                    error: fetchError,
-                    correlationId: requestId,
-                    policyTraceId: null,
-                    willRetry,
-                });
-                lastError = fetchError;
-                if (willRetry) {
-                    await delay(computeRetryDelayMs({ attempt }));
-                }
-            }
-        }
-        throw lastError instanceof Error
-            ? lastError
-            : new Error("Platform API request failed after retries.");
-    }
-    return {
-        request,
-    };
-}

package/dist/lib/platform/sdk/customTools.d.ts

@@ -1,83 +0,0 @@
-import { z } from "zod";
-import type { McpToolContract } from "./contracts/mcpTools";
-import type { JsonObject } from "./types";
-type AnyZodObject = z.ZodObject<z.ZodRawShape>;
-/** Origin of a custom tool invocation (SDK call or MCP request). */
-export type CustomToolInvocationSource = "sdk" | "mcp";
-/** Runtime context passed to a custom tool handler during invocation. */
-export type CustomToolInvocationContext = {
-    source: CustomToolInvocationSource;
-};
-/** Optional metadata attached to a custom tool registration. */
-export type CustomToolMetadata = {
-    category?: string;
-    tags?: string[];
-    requiredScopes?: string[];
-};
-/** Input descriptor for registering a custom tool with its schemas and handler. */
-export type CustomToolRegistration<TInput extends AnyZodObject = AnyZodObject, TOutput extends z.ZodTypeAny = z.ZodTypeAny> = {
-    namespace?: string;
-    name: string;
-    description: string;
-    inputSchema: TInput;
-    outputSchema: TOutput;
-    handler: (input: z.infer<TInput>, context: CustomToolInvocationContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
-    metadata?: CustomToolMetadata;
-    ownerModule?: string;
-    ontologyPrimitive?: McpToolContract["ontologyPrimitive"];
-    tier?: McpToolContract["tier"];
-};
-/** A fully resolved custom tool entry stored in the in-memory registry. */
-export type RegisteredCustomTool = {
-    fullName: string;
-    namespace: string;
-    shortName: string;
-    metadata: CustomToolMetadata;
-    contract: McpToolContract;
-    inputSchema: AnyZodObject;
-    outputSchema: z.ZodTypeAny;
-    invoke: (input: JsonObject, context: CustomToolInvocationContext) => Promise<unknown>;
-};
-/** Error thrown when custom tool registration or invocation fails validation. */
-export declare class CustomToolRegistryError extends Error {
-    constructor(message: string);
-}
-/**
- * Register a custom SDK tool in the in-memory registry.
- * @param registration - The tool definition including name, schemas, and handler.
- * @param options - Optional flags; set `replace` to overwrite an existing registration.
- * @returns The fully resolved registered tool entry.
- */
-export declare function registerCustomTool<TInput extends AnyZodObject, TOutput extends z.ZodTypeAny>(registration: CustomToolRegistration<TInput, TOutput>, options?: {
-    replace?: boolean;
-}): RegisteredCustomTool;
-/**
- * Remove a custom SDK tool from the registry.
- * @param fullName - Fully qualified tool name (`namespace.name`).
- * @returns `true` if the tool was found and removed, `false` otherwise.
- */
-export declare function unregisterCustomTool(fullName: string): boolean;
-/**
- * Get a custom SDK tool by fully qualified name.
- * @param fullName - Fully qualified tool name (`namespace.name`).
- * @returns The registered tool entry, or `undefined` if not found.
- */
-export declare function getRegisteredCustomTool(fullName: string): RegisteredCustomTool | undefined;
-/**
- * List all registered custom SDK tools, sorted alphabetically by full name.
- * @returns An array of all registered tool entries.
- */
-export declare function listRegisteredCustomTools(): RegisteredCustomTool[];
-/**
- * Clear the registered custom tool registry.
- */
-export declare function clearRegisteredCustomTools(): void;
-/**
- * Invoke a registered custom SDK tool by fully qualified name.
- * @param fullName - Fully qualified tool name (`namespace.name`).
- * @param params - JSON-serializable input parameters for the tool handler.
- * @param context - Invocation context indicating the call source.
- * @returns The validated output from the tool handler.
- */
-export declare function invokeRegisteredCustomTool(fullName: string, params: JsonObject, context: CustomToolInvocationContext): Promise<unknown>;
-export {};

package/dist/lib/platform/sdk/customTools.js

@@ -1,247 +0,0 @@
-import { z } from "zod";
-/** Default namespace assigned to custom tools when none is specified. */
-const DEFAULT_CUSTOM_NAMESPACE = "custom";
-/** Namespace strings reserved for platform-internal tools. */
-const RESERVED_NAMESPACES = new Set(["lucern"]);
-/** Error thrown when custom tool registration or invocation fails validation. */
-export class CustomToolRegistryError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "CustomToolRegistryError";
-    }
-}
-const customToolRegistry = new Map();
-function normalizeSegment(value, field) {
-    const normalized = value.trim();
-    if (!normalized) {
-        throw new CustomToolRegistryError(`Custom tool ${field} is required.`);
-    }
-    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(normalized)) {
-        throw new CustomToolRegistryError(`Invalid custom tool ${field}: "${value}". Use letters, numbers, "_" or "-".`);
-    }
-    return normalized;
-}
-function normalizeNamespace(namespace) {
-    const resolved = normalizeSegment(namespace ?? DEFAULT_CUSTOM_NAMESPACE, "namespace");
-    if (RESERVED_NAMESPACES.has(resolved.toLowerCase())) {
-        throw new CustomToolRegistryError(`Namespace "${resolved}" is reserved for platform tools.`);
-    }
-    return resolved;
-}
-function normalizeName(name) {
-    if (name.includes(".")) {
-        throw new CustomToolRegistryError(`Custom tool name "${name}" must not include "."; use namespace + name.`);
-    }
-    return normalizeSegment(name, "name");
-}
-function buildFullName(namespace, shortName) {
-    return `${namespace}.${shortName}`;
-}
-function unwrapSchema(schema) {
-    if (schema instanceof z.ZodOptional) {
-        return { schema: schema.unwrap(), required: false };
-    }
-    if (schema instanceof z.ZodDefault) {
-        const removeDefault = schema.removeDefault;
-        if (typeof removeDefault === "function") {
-            return { schema: removeDefault.call(schema), required: false };
-        }
-        const inner = schema
-            ._def?.innerType;
-        return { schema: inner ?? schema, required: false };
-    }
-    return { schema, required: true };
-}
-function resolveParameterType(schema) {
-    if (schema instanceof z.ZodString) {
-        return { type: "string" };
-    }
-    if (schema instanceof z.ZodEnum) {
-        return { type: "string", enum: schema.options };
-    }
-    if (schema instanceof z.ZodNativeEnum) {
-        const values = Object.values(schema.enum).filter((value) => typeof value === "string");
-        return values.length > 0
-            ? { type: "string", enum: values }
-            : { type: "string" };
-    }
-    if (schema instanceof z.ZodLiteral) {
-        const literalValue = schema.value;
-        if (typeof literalValue === "string") {
-            return { type: "string", enum: [literalValue] };
-        }
-        if (typeof literalValue === "number") {
-            return { type: "number" };
-        }
-        if (typeof literalValue === "boolean") {
-            return { type: "boolean" };
-        }
-        return { type: "object" };
-    }
-    if (schema instanceof z.ZodNumber) {
-        return { type: "number" };
-    }
-    if (schema instanceof z.ZodBoolean) {
-        return { type: "boolean" };
-    }
-    if (schema instanceof z.ZodArray) {
-        return { type: "array" };
-    }
-    return { type: "object" };
-}
-function schemaTypeLabel(schema) {
-    if (schema instanceof z.ZodString || schema instanceof z.ZodEnum) {
-        return "string";
-    }
-    if (schema instanceof z.ZodNumber) {
-        return "number";
-    }
-    if (schema instanceof z.ZodBoolean) {
-        return "boolean";
-    }
-    if (schema instanceof z.ZodArray) {
-        return "array";
-    }
-    if (schema instanceof z.ZodObject) {
-        return "object";
-    }
-    return "unknown";
-}
-function parseObjectSchema(value, fieldName) {
-    if (!(value instanceof z.ZodObject)) {
-        throw new CustomToolRegistryError(`${fieldName} must be a Zod object schema.`);
-    }
-    return value;
-}
-function deriveParameters(schema) {
-    const shape = schema.shape;
-    const parameters = {};
-    const required = [];
-    for (const [key, raw] of Object.entries(shape)) {
-        const { schema: unwrapped, required: isRequired } = unwrapSchema(raw);
-        const parameterType = resolveParameterType(unwrapped);
-        parameters[key] = {
-            type: parameterType.type,
-            description: raw.description ?? `${key} parameter`,
-            ...(parameterType.enum ? { enum: parameterType.enum } : {}),
-        };
-        if (isRequired) {
-            required.push(key);
-        }
-    }
-    return { parameters, required };
-}
-function deriveResponse(schema) {
-    if (schema instanceof z.ZodObject) {
-        const fields = Object.fromEntries(Object.entries(schema.shape).map(([key, value]) => {
-            const zodValue = value;
-            const label = schemaTypeLabel(unwrapSchema(zodValue).schema);
-            const description = zodValue.description ?? "custom output field";
-            return [key, `${label} — ${description}`];
-        }));
-        return {
-            description: "Custom tool result payload",
-            fields,
-        };
-    }
-    return {
-        description: "Custom tool result payload",
-        fields: {
-            result: `${schemaTypeLabel(schema)} — custom output payload`,
-        },
-    };
-}
-function buildContract(fullName, namespace, registration, inputSchema) {
-    const { parameters, required } = deriveParameters(inputSchema);
-    return {
-        name: fullName,
-        description: registration.description,
-        parameters,
-        required,
-        response: deriveResponse(registration.outputSchema),
-        ownerModule: registration.ownerModule ?? `${namespace}-extension`,
-        ontologyPrimitive: registration.ontologyPrimitive ?? "task",
-        tier: registration.tier ?? "workhorse",
-    };
-}
-/**
- * Register a custom SDK tool in the in-memory registry.
- * @param registration - The tool definition including name, schemas, and handler.
- * @param options - Optional flags; set `replace` to overwrite an existing registration.
- * @returns The fully resolved registered tool entry.
- */
-export function registerCustomTool(registration, options = {}) {
-    const namespace = normalizeNamespace(registration.namespace);
-    const shortName = normalizeName(registration.name);
-    const fullName = buildFullName(namespace, shortName);
-    if (customToolRegistry.has(fullName) && !options.replace) {
-        throw new CustomToolRegistryError(`Custom tool "${fullName}" is already registered.`);
-    }
-    const inputSchema = parseObjectSchema(registration.inputSchema, "inputSchema");
-    const outputSchema = registration.outputSchema;
-    const contract = buildContract(fullName, namespace, registration, inputSchema);
-    const metadata = {
-        category: registration.metadata?.category,
-        tags: registration.metadata?.tags ?? [],
-        requiredScopes: registration.metadata?.requiredScopes ?? ["custom:execute"],
-    };
-    const registered = {
-        fullName,
-        namespace,
-        shortName,
-        metadata,
-        contract,
-        inputSchema,
-        outputSchema,
-        invoke: async (input, context) => {
-            const parsedInput = inputSchema.parse(input);
-            const rawOutput = await registration.handler(parsedInput, context);
-            return outputSchema.parse(rawOutput);
-        },
-    };
-    customToolRegistry.set(fullName, registered);
-    return registered;
-}
-/**
- * Remove a custom SDK tool from the registry.
- * @param fullName - Fully qualified tool name (`namespace.name`).
- * @returns `true` if the tool was found and removed, `false` otherwise.
- */
-export function unregisterCustomTool(fullName) {
-    return customToolRegistry.delete(fullName.trim());
-}
-/**
- * Get a custom SDK tool by fully qualified name.
- * @param fullName - Fully qualified tool name (`namespace.name`).
- * @returns The registered tool entry, or `undefined` if not found.
- */
-export function getRegisteredCustomTool(fullName) {
-    return customToolRegistry.get(fullName.trim());
-}
-/**
- * List all registered custom SDK tools, sorted alphabetically by full name.
- * @returns An array of all registered tool entries.
- */
-export function listRegisteredCustomTools() {
-    return [...customToolRegistry.values()].sort((left, right) => left.fullName.localeCompare(right.fullName));
-}
-/**
- * Clear the registered custom tool registry.
- */
-export function clearRegisteredCustomTools() {
-    customToolRegistry.clear();
-}
-/**
- * Invoke a registered custom SDK tool by fully qualified name.
- * @param fullName - Fully qualified tool name (`namespace.name`).
- * @param params - JSON-serializable input parameters for the tool handler.
- * @param context - Invocation context indicating the call source.
- * @returns The validated output from the tool handler.
- */
-export async function invokeRegisteredCustomTool(fullName, params, context) {
-    const registered = getRegisteredCustomTool(fullName);
-    if (!registered) {
-        throw new CustomToolRegistryError(`Custom tool "${fullName}" is not registered.`);
-    }
-    return registered.invoke(params, context);
-}