@lucern/sdk 1.0.11 → 1.0.12

package/dist/customTools.d.ts

@@ -1,25 +1,21 @@
-import { z } from 'zod';
-import { McpToolContract } from '@lucern/contracts/tool-contracts';
-import { JsonObject } from './types.js';
-import './contracts/workflow-runtime.contract.js';
-import './contracts/lens-workflow.contract.js';
-import './contracts/lens-filter.contract.js';
-
+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). */
-type CustomToolInvocationSource = "sdk" | "mcp";
+export type CustomToolInvocationSource = "sdk" | "mcp";
 /** Runtime context passed to a custom tool handler during invocation. */
-type CustomToolInvocationContext = {
+export type CustomToolInvocationContext = {
     source: CustomToolInvocationSource;
 };
 /** Optional metadata attached to a custom tool registration. */
-type CustomToolMetadata = {
+export type CustomToolMetadata = {
     category?: string;
     tags?: string[];
     requiredScopes?: string[];
 };
 /** Input descriptor for registering a custom tool with its schemas and handler. */
-type CustomToolRegistration<TInput extends AnyZodObject = AnyZodObject, TOutput extends z.ZodTypeAny = z.ZodTypeAny> = {
+export type CustomToolRegistration<TInput extends AnyZodObject = AnyZodObject, TOutput extends z.ZodTypeAny = z.ZodTypeAny> = {
     namespace?: string;
     name: string;
     description: string;
@@ -32,7 +28,7 @@ type CustomToolRegistration<TInput extends AnyZodObject = AnyZodObject, TOutput
     tier?: McpToolContract["tier"];
 };
 /** A fully resolved custom tool entry stored in the in-memory registry. */
-type RegisteredCustomTool = {
+export type RegisteredCustomTool = {
     fullName: string;
     namespace: string;
     shortName: string;
@@ -43,7 +39,7 @@ type RegisteredCustomTool = {
     invoke: (input: JsonObject, context: CustomToolInvocationContext) => Promise<unknown>;
 };
 /** Error thrown when custom tool registration or invocation fails validation. */
-declare class CustomToolRegistryError extends Error {
+export declare class CustomToolRegistryError extends Error {
     constructor(message: string);
 }
 /**
@@ -52,7 +48,7 @@ declare class CustomToolRegistryError extends Error {
  * @param options - Optional flags; set `replace` to overwrite an existing registration.
  * @returns The fully resolved registered tool entry.
  */
-declare function registerCustomTool<TInput extends AnyZodObject, TOutput extends z.ZodTypeAny>(registration: CustomToolRegistration<TInput, TOutput>, options?: {
+export declare function registerCustomTool<TInput extends AnyZodObject, TOutput extends z.ZodTypeAny>(registration: CustomToolRegistration<TInput, TOutput>, options?: {
     replace?: boolean;
 }): RegisteredCustomTool;
 /**
@@ -60,22 +56,22 @@ declare function registerCustomTool<TInput extends AnyZodObject, TOutput extends
  * @param fullName - Fully qualified tool name (`namespace.name`).
  * @returns `true` if the tool was found and removed, `false` otherwise.
  */
-declare function unregisterCustomTool(fullName: string): boolean;
+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.
  */
-declare function getRegisteredCustomTool(fullName: string): RegisteredCustomTool | undefined;
+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.
  */
-declare function listRegisteredCustomTools(): RegisteredCustomTool[];
+export declare function listRegisteredCustomTools(): RegisteredCustomTool[];
 /**
  * Clear the registered custom tool registry.
  */
-declare function clearRegisteredCustomTools(): void;
+export declare function clearRegisteredCustomTools(): void;
 /**
  * Invoke a registered custom SDK tool by fully qualified name.
  * @param fullName - Fully qualified tool name (`namespace.name`).
@@ -83,6 +79,6 @@ declare function clearRegisteredCustomTools(): void;
  * @param context - Invocation context indicating the call source.
  * @returns The validated output from the tool handler.
  */
-declare function invokeRegisteredCustomTool(fullName: string, params: JsonObject, context: CustomToolInvocationContext): Promise<unknown>;
-
-export { type CustomToolInvocationContext, type CustomToolInvocationSource, type CustomToolMetadata, type CustomToolRegistration, CustomToolRegistryError, type RegisteredCustomTool, clearRegisteredCustomTools, getRegisteredCustomTool, invokeRegisteredCustomTool, listRegisteredCustomTools, registerCustomTool, unregisterCustomTool };
+export declare function invokeRegisteredCustomTool(fullName: string, params: JsonObject, context: CustomToolInvocationContext): Promise<unknown>;
+export {};
+//# sourceMappingURL=customTools.d.ts.map

package/dist/customTools.js

@@ -1,248 +1,248 @@
-import { z } from 'zod';
-
-// src/customTools.ts
-var DEFAULT_CUSTOM_NAMESPACE = "custom";
-var RESERVED_NAMESPACES = /* @__PURE__ */ new Set(["lucern"]);
-var CustomToolRegistryError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CustomToolRegistryError";
-  }
-};
-var customToolRegistry = /* @__PURE__ */ new Map();
+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;
+    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;
+    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");
+    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}`;
+    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 };
+    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" };
+    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" };
-  }
-  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";
+    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;
+    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);
+    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 };
+    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} \u2014 ${description}`];
-      })
-    );
+    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
+        description: "Custom tool result payload",
+        fields: {
+            result: `${schemaTypeLabel(schema)} — custom output payload`,
+        },
     };
-  }
-  return {
-    description: "Custom tool result payload",
-    fields: {
-      result: `${schemaTypeLabel(schema)} \u2014 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"
-  };
-}
-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;
-}
-function unregisterCustomTool(fullName) {
-  return customToolRegistry.delete(fullName.trim());
-}
-function getRegisteredCustomTool(fullName) {
-  return customToolRegistry.get(fullName.trim());
-}
-function listRegisteredCustomTools() {
-  return [...customToolRegistry.values()].sort(
-    (left, right) => left.fullName.localeCompare(right.fullName)
-  );
-}
-function clearRegisteredCustomTools() {
-  customToolRegistry.clear();
-}
-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);
-}
-
-export { CustomToolRegistryError, clearRegisteredCustomTools, getRegisteredCustomTool, invokeRegisteredCustomTool, listRegisteredCustomTools, registerCustomTool, unregisterCustomTool };
-//# sourceMappingURL=customTools.js.map
+    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);
+}
 //# sourceMappingURL=customTools.js.map

package/dist/decisions/index.d.ts

@@ -1,59 +1,9 @@
-import { LucernClientConfig } from '../clientConfig.js';
-import * as sdkMethods_contract from '@lucern/contracts/sdk-methods.contract';
-export { sdkMethods_contract as methodSchemas };
-import * as toolContracts from '@lucern/contracts/tool-contracts';
-export { toolContracts as toolSchemas };
-import '../clientHelpers.js';
-import '../types.js';
-import '../contracts/workflow-runtime.contract.js';
-import '../contracts/lens-workflow.contract.js';
-import '../contracts/lens-filter.contract.js';
-import '../adminClient.js';
-import '../coreClient.js';
-import '@lucern/transport-core';
-import '../authContext.js';
-import '../contracts/auth-session.contract.js';
-import '../controlObjectOwnership.js';
-import '../answersClient.js';
-import '../audiencesClient.js';
-import '../auditClient.js';
-import '../beliefsClient.js';
-import '../opinion.js';
-import '../contextClient.js';
-import '../contextTypes.js';
-import '../control-plane.js';
-import '../decisionsClient.js';
-import '../embeddingsClient.js';
-import '../boundaryClientSurface.js';
-import '../eventingClient.js';
-import '../evidenceClient.js';
-import '../functionSurface.js';
-import '../graphAnalysisClient.js';
-import '@lucern/contracts';
-import '../graphClient.js';
-import '../graphRecommendationsClient.js';
-import '../graphStateClassifierClient.js';
-import '../harnessClient.js';
-import '../identityClient.js';
-import '../jobsClient.js';
-import '../learningClient.js';
-import '../modelRuntimeClient.js';
-import '../ontologyClient.js';
-import '../ontologyLinksClient.js';
-import '../orgGraphSearchClient.js';
-import '../packsClient.js';
-import '../policyClient.js';
-import '../reportsClient.js';
-import '../schemaClient.js';
-import '../sourcesClient.js';
-import '../telemetryClient.js';
-import '../toolRegistryClient.js';
-import '../topicsClient.js';
-import '../workflowClient.js';
-
-type DecisionsClientConfig = LucernClientConfig;
-type DecisionsClient = ReturnType<typeof createDecisionsClient>;
-declare function createDecisionsClient(config?: DecisionsClientConfig): {
+import { type LucernClientConfig } from "../client";
+export * as methodSchemas from "@lucern/contracts/sdk-methods.contract";
+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;
@@ -79,5 +29,4 @@ declare function createDecisionsClient(config?: DecisionsClientConfig): {
         }): any;
     };
 };
-
-export { type DecisionsClient, type DecisionsClientConfig, createDecisionsClient };
+//# sourceMappingURL=index.d.ts.map