@mondaydotcomorg/atp-runtime 0.17.14

package/README.md

@@ -0,0 +1,389 @@
+# @mondaydotcomorg/atp-runtime
+
+Runtime APIs available to agents during code execution (LLM, embedding, approval, cache, logging, progress).
+
+## Overview
+
+This package provides the `atp.*` runtime APIs that agents can use when executing code on ATP servers. These APIs enable LLM calls, embeddings, approvals, caching, logging, and progress reporting.
+
+## Installation
+
+```bash
+npm install @mondaydotcomorg/atp-runtime
+```
+
+## Architecture
+
+```mermaid
+graph TB
+    Runtime[Runtime Registry] --> LLM[atp.llm.*]
+    Runtime --> Embedding[atp.embedding.*]
+    Runtime --> Approval[atp.approval.*]
+    Runtime --> Cache[atp.cache.*]
+    Runtime --> Log[atp.log.*]
+    Runtime --> Progress[atp.progress.*]
+
+    LLM --> Pause[Pause Mechanism]
+    Approval --> Pause
+    Embedding --> Pause
+
+    Cache --> Provider[CacheProvider]
+    Log --> Logger[Logger]
+```
+
+## Runtime APIs
+
+### atp.llm.\*
+
+LLM operations that pause execution and route to client-provided LLM.
+
+```typescript
+// Simple LLM call
+const response = await atp.llm.call({
+	prompt: 'What is the capital of France?',
+	model: 'gpt-4',
+	temperature: 0.7,
+	systemPrompt: 'You are a helpful assistant',
+});
+
+// Extract structured data
+const user = await atp.llm.extract({
+	prompt: 'Extract user info: John Doe, john@example.com',
+	schema: {
+		type: 'object',
+		properties: {
+			name: { type: 'string' },
+			email: { type: 'string' },
+		},
+		required: ['name', 'email'],
+	},
+});
+// Returns: { name: 'John Doe', email: 'john@example.com' }
+
+// Classify text
+const category = await atp.llm.classify({
+	text: 'This product is amazing!',
+	categories: ['positive', 'negative', 'neutral'],
+});
+// Returns: 'positive'
+```
+
+### atp.embedding.\*
+
+Embedding operations for semantic search.
+
+```typescript
+// Generate and store embedding
+const embeddingId = await atp.embedding.embed('Important document content');
+
+// Search by similarity
+const results = await atp.embedding.search('find similar documents', {
+	topK: 5,
+	minSimilarity: 0.7,
+});
+// Returns: [{ id: string, text: string, similarity: number }, ...]
+
+// Calculate similarity between two embeddings
+const similarity = await atp.embedding.similarity(vec1, vec2);
+
+// Get all embeddings
+const all = await atp.embedding.getAll();
+
+// Count embeddings
+const count = await atp.embedding.count();
+
+// Clear all embeddings
+await atp.embedding.clear();
+```
+
+### atp.approval.\*
+
+Request human approval during execution.
+
+```typescript
+// Request approval
+const result = await atp.approval.request('Delete all user data?', {
+	critical: true,
+	affectedUsers: 150,
+});
+
+if (result.approved) {
+	// User approved, proceed
+	await deleteData();
+} else {
+	// User denied
+	return { cancelled: true, reason: result.response };
+}
+```
+
+### atp.cache.\*
+
+Cache data with TTL support.
+
+```typescript
+// Set cache value
+await atp.cache.set('user:123', userData, 3600); // TTL in seconds
+
+// Get cache value
+const cached = await atp.cache.get('user:123');
+
+// Check if key exists
+const exists = await atp.cache.has('user:123');
+
+// Delete cache key
+await atp.cache.delete('user:123');
+```
+
+### atp.log.\*
+
+Structured logging with multiple levels.
+
+```typescript
+// Log levels
+atp.log.trace('Detailed trace', { requestId: '123' });
+atp.log.debug('Debug info', { state });
+atp.log.info('User logged in', { userId: '456' });
+atp.log.warn('Deprecated API used', { api: 'v1' });
+atp.log.error('Failed to connect', { error, retries: 3 });
+atp.log.fatal('System crash', { reason });
+
+// Logs include context automatically:
+// - executionId
+// - timestamp
+// - level
+// - message
+// - metadata
+```
+
+### atp.progress.\*
+
+Report progress for long-running operations.
+
+```typescript
+// Report progress
+atp.progress.report({
+	current: 5,
+	total: 10,
+	message: 'Processing items...',
+	metadata: {
+		itemsPerSecond: 2.5,
+	},
+});
+
+// Progress updates are sent to client in real-time
+```
+
+## Usage in Agent Code
+
+When agents execute code on ATP server, these APIs are automatically available:
+
+```typescript
+// Agent-generated code
+const items = ['apple', 'banana', 'cherry', 'date', 'elderberry'];
+const results = [];
+
+atp.log.info('Starting fruit analysis', { count: items.length });
+
+for (let i = 0; i < items.length; i++) {
+	atp.progress.report({
+		current: i + 1,
+		total: items.length,
+		message: `Processing ${items[i]}`,
+	});
+
+	// Call LLM for each item
+	const analysis = await atp.llm.call({
+		prompt: `Analyze this fruit: ${items[i]}`,
+	});
+
+	// Store embedding for semantic search
+	const embeddingId = await atp.embedding.embed(analysis);
+
+	// Cache result
+	await atp.cache.set(`analysis:${items[i]}`, analysis, 3600);
+
+	results.push({ fruit: items[i], analysis, embeddingId });
+}
+
+// Request approval before returning
+const approval = await atp.approval.request('Analysis complete. Proceed with storage?', {
+	resultCount: results.length,
+});
+
+if (!approval.approved) {
+	atp.log.warn('User rejected storage');
+	return { cancelled: true };
+}
+
+atp.log.info('Analysis complete', { results: results.length });
+return results;
+```
+
+## Pause/Resume Mechanism
+
+```mermaid
+sequenceDiagram
+    participant Code
+    participant Runtime
+    participant Server
+    participant Client
+
+    Code->>Runtime: atp.llm.call()
+    Runtime->>Server: Pause execution
+    Server->>Client: Request LLM callback
+    Client->>LLM: Call LLM API
+    LLM-->>Client: Response
+    Client->>Server: Resume with result
+    Server->>Runtime: Restore state
+    Runtime-->>Code: Return LLM result
+```
+
+## Initialization
+
+Runtime APIs are automatically initialized by the ATP server. For standalone use:
+
+```typescript
+import {
+	setClientLLMCallback,
+	initializeCache,
+	initializeApproval,
+	initializeVectorStore,
+	initializeLogger,
+} from '@mondaydotcomorg/atp-runtime';
+
+// Setup LLM callback
+setClientLLMCallback({
+	call: async (prompt, options) => {
+		// Implement LLM call
+	},
+});
+
+// Setup cache
+initializeCache(cacheProvider);
+
+// Setup approval
+initializeApproval({
+	request: async (message, context) => {
+		// Implement approval
+	},
+});
+
+// Setup embeddings
+initializeVectorStore(embeddingHandler);
+
+// Setup logger
+initializeLogger({
+	level: 'info',
+	pretty: true,
+});
+```
+
+## Replay Mode
+
+For deterministic execution and testing:
+
+```typescript
+import { setReplayMode } from '@mondaydotcomorg/atp-runtime';
+
+// Enable replay mode with cached results
+setReplayMode(true);
+
+// LLM calls will return cached results instead of pausing
+const result = await atp.llm.call({ prompt: 'Hello' });
+// Returns cached response from previous execution
+```
+
+## Type Definitions
+
+The runtime exports TypeScript definitions for all APIs:
+
+```typescript
+import type {
+	LLMCallOptions,
+	LLMExtractOptions,
+	LLMClassifyOptions,
+	EmbeddingSearchOptions,
+	EmbeddingSearchResult,
+	ApprovalRequest,
+	ApprovalResponse,
+	ProgressUpdate,
+} from '@mondaydotcomorg/atp-runtime';
+```
+
+## Metadata Generation
+
+Runtime APIs are decorated with metadata for automatic discovery:
+
+```typescript
+import { GENERATED_METADATA } from '@mondaydotcomorg/atp-runtime';
+
+// Metadata includes:
+// - API names and descriptions
+// - Method signatures
+// - Parameter types
+// - Return types
+
+console.log(GENERATED_METADATA);
+// {
+//   apis: [
+//     {
+//       name: 'llm',
+//       description: 'LLM API - Large Language Model calls...',
+//       methods: [...]
+//     },
+//     ...
+//   ]
+// }
+```
+
+## Error Handling
+
+```typescript
+import { PauseExecutionError, isPauseError } from '@mondaydotcomorg/atp-runtime';
+
+try {
+	const result = await atp.llm.call({ prompt: 'Hello' });
+} catch (error) {
+	if (isPauseError(error)) {
+		// Execution paused for callback
+		console.log('Paused for:', error.callbackType);
+	} else {
+		// Other error
+		throw error;
+	}
+}
+```
+
+## Advanced Features
+
+### Sequence Numbers
+
+Track call order for replay:
+
+```typescript
+import { getCallSequenceNumber } from '@mondaydotcomorg/atp-runtime';
+
+const seq = getCallSequenceNumber();
+console.log('Current sequence:', seq);
+```
+
+### Execution Context
+
+Run code in specific execution context:
+
+```typescript
+import { runInExecutionContext } from '@mondaydotcomorg/atp-runtime';
+
+runInExecutionContext('exec-123', () => {
+	// All atp.* calls use this execution ID
+	const result = await atp.llm.call({ prompt: 'Hello' });
+});
+```
+
+## TypeScript Support
+
+Full TypeScript definitions with strict typing.
+
+## License
+
+MIT

package/dist/approval/handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ */
+import type { ApprovalRequest, ApprovalResponse } from './types';
+/**
+ * Initialize the approval system with a custom handler
+ */
+export declare function initializeApproval(handler: (request: ApprovalRequest) => Promise<ApprovalResponse>): void;
+/**
+ * Get the current approval handler
+ */
+export declare function getApprovalHandler(): ((request: ApprovalRequest) => Promise<ApprovalResponse>) | null;
+//# sourceMappingURL=handler.d.ts.map

package/dist/approval/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/approval/handler.ts"],"names":[],"mappings":"AAAA;GACG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAOjE;;GAEG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAAC,GAC9D,IAAI,CAEN;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAC/B,CAAC,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC,GACzD,IAAI,CAEN"}

package/dist/approval/handler.js

@@ -0,0 +1,17 @@
+/**
+ * Global approval handler that must be set by the execution context
+ */
+let approvalHandler = null;
+/**
+ * Initialize the approval system with a custom handler
+ */
+export function initializeApproval(handler) {
+    approvalHandler = handler;
+}
+/**
+ * Get the current approval handler
+ */
+export function getApprovalHandler() {
+    return approvalHandler;
+}
+//# sourceMappingURL=handler.js.map

package/dist/approval/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/approval/handler.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,IAAI,eAAe,GAAqE,IAAI,CAAC;AAE7F;;GAEG;AACH,MAAM,UAAU,kBAAkB,CACjC,OAAgE;IAEhE,eAAe,GAAG,OAAO,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAGjC,OAAO,eAAe,CAAC;AACxB,CAAC"}

package/dist/approval/index.d.ts

@@ -0,0 +1,17 @@
+import type { ApprovalResponse } from './types';
+export type { ApprovalRequest, ApprovalResponse, ApprovalSchema } from './types';
+export { initializeApproval } from './handler.js';
+/**
+ * Approval Runtime API
+ *
+ * Allows agents to request explicit human approval before proceeding with sensitive operations.
+ * This integrates with MCP's elicitation feature to request structured input from users.
+ */
+declare class ApprovalAPI {
+    /**
+     * Request approval from a human
+     */
+    request(message: string, context?: Record<string, unknown>): Promise<ApprovalResponse>;
+}
+export declare const approval: ApprovalAPI;
+//# sourceMappingURL=index.d.ts.map

package/dist/approval/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/approval/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGjE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD;;;;;GAKG;AACH,cACM,WAAW;IAChB;;OAEG;IAWG,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAsD5F;AAED,eAAO,MAAM,QAAQ,aAAoB,CAAC"}

package/dist/approval/index.js

@@ -0,0 +1,94 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * Approval API - Clean refactored version with decorators and extracted modules
+ *
+ * Benefits:
+ * - No duplication between implementation and metadata
+ * - Types auto-detected from TypeScript signatures
+ * - Clean separation of concerns (handler, API)
+ */
+import { RuntimeAPI, RuntimeMethod } from '../metadata/decorators.js';
+import { getApprovalHandler } from './handler.js';
+import { pauseForCallback, CallbackType, ApprovalOperation } from '../pause/index.js';
+import { nextSequenceNumber, getCachedResult, shouldPauseForClient } from '../llm/replay.js';
+export { initializeApproval } from './handler.js';
+/**
+ * Approval Runtime API
+ *
+ * Allows agents to request explicit human approval before proceeding with sensitive operations.
+ * This integrates with MCP's elicitation feature to request structured input from users.
+ */
+let ApprovalAPI = class ApprovalAPI {
+    /**
+     * Request approval from a human
+     */
+    async request(message, context) {
+        const currentSequence = nextSequenceNumber();
+        const cachedResult = getCachedResult(currentSequence);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        if (shouldPauseForClient()) {
+            pauseForCallback(CallbackType.APPROVAL, ApprovalOperation.REQUEST, {
+                message,
+                context,
+                sequenceNumber: currentSequence,
+            });
+        }
+        const handler = getApprovalHandler();
+        if (!handler) {
+            throw new Error('Approval handler not configured. Human approval is required but no handler is set.');
+        }
+        const approvalRequest = {
+            message,
+            context,
+            timeout: 300000,
+        };
+        let timeoutId = null;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error('Approval request timed out')), approvalRequest.timeout);
+        });
+        try {
+            const response = await Promise.race([handler(approvalRequest), timeoutPromise]);
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            return {
+                ...response,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            throw new Error(`Approval request failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+};
+__decorate([
+    RuntimeMethod('Request approval from a human', {
+        message: {
+            description: 'The message to display to the user',
+        },
+        context: {
+            description: 'Optional context information about what needs approval',
+            optional: true,
+            type: 'Record<string, unknown>',
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], ApprovalAPI.prototype, "request", null);
+ApprovalAPI = __decorate([
+    RuntimeAPI('approval', 'Approval API - Request explicit human approval for sensitive operations')
+], ApprovalAPI);
+export const approval = new ApprovalAPI();
+//# sourceMappingURL=index.js.map

package/dist/approval/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/approval/index.ts"],"names":[],"mappings":";;;;;;;;;AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtF,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAG7F,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD;;;;;GAKG;AAEH,IAAM,WAAW,GAAjB,MAAM,WAAW;IAChB;;OAEG;IAWG,AAAN,KAAK,CAAC,OAAO,CAAC,OAAe,EAAE,OAAiC;QAC/D,MAAM,eAAe,GAAG,kBAAkB,EAAE,CAAC;QAE7C,MAAM,YAAY,GAAG,eAAe,CAAC,eAAe,CAAC,CAAC;QACtD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAChC,OAAO,YAAgC,CAAC;QACzC,CAAC;QAED,IAAI,oBAAoB,EAAE,EAAE,CAAC;YAC5B,gBAAgB,CAAC,YAAY,CAAC,QAAQ,EAAE,iBAAiB,CAAC,OAAO,EAAE;gBAClE,OAAO;gBACP,OAAO;gBACP,cAAc,EAAE,eAAe;aAC/B,CAAC,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,kBAAkB,EAAE,CAAC;QAErC,IAAI,CAAC,OAAO,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CACd,oFAAoF,CACpF,CAAC;QACH,CAAC;QAED,MAAM,eAAe,GAAoB;YACxC,OAAO;YACP,OAAO;YACP,OAAO,EAAE,MAAM;SACf,CAAC;QAEF,IAAI,SAAS,GAA0B,IAAI,CAAC;QAC5C,MAAM,cAAc,GAAG,IAAI,OAAO,CAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YAClE,SAAS,GAAG,UAAU,CACrB,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,EACrD,eAAe,CAAC,OAAQ,CACxB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC;YACJ,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;YAEhF,IAAI,SAAS;gBAAE,YAAY,CAAC,SAAS,CAAC,CAAC;YAEvC,OAAO;gBACN,GAAG,QAAQ;gBACX,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;aACrB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,IAAI,SAAS;gBAAE,YAAY,CAAC,SAAS,CAAC,CAAC;YACvC,MAAM,IAAI,KAAK,CACd,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,EAAE,CACtF,CAAC;QACH,CAAC;IACF,CAAC;CACD,CAAA;AAtDM;IAVL,aAAa,CAAC,+BAA+B,EAAE;QAC/C,OAAO,EAAE;YACR,WAAW,EAAE,oCAAoC;SACjD;QACD,OAAO,EAAE;YACR,WAAW,EAAE,wDAAwD;YACrE,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,yBAAyB;SAC/B;KACD,CAAC;;;;0CAsDD;AAnEI,WAAW;IADhB,UAAU,CAAC,UAAU,EAAE,yEAAyE,CAAC;GAC5F,WAAW,CAoEhB;AAED,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAC"}

package/dist/approval/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Human Approval API Types
+ */
+export interface ApprovalRequest {
+    message: string;
+    context?: Record<string, unknown>;
+    timeout?: number;
+    schema?: ApprovalSchema;
+}
+export interface ApprovalSchema {
+    type: 'boolean' | 'text' | 'choice' | 'structured';
+    choices?: string[];
+    structuredSchema?: Record<string, unknown>;
+    required?: boolean;
+}
+export interface ApprovalResponse<T = unknown> {
+    approved: boolean;
+    response?: T;
+    timestamp: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/approval/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/approval/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,CAAC;IACnD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO;IAC5C,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CAClB"}

package/dist/approval/types.js

@@ -0,0 +1,5 @@
+/**
+ * Human Approval API Types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/approval/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/approval/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/cache/backends.d.ts

@@ -0,0 +1,39 @@
+import type { CacheBackend, CacheConfig } from './types';
+/**
+ * In-memory cache implementation using node-cache
+ */
+export declare class MemoryCacheBackend implements CacheBackend {
+    private cache;
+    constructor(config?: {
+        maxKeys?: number;
+        defaultTTL?: number;
+        checkPeriod?: number;
+    });
+    get<T>(key: string): Promise<T | null>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+/**
+ * Redis cache implementation (lazy-loaded only if configured)
+ */
+export declare class RedisCacheBackend implements CacheBackend {
+    private client;
+    private connected;
+    constructor(config: NonNullable<CacheConfig['redis']>);
+    get<T>(key: string): Promise<T | null>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+/**
+ * Initializes the cache system with configuration
+ */
+export declare function initializeCache(config: CacheConfig): void;
+/**
+ * Get the current cache backend
+ */
+export declare function getCacheBackend(): CacheBackend;
+//# sourceMappingURL=backends.d.ts.map

package/dist/cache/backends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backends.d.ts","sourceRoot":"","sources":["../../src/cache/backends.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEzD;;GAEG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACtD,OAAO,CAAC,KAAK,CAAY;gBAEb,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE;IAS9E,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAKtC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ7D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B;AAED;;GAEG;AACH,qBAAa,iBAAkB,YAAW,YAAY;IACrD,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAAkB;gBAEvB,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IA+B/C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAkBtC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBlC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAc5B;AAID;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAUzD;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAE9C"}