@jaypie/testkit 1.2.4 → 1.2.7

package/dist/mock/dynamodb.d.ts

@@ -0,0 +1,81 @@
+import * as original from "@jaypie/dynamodb";
+import type { ArchiveEntityParams, BaseQueryOptions, DeleteEntityParams, DynamoClientConfig, FabricEntity, GetEntityParams, ParentReference, PutEntityParams, QueryByAliasParams, QueryByClassParams, QueryByOuParams, QueryByTypeParams, QueryByXidParams, QueryResult, UpdateEntityParams } from "@jaypie/dynamodb";
+export declare const APEX = "@";
+export declare const ARCHIVED_SUFFIX = "#archived";
+export declare const DELETED_SUFFIX = "#deleted";
+export declare const INDEX_ALIAS = "indexAlias";
+export declare const INDEX_CLASS = "indexClass";
+export declare const INDEX_OU = "indexOu";
+export declare const INDEX_TYPE = "indexType";
+export declare const INDEX_XID = "indexXid";
+export declare const SEPARATOR = "#";
+export declare const buildIndexAlias: ((ou: string, model: string, alias: string) => string) & {
+    mock: any;
+};
+export declare const buildIndexClass: ((ou: string, model: string, recordClass: string) => string) & {
+    mock: any;
+};
+export declare const buildIndexOu: ((ou: string, model: string) => string) & {
+    mock: any;
+};
+export declare const buildIndexType: ((ou: string, model: string, type: string) => string) & {
+    mock: any;
+};
+export declare const buildIndexXid: ((ou: string, model: string, xid: string) => string) & {
+    mock: any;
+};
+export declare const calculateOu: ((parent?: ParentReference) => string) & {
+    mock: any;
+};
+export declare const indexEntity: (<T extends FabricEntity>(entity: T, suffix?: string) => T) & {
+    mock: any;
+};
+export declare const initClient: ((config: DynamoClientConfig) => void) & {
+    mock: any;
+};
+export declare const getDocClient: ((...args: any[]) => any) & {
+    mock: any;
+};
+export declare const getTableName: ((...args: any[]) => any) & {
+    mock: any;
+};
+export declare const isInitialized: ((...args: any[]) => any) & {
+    mock: any;
+};
+export declare const resetClient: ((...args: any[]) => any) & {
+    mock: any;
+};
+export declare const getEntity: (<T extends FabricEntity = original.FabricEntity>(params: GetEntityParams) => Promise<T | null>) & {
+    mock: any;
+};
+export declare const putEntity: (<T extends FabricEntity>(params: PutEntityParams<T>) => Promise<T>) & {
+    mock: any;
+};
+export declare const updateEntity: (<T extends FabricEntity>(params: UpdateEntityParams<T>) => Promise<T>) & {
+    mock: any;
+};
+export declare const deleteEntity: ((params: DeleteEntityParams) => Promise<boolean>) & {
+    mock: any;
+};
+export declare const archiveEntity: ((params: ArchiveEntityParams) => Promise<boolean>) & {
+    mock: any;
+};
+export declare const destroyEntity: ((params: DeleteEntityParams) => Promise<boolean>) & {
+    mock: any;
+};
+export declare const queryByOu: (<T extends FabricEntity = original.FabricEntity>(params: QueryByOuParams) => Promise<QueryResult<T>>) & {
+    mock: any;
+};
+export declare const queryByAlias: (<T extends FabricEntity = original.FabricEntity>(params: QueryByAliasParams) => Promise<T | null>) & {
+    mock: any;
+};
+export declare const queryByClass: (<T extends FabricEntity = original.FabricEntity>(params: QueryByClassParams) => Promise<QueryResult<T>>) & {
+    mock: any;
+};
+export declare const queryByType: (<T extends FabricEntity = original.FabricEntity>(params: QueryByTypeParams) => Promise<QueryResult<T>>) & {
+    mock: any;
+};
+export declare const queryByXid: (<T extends FabricEntity = original.FabricEntity>(params: QueryByXidParams) => Promise<T | null>) & {
+    mock: any;
+};
+export type { BaseQueryOptions, FabricEntity, ParentReference, QueryResult };

package/dist/mock/index.d.ts

@@ -3,7 +3,10 @@
 import * as vitest from 'vitest';
 import * as errors from '@jaypie/errors';
 import * as kit from '@jaypie/kit';
-import * as original from '@jaypie/llm';
+import * as original from '@jaypie/dynamodb';
+import { ParentReference, FabricEntity, DynamoClientConfig, GetEntityParams, PutEntityParams, UpdateEntityParams, DeleteEntityParams, ArchiveEntityParams, QueryByOuParams, QueryResult, QueryByAliasParams, QueryByClassParams, QueryByTypeParams, QueryByXidParams } from '@jaypie/dynamodb';
+export { BaseQueryOptions, FabricEntity, ParentReference, QueryResult } from '@jaypie/dynamodb';
+import * as original$1 from '@jaypie/llm';
 export { FORMAT, LEVEL, Logger, log } from '@jaypie/logger';
 export { mongoose } from '@jaypie/mongoose';
 
@@ -311,6 +314,85 @@ declare const submitDistribution: vitest.Mock<(...args: any[]) => any>;
 declare const submitMetric: vitest.Mock<(...args: any[]) => any>;
 declare const submitMetricSet: vitest.Mock<(...args: any[]) => any>;
 
+declare const APEX = "@";
+declare const ARCHIVED_SUFFIX = "#archived";
+declare const DELETED_SUFFIX = "#deleted";
+declare const INDEX_ALIAS = "indexAlias";
+declare const INDEX_CLASS = "indexClass";
+declare const INDEX_OU = "indexOu";
+declare const INDEX_TYPE = "indexType";
+declare const INDEX_XID = "indexXid";
+declare const SEPARATOR = "#";
+declare const buildIndexAlias: ((ou: string, model: string, alias: string) => string) & {
+    mock: any;
+};
+declare const buildIndexClass: ((ou: string, model: string, recordClass: string) => string) & {
+    mock: any;
+};
+declare const buildIndexOu: ((ou: string, model: string) => string) & {
+    mock: any;
+};
+declare const buildIndexType: ((ou: string, model: string, type: string) => string) & {
+    mock: any;
+};
+declare const buildIndexXid: ((ou: string, model: string, xid: string) => string) & {
+    mock: any;
+};
+declare const calculateOu: ((parent?: ParentReference) => string) & {
+    mock: any;
+};
+declare const indexEntity: (<T extends FabricEntity>(entity: T, suffix?: string) => T) & {
+    mock: any;
+};
+declare const initClient: ((config: DynamoClientConfig) => void) & {
+    mock: any;
+};
+declare const getDocClient: ((...args: any[]) => any) & {
+    mock: any;
+};
+declare const getTableName: ((...args: any[]) => any) & {
+    mock: any;
+};
+declare const isInitialized: ((...args: any[]) => any) & {
+    mock: any;
+};
+declare const resetClient: ((...args: any[]) => any) & {
+    mock: any;
+};
+declare const getEntity: (<T extends FabricEntity = original.FabricEntity>(params: GetEntityParams) => Promise<T | null>) & {
+    mock: any;
+};
+declare const putEntity: (<T extends FabricEntity>(params: PutEntityParams<T>) => Promise<T>) & {
+    mock: any;
+};
+declare const updateEntity: (<T extends FabricEntity>(params: UpdateEntityParams<T>) => Promise<T>) & {
+    mock: any;
+};
+declare const deleteEntity: ((params: DeleteEntityParams) => Promise<boolean>) & {
+    mock: any;
+};
+declare const archiveEntity: ((params: ArchiveEntityParams) => Promise<boolean>) & {
+    mock: any;
+};
+declare const destroyEntity: ((params: DeleteEntityParams) => Promise<boolean>) & {
+    mock: any;
+};
+declare const queryByOu: (<T extends FabricEntity = original.FabricEntity>(params: QueryByOuParams) => Promise<QueryResult<T>>) & {
+    mock: any;
+};
+declare const queryByAlias: (<T extends FabricEntity = original.FabricEntity>(params: QueryByAliasParams) => Promise<T | null>) & {
+    mock: any;
+};
+declare const queryByClass: (<T extends FabricEntity = original.FabricEntity>(params: QueryByClassParams) => Promise<QueryResult<T>>) & {
+    mock: any;
+};
+declare const queryByType: (<T extends FabricEntity = original.FabricEntity>(params: QueryByTypeParams) => Promise<QueryResult<T>>) & {
+    mock: any;
+};
+declare const queryByXid: (<T extends FabricEntity = original.FabricEntity>(params: QueryByXidParams) => Promise<T | null>) & {
+    mock: any;
+};
+
 declare const EXPRESS: {
     readonly PATH: {
         readonly ANY: "*";
@@ -382,25 +464,25 @@ declare const lambdaStreamHandler: ((handler: StreamHandlerFunction, props?: Lam
     mock: any;
 };
 
-declare const LLM: typeof original.LLM;
+declare const LLM: typeof original$1.LLM;
 declare const Llm: vitest.Mock<(...args: any[]) => any> & {
     operate: vitest.Mock<(...args: any[]) => any>;
     send: vitest.Mock<(...args: any[]) => any>;
 };
-declare const Toolkit: typeof original.Toolkit;
-declare const JaypieToolkit: typeof original.JaypieToolkit;
-declare const LlmMessageRole: typeof original.LlmMessageRole;
-declare const LlmMessageType: typeof original.LlmMessageType;
-declare const LlmStreamChunkType: typeof original.LlmStreamChunkType;
-declare const GeminiProvider: typeof original.GeminiProvider;
-declare const OpenRouterProvider: typeof original.OpenRouterProvider;
-declare const extractReasoning: typeof original.extractReasoning;
-declare const isLlmOperateInput: typeof original.isLlmOperateInput;
-declare const isLlmOperateInputContent: typeof original.isLlmOperateInputContent;
-declare const isLlmOperateInputFile: typeof original.isLlmOperateInputFile;
-declare const isLlmOperateInputImage: typeof original.isLlmOperateInputImage;
-declare const toolkit: original.JaypieToolkit;
-declare const tools: Omit<original.LlmTool, "call">[];
+declare const Toolkit: typeof original$1.Toolkit;
+declare const JaypieToolkit: typeof original$1.JaypieToolkit;
+declare const LlmMessageRole: typeof original$1.LlmMessageRole;
+declare const LlmMessageType: typeof original$1.LlmMessageType;
+declare const LlmStreamChunkType: typeof original$1.LlmStreamChunkType;
+declare const GeminiProvider: typeof original$1.GeminiProvider;
+declare const OpenRouterProvider: typeof original$1.OpenRouterProvider;
+declare const extractReasoning: typeof original$1.extractReasoning;
+declare const isLlmOperateInput: typeof original$1.isLlmOperateInput;
+declare const isLlmOperateInputContent: typeof original$1.isLlmOperateInputContent;
+declare const isLlmOperateInputFile: typeof original$1.isLlmOperateInputFile;
+declare const isLlmOperateInputImage: typeof original$1.isLlmOperateInputImage;
+declare const toolkit: original$1.JaypieToolkit;
+declare const tools: Omit<original$1.LlmTool, "call">[];
 
 interface JsonApiError {
   errors: Array<{
@@ -483,7 +565,22 @@ declare const MarkdownPage: any;
  */
 declare const textractJsonToMarkdown: vitest.Mock<(...args: any[]) => any>;
 
+declare const STATUS_VALUES: readonly ["canceled", "complete", "error", "pending", "processing", "queued", "sending"];
+type Status = (typeof STATUS_VALUES)[number];
+declare const StatusType: ("canceled" | "complete" | "error" | "pending" | "processing" | "queued" | "sending")[];
+declare function isStatus(value: unknown): value is Status;
 type ServiceHandlerFunction = (input?: Record<string, unknown> | string) => Promise<unknown>;
+interface ServiceHandlerFunctionWithMetadata extends ServiceHandlerFunction {
+    alias?: string;
+    description?: string;
+    input?: Record<string, InputFieldDefinition>;
+}
+interface InputFieldDefinition {
+    default?: unknown;
+    description?: string;
+    required?: boolean;
+    type: unknown;
+}
 interface LambdaServiceHandlerOptions {
     chaos?: string;
     name?: string;
@@ -505,8 +602,69 @@ type HandlerFunction = (...args: unknown[]) => unknown;
 declare const lambdaServiceHandler: ((handlerOrConfig: ServiceHandlerFunction | LambdaServiceHandlerConfig, options?: LambdaServiceHandlerOptions) => HandlerFunction) & {
     mock: any;
 };
+interface LlmTool {
+    call: (args?: Record<string, unknown>) => Promise<unknown> | unknown;
+    description: string;
+    message?: string | ((args?: Record<string, unknown>, context?: {
+        name: string;
+    }) => Promise<string> | string);
+    name: string;
+    parameters: Record<string, unknown>;
+    type: "function" | string;
+}
+interface CreateLlmToolConfig {
+    description?: string;
+    exclude?: string[];
+    handler: ServiceHandlerFunctionWithMetadata;
+    message?: string | ((args?: Record<string, unknown>) => string);
+    name?: string;
+}
+interface CreateLlmToolResult {
+    tool: LlmTool;
+}
+/**
+ * Mock implementation of createLlmTool
+ * Creates an LLM tool from a vocabulary service handler
+ */
+declare const createLlmTool: ((config: CreateLlmToolConfig) => CreateLlmToolResult) & {
+    mock: any;
+};
+/**
+ * Mock implementation of inputToJsonSchema
+ * Converts vocabulary input definitions to JSON Schema
+ */
+declare const inputToJsonSchema: ((input?: Record<string, InputFieldDefinition>, options?: {
+    exclude?: string[];
+}) => Record<string, unknown>) & {
+    mock: any;
+};
+interface McpToolResponse {
+    content: Array<{
+        text: string;
+        type: "text";
+    }>;
+}
+interface McpServer {
+    tool: (name: string, description: string, schema: Record<string, unknown>, handler: (args: Record<string, unknown>) => Promise<McpToolResponse>) => void;
+}
+interface RegisterMcpToolConfig {
+    description?: string;
+    handler: ServiceHandlerFunctionWithMetadata;
+    name?: string;
+    server: McpServer;
+}
+interface RegisterMcpToolResult {
+    name: string;
+}
+/**
+ * Mock implementation of registerMcpTool
+ * Registers a vocabulary service handler as an MCP tool
+ */
+declare const registerMcpTool: ((config: RegisterMcpToolConfig) => RegisterMcpToolResult) & {
+    mock: any;
+};
 
 declare const mock: Record<string, any>;
 
-export { BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieStream, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, createExpressStream, createJaypieStream, createLambdaStream, createLogger, mock as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, expressStreamHandler, extractReasoning, forbiddenRoute, force, formatError, formatSSE, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getS3FileBuffer, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, isLocalEnv, isNodeTestEnv, isProductionEnv, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, lambdaServiceHandler, lambdaStreamHandler, loadEnvSecrets, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, streamToSSE, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid };
-export type { ExpressHandlerFunction, ExpressHandlerOptions, ExpressStreamHandlerFunction, ExpressStreamHandlerOptions, LambdaOptions };
+export { APEX, ARCHIVED_SUFFIX, BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, DELETED_SUFFIX, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP, INDEX_ALIAS, INDEX_CLASS, INDEX_OU, INDEX_TYPE, INDEX_XID, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieStream, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, SEPARATOR, STATUS_VALUES, StatusType, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, archiveEntity, badRequestRoute, buildIndexAlias, buildIndexClass, buildIndexOu, buildIndexType, buildIndexXid, calculateOu, cloneDeep, connect, connectFromSecretEnv, cors, createExpressStream, createJaypieStream, createLambdaStream, createLlmTool, createLogger, mock as default, deleteEntity, destroyEntity, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, expressStreamHandler, extractReasoning, forbiddenRoute, force, formatError, formatSSE, getDocClient, getEntity, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getS3FileBuffer, getSecret, getSingletonMessage, getTableName, getTextractJob, goneRoute, hasDatadogEnv, indexEntity, initClient, inputToJsonSchema, isClass, isInitialized, isJaypieError, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, isLocalEnv, isNodeTestEnv, isProductionEnv, isStatus, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, lambdaServiceHandler, lambdaStreamHandler, loadEnvSecrets, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, putEntity, queryByAlias, queryByClass, queryByOu, queryByType, queryByXid, registerMcpTool, resetClient, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, streamToSSE, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, updateEntity, uuid };
+export type { ExpressHandlerFunction, ExpressHandlerOptions, ExpressStreamHandlerFunction, ExpressStreamHandlerOptions, LambdaOptions, Status };

package/dist/mock/index.js

@@ -593,6 +593,207 @@ var datadog = /*#__PURE__*/Object.freeze({
     submitMetricSet: submitMetricSet
 });
 
+// Primary markers
+const APEX$1 = "@"; // Root-level marker (DynamoDB prohibits empty strings)
+const SEPARATOR$1 = "#"; // Composite key separator
+// GSI names
+const INDEX_ALIAS$1 = "indexAlias";
+const INDEX_CLASS$1 = "indexClass";
+const INDEX_OU$1 = "indexOu";
+const INDEX_TYPE$1 = "indexType";
+const INDEX_XID$1 = "indexXid";
+// Index suffixes for soft state
+const ARCHIVED_SUFFIX$1 = "#archived";
+const DELETED_SUFFIX$1 = "#deleted";
+
+/**
+ * Build the indexOu key for hierarchical queries
+ * @param ou - The organizational unit (APEX or "{parent.model}#{parent.id}")
+ * @param model - The entity model name
+ * @returns Composite key: "{ou}#{model}"
+ */
+function buildIndexOu$1(ou, model) {
+    return `${ou}${SEPARATOR$1}${model}`;
+}
+/**
+ * Build the indexAlias key for human-friendly lookups
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param alias - The human-friendly alias
+ * @returns Composite key: "{ou}#{model}#{alias}"
+ */
+function buildIndexAlias$1(ou, model, alias) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${alias}`;
+}
+/**
+ * Build the indexClass key for category filtering
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param recordClass - The category classification
+ * @returns Composite key: "{ou}#{model}#{class}"
+ */
+function buildIndexClass$1(ou, model, recordClass) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${recordClass}`;
+}
+/**
+ * Build the indexType key for type filtering
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param type - The type classification
+ * @returns Composite key: "{ou}#{model}#{type}"
+ */
+function buildIndexType$1(ou, model, type) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${type}`;
+}
+/**
+ * Build the indexXid key for external ID lookups
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param xid - The external ID
+ * @returns Composite key: "{ou}#{model}#{xid}"
+ */
+function buildIndexXid$1(ou, model, xid) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${xid}`;
+}
+/**
+ * Calculate the organizational unit from a parent reference
+ * @param parent - Optional parent entity reference
+ * @returns APEX ("@") if no parent, otherwise "{parent.model}#{parent.id}"
+ */
+function calculateOu$1(parent) {
+    if (!parent) {
+        return APEX$1;
+    }
+    return `${parent.model}${SEPARATOR$1}${parent.id}`;
+}
+/**
+ * Auto-populate GSI index keys on an entity
+ * - indexOu is always populated from ou + model
+ * - indexAlias is populated only when alias is present
+ * - indexClass is populated only when class is present
+ * - indexType is populated only when type is present
+ * - indexXid is populated only when xid is present
+ *
+ * @param entity - The entity to populate index keys for
+ * @param suffix - Optional suffix to append to all index keys (e.g., "#deleted", "#archived")
+ * @returns The entity with populated index keys
+ */
+function indexEntity$1(entity, suffix = "") {
+    const result = { ...entity };
+    // indexOu is always set (from ou + model)
+    result.indexOu = buildIndexOu$1(entity.ou, entity.model) + suffix;
+    // Optional indexes - only set when the source field is present
+    if (entity.alias !== undefined) {
+        result.indexAlias =
+            buildIndexAlias$1(entity.ou, entity.model, entity.alias) + suffix;
+    }
+    if (entity.class !== undefined) {
+        result.indexClass =
+            buildIndexClass$1(entity.ou, entity.model, entity.class) + suffix;
+    }
+    if (entity.type !== undefined) {
+        result.indexType =
+            buildIndexType$1(entity.ou, entity.model, entity.type) + suffix;
+    }
+    if (entity.xid !== undefined) {
+        result.indexXid =
+            buildIndexXid$1(entity.ou, entity.model, entity.xid) + suffix;
+    }
+    return result;
+}
+
+// Re-export constants (no need to mock, just pass through)
+const APEX = APEX$1;
+const ARCHIVED_SUFFIX = ARCHIVED_SUFFIX$1;
+const DELETED_SUFFIX = DELETED_SUFFIX$1;
+const INDEX_ALIAS = INDEX_ALIAS$1;
+const INDEX_CLASS = INDEX_CLASS$1;
+const INDEX_OU = INDEX_OU$1;
+const INDEX_TYPE = INDEX_TYPE$1;
+const INDEX_XID = INDEX_XID$1;
+const SEPARATOR = SEPARATOR$1;
+// Key builder functions - use createMockFunction with typed implementations
+const buildIndexAlias = createMockFunction((ou, model, alias) => buildIndexAlias$1(ou, model, alias));
+const buildIndexClass = createMockFunction((ou, model, recordClass) => buildIndexClass$1(ou, model, recordClass));
+const buildIndexOu = createMockFunction((ou, model) => buildIndexOu$1(ou, model));
+const buildIndexType = createMockFunction((ou, model, type) => buildIndexType$1(ou, model, type));
+const buildIndexXid = createMockFunction((ou, model, xid) => buildIndexXid$1(ou, model, xid));
+const calculateOu = createMockFunction((parent) => calculateOu$1(parent));
+const indexEntity = createMockFunction((entity, suffix) => indexEntity$1(entity, suffix));
+// Client functions
+const initClient = createMockFunction(() => {
+    // No-op in mock
+});
+const getDocClient = createMockFunction(() => ({
+    send: createMockResolvedFunction({ Items: [] }),
+}));
+const getTableName = createMockFunction(() => "mock-table");
+const isInitialized = createMockFunction(() => true);
+const resetClient = createMockFunction(() => {
+    // No-op in mock
+});
+// Entity operations - return mock data
+const getEntity = createMockFunction(async () => null);
+const putEntity = createMockFunction(async (params) => indexEntity$1(params.entity));
+const updateEntity = createMockFunction(async (params) => ({
+    ...indexEntity$1(params.entity),
+    updatedAt: new Date().toISOString(),
+}));
+const deleteEntity = createMockFunction(async () => true);
+const archiveEntity = createMockFunction(async () => true);
+const destroyEntity = createMockFunction(async () => true);
+// Query functions - return empty results by default (use object params)
+const queryByOu = createMockFunction(async () => ({
+    items: [],
+    lastEvaluatedKey: undefined,
+}));
+const queryByAlias = createMockFunction(async () => null);
+const queryByClass = createMockFunction(async () => ({
+    items: [],
+    lastEvaluatedKey: undefined,
+}));
+const queryByType = createMockFunction(async () => ({
+    items: [],
+    lastEvaluatedKey: undefined,
+}));
+const queryByXid = createMockFunction(async () => null);
+
+var dynamodb = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    APEX: APEX,
+    ARCHIVED_SUFFIX: ARCHIVED_SUFFIX,
+    DELETED_SUFFIX: DELETED_SUFFIX,
+    INDEX_ALIAS: INDEX_ALIAS,
+    INDEX_CLASS: INDEX_CLASS,
+    INDEX_OU: INDEX_OU,
+    INDEX_TYPE: INDEX_TYPE,
+    INDEX_XID: INDEX_XID,
+    SEPARATOR: SEPARATOR,
+    archiveEntity: archiveEntity,
+    buildIndexAlias: buildIndexAlias,
+    buildIndexClass: buildIndexClass,
+    buildIndexOu: buildIndexOu,
+    buildIndexType: buildIndexType,
+    buildIndexXid: buildIndexXid,
+    calculateOu: calculateOu,
+    deleteEntity: deleteEntity,
+    destroyEntity: destroyEntity,
+    getDocClient: getDocClient,
+    getEntity: getEntity,
+    getTableName: getTableName,
+    indexEntity: indexEntity,
+    initClient: initClient,
+    isInitialized: isInitialized,
+    putEntity: putEntity,
+    queryByAlias: queryByAlias,
+    queryByClass: queryByClass,
+    queryByOu: queryByOu,
+    queryByType: queryByType,
+    queryByXid: queryByXid,
+    resetClient: resetClient,
+    updateEntity: updateEntity
+});
+
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 // Constants for mock values
 const TAG$1 = "EXPRESS";
@@ -1051,6 +1252,21 @@ var textract$1 = /*#__PURE__*/Object.freeze({
 });
 
 // Mock implementations for @jaypie/vocabulary
+// Status Type - re-export real values (no mocking needed)
+const STATUS_VALUES = [
+    "canceled",
+    "complete",
+    "error",
+    "pending",
+    "processing",
+    "queued",
+    "sending",
+];
+const StatusType = [...STATUS_VALUES];
+function isStatus(value) {
+    return (typeof value === "string" &&
+        STATUS_VALUES.includes(value));
+}
 /**
  * Mock implementation of lambdaServiceHandler
  * Mirrors the real implementation: wraps a service handler for Lambda with getMessages processing
@@ -1098,10 +1314,72 @@ const lambdaServiceHandler = createMockFunction((handlerOrConfig, options = {})
         validate: opts.validate,
     });
 });
+/**
+ * Mock implementation of createLlmTool
+ * Creates an LLM tool from a vocabulary service handler
+ */
+const createLlmTool = createMockFunction((config) => {
+    const { description, handler, message, name } = config;
+    const toolName = name ?? handler.alias ?? "tool";
+    const toolDescription = description ?? handler.description ?? "";
+    const tool = {
+        call: async (args) => {
+            return handler(args);
+        },
+        description: toolDescription,
+        name: toolName,
+        parameters: {
+            properties: {},
+            required: [],
+            type: "object",
+        },
+        type: "function",
+    };
+    if (message !== undefined) {
+        tool.message = message;
+    }
+    return { tool };
+});
+/**
+ * Mock implementation of inputToJsonSchema
+ * Converts vocabulary input definitions to JSON Schema
+ */
+const inputToJsonSchema = createMockFunction(() => ({
+    properties: {},
+    required: [],
+    type: "object",
+}));
+/**
+ * Mock implementation of registerMcpTool
+ * Registers a vocabulary service handler as an MCP tool
+ */
+const registerMcpTool = createMockFunction((config) => {
+    const { description, handler, name, server } = config;
+    const toolName = name ?? handler.alias ?? "tool";
+    const toolDescription = description ?? handler.description ?? "";
+    server.tool(toolName, toolDescription, {}, async (args) => {
+        const result = await handler(args);
+        return {
+            content: [
+                {
+                    text: result === undefined || result === null ? "" : String(result),
+                    type: "text",
+                },
+            ],
+        };
+    });
+    return { name: toolName };
+});
 
 var vocabulary = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    lambdaServiceHandler: lambdaServiceHandler
+    STATUS_VALUES: STATUS_VALUES,
+    StatusType: StatusType,
+    createLlmTool: createLlmTool,
+    inputToJsonSchema: inputToJsonSchema,
+    isStatus: isStatus,
+    lambdaServiceHandler: lambdaServiceHandler,
+    registerMcpTool: registerMcpTool
 });
 
 // Import all mocks
@@ -1113,15 +1391,19 @@ const mock = {
     ...core,
     // Datadog module
     ...datadog,
+    // DynamoDB module
+    ...dynamodb,
     // Express module
     ...express,
+    // Kit module
     ...kit,
     // Lambda module
     ...lambda,
     // LLM module
     ...llm,
+    // Logger module
     ...logger,
-    // Mongoose module (now empty)
+    // Mongoose module
     ...mongoose,
     // Textract module
     ...textract$1,
@@ -1129,5 +1411,5 @@ const mock = {
     ...vocabulary,
 };
 
-export { BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieStream, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, createExpressStream, createJaypieStream, createLambdaStream, createLogger, mock as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, expressStreamHandler, extractReasoning, forbiddenRoute, force, formatError, formatSSE, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getS3FileBuffer, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, isLocalEnv, isNodeTestEnv, isProductionEnv, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, lambdaServiceHandler, lambdaStreamHandler, loadEnvSecrets, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, streamToSSE, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid };
+export { APEX, ARCHIVED_SUFFIX, BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, DELETED_SUFFIX, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP$1 as HTTP, INDEX_ALIAS, INDEX_CLASS, INDEX_OU, INDEX_TYPE, INDEX_XID, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieStream, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, SEPARATOR, STATUS_VALUES, StatusType, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, archiveEntity, badRequestRoute, buildIndexAlias, buildIndexClass, buildIndexOu, buildIndexType, buildIndexXid, calculateOu, cloneDeep, connect, connectFromSecretEnv, cors, createExpressStream, createJaypieStream, createLambdaStream, createLlmTool, createLogger, mock as default, deleteEntity, destroyEntity, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, expressStreamHandler, extractReasoning, forbiddenRoute, force, formatError, formatSSE, getDocClient, getEntity, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getS3FileBuffer, getSecret, getSingletonMessage, getTableName, getTextractJob, goneRoute, hasDatadogEnv, indexEntity, initClient, inputToJsonSchema, isClass, isInitialized, isJaypieError, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, isLocalEnv, isNodeTestEnv, isProductionEnv, isStatus, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, lambdaServiceHandler, lambdaStreamHandler, loadEnvSecrets, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, putEntity, queryByAlias, queryByClass, queryByOu, queryByType, queryByXid, registerMcpTool, resetClient, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, streamToSSE, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, updateEntity, uuid };
 //# sourceMappingURL=index.js.map