@lucern/sdk 1.0.29 → 1.0.31

package/dist/coreClient.js

@@ -1,13 +1,15 @@
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
 import { createTelemetryExporterFromEnv, emitTelemetrySignal, } from "@lucern/transport-core";
 import { redactDiagnosticValue } from "@lucern/transport-core/redaction";
 import { classifyRetry } from "@lucern/transport-core/transport";
-import { Cause, Effect, Exit } from "effect";
+import { Cause, Effect, Either, Exit, Schema } from "effect";
 import { createCanonicalAuthHeaders, LucernSdkAuthContextError, normalizeCanonicalLucernAuthContext, } from "./authContext.js";
 const DEFAULT_GATEWAY_TIMEOUT_MS = 15_000;
 const DEFAULT_GATEWAY_MAX_RETRIES = 2;
 const DEFAULT_ENV_TIMEOUT_MS = "LUCERN_REQUEST_TIMEOUT_MS";
 const DEFAULT_ENV_MAX_RETRIES = "LUCERN_GATEWAY_MAX_RETRIES";
 const ENV_TIMEOUT_BY_METHOD_PREFIX = "LUCERN_REQUEST_TIMEOUT_MS_";
+const TRAILING_SLASHES_PATTERN = /\/+$/u;
 export class GatewayTimeoutError extends Error {
     retryable = true;
     timeoutMs;
@@ -28,12 +30,12 @@ export class GatewayTransportError extends Error {
     }
 }
 export function isGatewayRecoverableError(error) {
-    return error instanceof GatewayTimeoutError || error instanceof GatewayTransportError;
+    return (error instanceof GatewayTimeoutError ||
+        error instanceof GatewayTransportError);
 }
 export function isGatewayRetryableError(error) {
     return ((error instanceof GatewayTimeoutError && error.retryable) ||
-        (error instanceof GatewayTransportError && error.retryable) ||
-        false);
+        (error instanceof GatewayTransportError && error.retryable));
 }
 /**
  * Structured error thrown when a platform API request fails.
@@ -63,29 +65,85 @@ export class LucernApiError extends Error {
         this.policyTraceId = args.policyTraceId;
     }
 }
+const JsonValueSchema = Schema.Unknown.pipe(Schema.filter((value) => isJsonValue(value), {
+    message: () => "Expected a JSON-serializable value",
+}));
+const GatewayLegacyErrorSchema = Schema.Struct({
+    code: Schema.String,
+    message: Schema.String,
+    details: Schema.optional(JsonValueSchema),
+});
+const GatewaySuccessDataSchema = Schema.Unknown.pipe(Schema.filter((value) => value !== undefined, {
+    message: () => "Expected gateway success data to be present",
+}));
+const GatewaySuccessEnvelopeSchema = Schema.Struct({
+    success: Schema.Literal(true),
+    data: GatewaySuccessDataSchema,
+    correlationId: Schema.String,
+    idempotentReplay: Schema.Boolean,
+    policyTraceId: Schema.NullOr(Schema.String),
+});
+const GatewayFailureEnvelopeSchema = Schema.Struct({
+    success: Schema.Literal(false),
+    error: Schema.Union(Schema.String, GatewayLegacyErrorSchema),
+    code: Schema.optional(Schema.String),
+    correlationId: Schema.String,
+    details: Schema.optional(JsonValueSchema),
+    invariant: Schema.optional(Schema.NullOr(Schema.String)),
+    legacyError: Schema.optional(GatewayLegacyErrorSchema),
+    policyTraceId: Schema.NullOr(Schema.String),
+    suggestion: Schema.optional(Schema.NullOr(Schema.String)),
+});
+const GatewayEnvelopeSchema = Schema.Union(GatewaySuccessEnvelopeSchema, GatewayFailureEnvelopeSchema);
+const GatewayJsonBodySchema = Schema.Unknown.pipe(Schema.filter((value) => value === undefined || isJsonValue(value, { allowUndefined: true }), {
+    message: () => "Expected a JSON-serializable request body",
+}));
 /**
  * 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 preferredKey of ["tenantId", "workspaceId"]) {
+        const preferredValue = Object.entries(scope).find(([key]) => key === preferredKey)?.[1];
+        const serialized = serializeGatewayQueryValue(preferredValue);
+        if (serialized !== undefined) {
+            params.set(preferredKey, serialized);
+        }
     }
     for (const [key, value] of Object.entries(scope)) {
         if (key === "tenantId" || key === "workspaceId") {
             continue;
         }
-        if (value === undefined) {
-            continue;
+        const serialized = serializeGatewayQueryValue(value);
+        if (serialized !== undefined) {
+            params.set(key, serialized);
         }
-        params.set(key, String(value));
     }
     const serialized = params.toString();
     return serialized.length > 0 ? `?${serialized}` : "";
 }
+function serializeGatewayQueryValue(value) {
+    const decoded = Schema.decodeUnknownEither(GatewayJsonBodySchema)(value);
+    if (Either.isLeft(decoded)) {
+        throw new TypeError("Gateway query values must be JSON-serializable.");
+    }
+    const queryValue = decoded.right;
+    if (queryValue === undefined || queryValue === null) {
+        return;
+    }
+    if (Array.isArray(queryValue)) {
+        return queryValue
+            .filter((item) => item !== undefined && item !== null)
+            .map((item) => String(item))
+            .join(",");
+    }
+    if (typeof queryValue === "string" ||
+        typeof queryValue === "number" ||
+        typeof queryValue === "boolean") {
+        return String(queryValue);
+    }
+    throw new TypeError("Gateway query values must be scalar or arrays.");
+}
 function fillRandomBytes(length) {
     const bytes = new Uint8Array(length);
     if (typeof globalThis.crypto?.getRandomValues === "function") {
@@ -102,10 +160,14 @@ function generatePortableRequestId() {
         return globalThis.crypto.randomUUID();
     }
     const bytes = fillRandomBytes(16);
+    // biome-ignore lint/suspicious/noBitwiseOperators: UUID v4 fallback must set version bits.
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // biome-ignore lint/suspicious/noBitwiseOperators: UUID v4 fallback must set variant bits.
     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("")}`;
+    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("")}`;
 }
 function resolveEnvironment() {
     const processEnv = typeof globalThis === "object" &&
@@ -186,7 +248,7 @@ function parseIntegerFromString(value, rawValue) {
         return value;
     }
     if (typeof rawValue !== "string" || !rawValue.trim()) {
-        return undefined;
+        return;
     }
     const parsed = Number.parseInt(rawValue, 10);
     return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
@@ -198,7 +260,7 @@ function resolveGatewayBaseUrl(configBaseUrl, environment) {
     const envBaseUrl = environment.get("LUCERN_API_URL") ??
         environment.get("LUCERN_BASE_URL") ??
         environment.get("LUCERN_GATEWAY_BASE_URL");
-    return (configBaseUrl ?? envBaseUrl ?? "").replace(/\/+$/, "");
+    return (configBaseUrl ?? envBaseUrl ?? "").replace(TRAILING_SLASHES_PATTERN, "");
 }
 function normalizeGatewayEnvironment(value) {
     return value === "sandbox" || value === "production" ? value : undefined;
@@ -250,6 +312,34 @@ function classifyGatewayErrorForRetry(error) {
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isPlainObject(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, options = {}) {
+    if (value === undefined) {
+        return options.allowUndefined === true;
+    }
+    if (value === null) {
+        return true;
+    }
+    if (typeof value === "string" || typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonValue(item, options));
+    }
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return Object.values(value).every((entry) => isJsonValue(entry, options));
+}
 function readPolicySummaryFromDetails(details) {
     if (!isRecord(details)) {
         return null;
@@ -298,6 +388,21 @@ function cleanHeaderValue(value) {
     const normalized = value?.trim();
     return normalized ? normalized : undefined;
 }
+function sdkTelemetryEventName(context) {
+    if (context.willRetry) {
+        return "sdk.retry";
+    }
+    if (context.error) {
+        return "sdk.request.error";
+    }
+    return "sdk.request.complete";
+}
+function sdkTelemetrySeverity(context) {
+    if (!context.error) {
+        return "info";
+    }
+    return context.willRetry ? "warn" : "error";
+}
 /**
  * Create the transport client used by all SDK modules.
  */
@@ -334,7 +439,7 @@ export function createGatewayRequestClient(config = {}) {
         setIfAbsent("x-lucern-deployment-host", config.deploymentHost);
         const base = Object.fromEntries(headers.entries());
         const authContextInput = await resolveConfiguredAuthContext(config.authContext);
-        if (!authContextInput && !config.requireCanonicalAuthContext) {
+        if (!(authContextInput || config.requireCanonicalAuthContext)) {
             return base;
         }
         const authContext = normalizeCanonicalLucernAuthContext(authContextInput);
@@ -385,12 +490,8 @@ export function createGatewayRequestClient(config = {}) {
         await emitTelemetrySignal(telemetryExporter, {
             signalType: "trace",
             surface: "sdk-retry",
-            eventName: context.willRetry
-                ? "sdk.retry"
-                : context.error
-                    ? "sdk.request.error"
-                    : "sdk.request.complete",
-            severity: context.error ? (context.willRetry ? "warn" : "error") : "info",
+            eventName: sdkTelemetryEventName(context),
+            severity: sdkTelemetrySeverity(context),
             durationMs: context.durationMs,
             metricName: "sdk.request.duration_ms",
             metricValue: context.durationMs,
@@ -428,9 +529,21 @@ export function createGatewayRequestClient(config = {}) {
         if (!parsed.ok) {
             return null;
         }
-        return isRecord(parsed.value)
-            ? parsed.value
-            : null;
+        return decodeGatewayEnvelope(parsed.value);
+    }
+    function decodeGatewayEnvelope(value) {
+        const decoded = Schema.decodeUnknownEither(GatewayEnvelopeSchema)(value);
+        if (Either.isLeft(decoded)) {
+            return null;
+        }
+        const envelope = decoded.right;
+        if (envelope.success) {
+            return {
+                ...envelope,
+                data: envelope.data,
+            };
+        }
+        return envelope;
     }
     function resolveTimeoutMs(method, requestTimeoutMs) {
         if (typeof requestTimeoutMs === "number") {
@@ -444,7 +557,7 @@ export function createGatewayRequestClient(config = {}) {
     }
     function tryParseGatewayEnvelopeJson(text) {
         const trimmed = text.trim();
-        if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) {
             return { ok: false, reason: "non-json" };
         }
         try {
@@ -468,9 +581,7 @@ export function createGatewayRequestClient(config = {}) {
             null;
         const details = runtime.redaction(redactJsonDiagnosticValue(failure?.details ?? legacyError?.details));
         const policySummary = readPolicySummaryFromDetails(details);
-        const failureMessage = typeof failure?.error === "string"
-            ? failure.error
-            : legacyError?.message;
+        const failureMessage = typeof failure?.error === "string" ? failure.error : legacyError?.message;
         return new LucernApiError({
             code: failure?.code ??
                 legacyError?.code ??
@@ -489,6 +600,97 @@ export function createGatewayRequestClient(config = {}) {
             policyTraceId,
         });
     }
+    async function emitGatewayResponseContext(context) {
+        await config.onResponse?.(context);
+        await emitSdkResponseTelemetry(context);
+    }
+    function buildGatewayRequestHookContext(args) {
+        return {
+            requestId: args.requestId,
+            attempt: args.attempt,
+            maxRetries: args.maxRetries,
+            method: args.method,
+            path: args.path,
+            url: args.url,
+            headers: new Headers(args.headers),
+            body: args.body,
+            timeoutMs: args.timeoutMs,
+        };
+    }
+    async function handleGatewayHttpResponse(args) {
+        if (!(args.response.ok && args.payload?.success)) {
+            const failure = args.payload && !args.payload.success
+                ? args.payload
+                : null;
+            const apiError = buildApiError({
+                requestId: args.requestId,
+                response: args.response,
+                failure,
+            });
+            const willRetry = args.attempt < args.maxRetries && args.retryable;
+            await emitGatewayResponseContext({
+                ...args.hookRequestContext,
+                durationMs: Date.now() - args.startedAt,
+                status: args.response.status,
+                response: args.responseClone,
+                error: apiError,
+                correlationId: apiError.correlationId ?? args.requestId,
+                policyTraceId: apiError.policyTraceId ?? null,
+                retryAfterMs: args.retryAfterMs,
+                willRetry,
+            });
+            if (willRetry) {
+                return {
+                    retryError: apiError,
+                    retryDelayMs: computeRetryDelayMs({
+                        attempt: args.attempt,
+                        status: args.response.status,
+                        retryAfterMs: args.retryAfterMs,
+                    }),
+                };
+            }
+            throw apiError;
+        }
+        const successPayload = args.payload;
+        await emitGatewayResponseContext({
+            ...args.hookRequestContext,
+            durationMs: Date.now() - args.startedAt,
+            status: args.response.status,
+            response: args.responseClone,
+            correlationId: successPayload.correlationId ??
+                args.response.headers.get("x-lucern-correlation-id")?.trim() ??
+                args.requestId,
+            policyTraceId: successPayload.policyTraceId ??
+                args.response.headers.get("x-lucern-policy-trace-id")?.trim() ??
+                null,
+            idempotentReplay: successPayload.idempotentReplay,
+            retryAfterMs: args.retryAfterMs,
+            willRetry: false,
+        });
+        return { success: successPayload };
+    }
+    async function handleGatewayFetchError(args) {
+        if (args.error instanceof LucernApiError) {
+            throw args.error;
+        }
+        const willRetry = args.attempt < args.maxRetries &&
+            classifyGatewayErrorForRetry(args.error);
+        await emitGatewayResponseContext({
+            ...args.hookRequestContext,
+            durationMs: Date.now() - args.startedAt,
+            error: args.error,
+            correlationId: args.requestId,
+            policyTraceId: null,
+            willRetry,
+        });
+        if (willRetry) {
+            return {
+                retryError: args.error,
+                retryDelayMs: computeRetryDelayMs({ attempt: args.attempt }),
+            };
+        }
+        throw args.error;
+    }
     async function request(args) {
         const authHeaders = await resolveAuthHeaders();
         const method = args.method ?? "GET";
@@ -504,11 +706,11 @@ export function createGatewayRequestClient(config = {}) {
             headers.get("x-request-id")?.trim() ||
             args.requestId ||
             requestIdFactory();
-        if (!headers.has("x-correlation-id") && !headers.has("x-request-id")) {
+        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 serializedBody = args.body === undefined ? undefined : stringifyGatewayJsonBody(args.body);
         const init = {
             method,
             headers,
@@ -516,17 +718,17 @@ export function createGatewayRequestClient(config = {}) {
         };
         let lastError;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            const hookRequestContext = {
+            const hookRequestContext = buildGatewayRequestHookContext({
                 requestId,
                 attempt,
                 maxRetries,
                 method,
                 path: args.path,
                 url,
-                headers: new Headers(headers),
+                headers,
                 body: serializedBody,
                 timeoutMs,
-            };
+            });
             await config.onRequest?.(hookRequestContext);
             const startedAt = Date.now();
             try {
@@ -538,77 +740,36 @@ export function createGatewayRequestClient(config = {}) {
                     retryAfter: response.headers.get("Retry-After"),
                 });
                 const retryAfterMs = retry.retryAfterMs ?? null;
-                if (!response.ok || !payload?.success) {
-                    const failure = payload && !payload.success ? payload : null;
-                    const apiError = buildApiError({
-                        requestId,
-                        response,
-                        failure,
-                    });
-                    const willRetry = attempt < maxRetries && retry.retryable;
-                    const responseContext = {
-                        ...hookRequestContext,
-                        durationMs: Date.now() - startedAt,
-                        status: response.status,
-                        response: responseClone,
-                        error: apiError,
-                        correlationId: apiError.correlationId ?? requestId,
-                        policyTraceId: apiError.policyTraceId ?? null,
-                        retryAfterMs,
-                        willRetry,
-                    };
-                    await config.onResponse?.(responseContext);
-                    await emitSdkResponseTelemetry(responseContext);
-                    if (willRetry) {
-                        lastError = apiError;
-                        await delay(computeRetryDelayMs({
-                            attempt,
-                            status: response.status,
-                            retryAfterMs,
-                        }));
-                        continue;
-                    }
-                    throw apiError;
-                }
-                const successPayload = payload;
-                const responseContext = {
-                    ...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,
+                const attemptResult = await handleGatewayHttpResponse({
+                    attempt,
+                    hookRequestContext,
+                    maxRetries,
+                    payload,
+                    requestId,
+                    response,
+                    responseClone,
                     retryAfterMs,
-                    willRetry: false,
-                };
-                await config.onResponse?.(responseContext);
-                await emitSdkResponseTelemetry(responseContext);
-                return successPayload;
+                    retryable: retry.retryable,
+                    startedAt,
+                });
+                if ("retryError" in attemptResult) {
+                    lastError = attemptResult.retryError;
+                    await delay(attemptResult.retryDelayMs);
+                    continue;
+                }
+                return attemptResult.success;
             }
             catch (fetchError) {
-                if (fetchError instanceof LucernApiError) {
-                    throw fetchError;
-                }
-                const willRetry = attempt < maxRetries && classifyGatewayErrorForRetry(fetchError);
-                const responseContext = {
-                    ...hookRequestContext,
-                    durationMs: Date.now() - startedAt,
+                const attemptResult = await handleGatewayFetchError({
+                    attempt,
                     error: fetchError,
-                    correlationId: requestId,
-                    policyTraceId: null,
-                    willRetry,
-                };
-                await config.onResponse?.(responseContext);
-                await emitSdkResponseTelemetry(responseContext);
-                lastError = fetchError;
-                if (willRetry) {
-                    await delay(computeRetryDelayMs({ attempt }));
-                }
+                    hookRequestContext,
+                    maxRetries,
+                    requestId,
+                    startedAt,
+                });
+                lastError = attemptResult.retryError;
+                await delay(attemptResult.retryDelayMs);
             }
         }
         throw lastError instanceof Error
@@ -619,4 +780,11 @@ export function createGatewayRequestClient(config = {}) {
         request,
     };
 }
+function stringifyGatewayJsonBody(body) {
+    const decoded = Schema.decodeUnknownEither(GatewayJsonBodySchema)(body);
+    if (Either.isLeft(decoded)) {
+        throw new GatewayTransportError("Gateway request body must be JSON-serializable.", { retryable: false });
+    }
+    return JSON.stringify(decoded.right);
+}
 //# sourceMappingURL=coreClient.js.map

package/dist/customTools.d.ts

@@ -5,39 +5,39 @@ 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 = {
+export interface CustomToolInvocationContext {
     source: CustomToolInvocationSource;
-};
+}
 /** Optional metadata attached to a custom tool registration. */
-export type CustomToolMetadata = {
+export interface CustomToolMetadata {
     category?: string;
-    tags?: string[];
     requiredScopes?: string[];
-};
+    tags?: 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;
+export interface CustomToolRegistration<TInput extends AnyZodObject = AnyZodObject, TOutput extends z.ZodTypeAny = z.ZodTypeAny> {
     description: string;
-    inputSchema: TInput;
-    outputSchema: TOutput;
     handler: (input: z.infer<TInput>, context: CustomToolInvocationContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+    inputSchema: TInput;
     metadata?: CustomToolMetadata;
-    ownerModule?: string;
+    name: string;
+    namespace?: string;
     ontologyPrimitive?: McpToolContract["ontologyPrimitive"];
+    outputSchema: TOutput;
+    ownerModule?: string;
     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;
+export interface RegisteredCustomTool {
     contract: McpToolContract;
+    fullName: string;
     inputSchema: AnyZodObject;
-    outputSchema: z.ZodTypeAny;
     invoke: (input: JsonObject, context: CustomToolInvocationContext) => Promise<unknown>;
-};
+    metadata: CustomToolMetadata;
+    namespace: string;
+    outputSchema: z.ZodTypeAny;
+    shortName: string;
+}
 /** Error thrown when custom tool registration or invocation fails validation. */
 export declare class CustomToolRegistryError extends Error {
     constructor(message: string);

package/dist/customTools.js

@@ -1,8 +1,10 @@
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
 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"]);
+const CUSTOM_TOOL_SEGMENT_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
 /** Error thrown when custom tool registration or invocation fails validation. */
 export class CustomToolRegistryError extends Error {
     constructor(message) {
@@ -16,7 +18,7 @@ function normalizeSegment(value, field) {
     if (!normalized) {
         throw new CustomToolRegistryError(`Custom tool ${field} is required.`);
     }
-    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(normalized)) {
+    if (!CUSTOM_TOOL_SEGMENT_PATTERN.test(normalized)) {
         throw new CustomToolRegistryError(`Invalid custom tool ${field}: "${value}". Use letters, numbers, "_" or "-".`);
     }
     return normalized;
@@ -238,7 +240,7 @@ export function clearRegisteredCustomTools() {
  * @param context - Invocation context indicating the call source.
  * @returns The validated output from the tool handler.
  */
-export async function invokeRegisteredCustomTool(fullName, params, context) {
+export function invokeRegisteredCustomTool(fullName, params, context) {
     const registered = getRegisteredCustomTool(fullName);
     if (!registered) {
         throw new CustomToolRegistryError(`Custom tool "${fullName}" is not registered.`);

package/dist/decisions/index.d.ts

@@ -4,29 +4,29 @@ export * as toolSchemas from "@lucern/contracts/tool-contracts";
 export type DecisionsClientConfig = LucernClientConfig;
 export type DecisionsClient = ReturnType<typeof createDecisionsClient>;
 export declare function createDecisionsClient(config?: DecisionsClientConfig): {
-    createDecision: any;
-    getDecision: any;
-    listDecisions: any;
-    recordDecisionOutcome: any;
-    updateDecisionOutcome: any;
-    getDecisionReadiness: (topicId: string) => any;
-    getDecisionCalibration: (topicId: string) => any;
-    listPendingDecisionOutcomeReviews: (topicId: string) => any;
+    createDecision: (input: import("..").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentResponse>>;
+    getDecision: (judgmentId: string) => Promise<import("..").PlatformGatewaySuccess<import("..").GetJudgmentResponse>>;
+    listDecisions: (query: import("..").ListJudgmentsInput) => Promise<import("..").PlatformGatewaySuccess<import("..").ListJudgmentsResponse>>;
+    recordDecisionOutcome: (judgmentId: string, input: import("..").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentOutcomeResponse>>;
+    updateDecisionOutcome: (judgmentId: string, input: import("..").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentOutcomeResponse>>;
+    getDecisionReadiness: (topicId: string) => Promise<import("..").PlatformGatewaySuccess<import("..").JudgmentReadinessResponse>>;
+    getDecisionCalibration: (topicId: string) => Promise<import("..").PlatformGatewaySuccess<import("..").JudgmentCalibrationResponse>>;
+    listPendingDecisionOutcomeReviews: (topicId: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ListResult<import("..").PendingJudgmentOutcomeRecord, "reviews">>>;
     raw: {
-        create: any;
-        record: any;
-        list: any;
-        get: any;
-        recordOutcome: any;
-        updateOutcome: any;
-        readiness(topicId: string): any;
-        calibration(topicId: string): any;
-        pendingOutcomeReview(topicId: string): any;
+        create: (input: import("..").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentResponse>>;
+        record: (input: import("..").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentResponse>>;
+        list: (query: import("..").ListJudgmentsInput) => Promise<import("..").PlatformGatewaySuccess<import("..").ListJudgmentsResponse>>;
+        get: (judgmentId: string) => Promise<import("..").PlatformGatewaySuccess<import("..").GetJudgmentResponse>>;
+        recordOutcome: (judgmentId: string, input: import("..").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentOutcomeResponse>>;
+        updateOutcome: (judgmentId: string, input: import("..").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").RecordJudgmentOutcomeResponse>>;
+        readiness(topicId: string): Promise<import("..").PlatformGatewaySuccess<import("..").JudgmentReadinessResponse>>;
+        calibration(topicId: string): Promise<import("..").PlatformGatewaySuccess<import("..").JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string): Promise<import("..").PlatformGatewaySuccess<import("..").ListResult<import("..").PendingJudgmentOutcomeRecord, "reviews">>>;
         transitionAuditIntegrity(args: {
             topicId?: string;
             judgmentId?: string;
             includePassing?: boolean;
-        }): any;
+        }): Promise<import("..").PlatformGatewaySuccess<import("..").JudgmentTransitionAuditIntegrityResponse>>;
     };
 };
 //# sourceMappingURL=index.d.ts.map