@troykelly/openclaw-projects 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Troy Kelly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,389 @@
+# @troykelly/openclaw-projects
+
+An [OpenClaw](https://docs.openclaw.ai/) plugin that connects agents to the openclaw-projects backend for project management, memory, todos, and contacts.
+
+> **Note:** This is a third-party plugin — not part of OpenClaw itself. It provides OpenClaw agents with tools to interact with the [openclaw-projects](https://github.com/troykelly/openclaw-projects) backend service.
+
+## Features
+
+- **Memory Management**: Store, recall, and forget memories with semantic search
+- **Project Management**: List, get, and create projects
+- **Todo Management**: Manage todos with completion tracking
+- **Contact Management**: Search, get, and create contacts
+- **Auto-Recall**: Automatically inject relevant context into conversations
+- **Auto-Capture**: Capture important information from completed conversations
+- **CLI Commands**: Debug and manage the plugin from the command line
+- **Multi-User Support**: Flexible user scoping (agent, session, identity)
+
+## Installation
+
+```bash
+pnpm add @troykelly/openclaw-projects
+```
+
+## Quick Start
+
+```typescript
+import { register } from '@troykelly/openclaw-projects'
+
+const plugin = register({
+  config: {
+    apiUrl: 'https://your-backend.example.com',
+    apiKey: process.env.OPENCLAW_API_KEY,
+  },
+})
+
+// Use tools
+const result = await plugin.tools.memoryRecall.execute({
+  query: 'user preferences',
+})
+```
+
+## Configuration
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiUrl` | string | **required** | Backend API URL |
+| `apiKey` | string | **required** | API authentication key |
+| `autoRecall` | boolean | `true` | Enable auto-recall hook |
+| `autoCapture` | boolean | `true` | Enable auto-capture hook |
+| `userScoping` | string | `'agent'` | User scoping mode |
+| `maxRecallMemories` | number | `5` | Max memories to return |
+| `minRecallScore` | number | `0.7` | Minimum similarity score |
+| `timeout` | number | `30000` | API timeout (ms) |
+| `maxRetries` | number | `3` | Max retry attempts |
+| `debug` | boolean | `false` | Enable debug logging |
+
+### User Scoping Modes
+
+| Mode | Description | Use Case |
+|------|-------------|----------|
+| `agent` | Scope by agent ID | Single user per agent |
+| `session` | Scope by session key | Maximum isolation |
+| `identity` | Scope by canonical identity | Shared identity across agents |
+
+### Environment Variables
+
+```bash
+OPENCLAW_API_URL=https://your-backend.example.com
+OPENCLAW_API_KEY=your-api-key
+```
+
+## Tools
+
+### Memory Tools
+
+#### `memory_recall`
+Search memories semantically.
+
+```typescript
+const result = await plugin.tools.memoryRecall.execute({
+  query: 'user preferences for notifications',
+  limit: 10,           // optional, default: 5
+  category: 'preference', // optional filter
+})
+```
+
+#### `memory_store`
+Save information to long-term memory.
+
+```typescript
+const result = await plugin.tools.memoryStore.execute({
+  text: 'User prefers dark mode',
+  category: 'preference', // preference, fact, decision, context, other
+  importance: 0.8,        // optional, 0-1
+})
+```
+
+#### `memory_forget`
+Delete memories (GDPR data portability).
+
+```typescript
+// By ID
+const result = await plugin.tools.memoryForget.execute({
+  memoryId: '123e4567-e89b-12d3-a456-426614174000',
+})
+
+// By query (bulk delete)
+const result = await plugin.tools.memoryForget.execute({
+  query: 'outdated preferences',
+  confirm: true, // required for bulk delete
+})
+```
+
+### Project Tools
+
+#### `project_list`
+List projects with optional filtering.
+
+```typescript
+const result = await plugin.tools.projectList.execute({
+  status: 'active', // optional: active, completed, archived, on_hold
+  limit: 20,        // optional
+})
+```
+
+#### `project_get`
+Get a specific project by ID.
+
+```typescript
+const result = await plugin.tools.projectGet.execute({
+  id: '123e4567-e89b-12d3-a456-426614174000',
+})
+```
+
+#### `project_create`
+Create a new project.
+
+```typescript
+const result = await plugin.tools.projectCreate.execute({
+  name: 'Home Renovation',
+  description: 'Kitchen remodel project', // optional
+  status: 'active', // optional
+})
+```
+
+### Todo Tools
+
+#### `todo_list`
+List todos with optional filtering.
+
+```typescript
+const result = await plugin.tools.todoList.execute({
+  projectId: '123e4567-e89b-12d3-a456-426614174000', // optional
+  completed: false, // optional
+  limit: 50,        // optional
+})
+```
+
+#### `todo_create`
+Create a new todo.
+
+```typescript
+const result = await plugin.tools.todoCreate.execute({
+  title: 'Buy groceries',
+  projectId: '123e4567-e89b-12d3-a456-426614174000', // optional
+  dueDate: '2024-01-15', // optional, ISO 8601
+})
+```
+
+#### `todo_complete`
+Mark a todo as complete.
+
+```typescript
+const result = await plugin.tools.todoComplete.execute({
+  id: '123e4567-e89b-12d3-a456-426614174000',
+})
+```
+
+### Contact Tools
+
+#### `contact_search`
+Search contacts.
+
+```typescript
+const result = await plugin.tools.contactSearch.execute({
+  query: 'Alice',
+  limit: 10, // optional
+})
+```
+
+#### `contact_get`
+Get a specific contact by ID.
+
+```typescript
+const result = await plugin.tools.contactGet.execute({
+  id: '123e4567-e89b-12d3-a456-426614174000',
+})
+```
+
+#### `contact_create`
+Create a new contact.
+
+```typescript
+const result = await plugin.tools.contactCreate.execute({
+  name: 'Alice Smith',
+  email: 'alice@example.com', // optional
+  phone: '+1-555-123-4567',   // optional
+})
+```
+
+## Lifecycle Hooks
+
+### `beforeAgentStart` (Auto-Recall)
+
+Automatically fetches relevant context before the agent processes a prompt.
+
+```typescript
+const context = await plugin.hooks.beforeAgentStart({
+  prompt: 'What are my notification preferences?',
+})
+
+if (context) {
+  // Prepend context.prependContext to the conversation
+}
+```
+
+### `agentEnd` (Auto-Capture)
+
+Automatically captures important information after a conversation ends.
+
+```typescript
+await plugin.hooks.agentEnd({
+  messages: [
+    { role: 'user', content: 'Remember I prefer email notifications' },
+    { role: 'assistant', content: 'Noted! I will remember your preference.' },
+  ],
+})
+```
+
+## CLI Commands
+
+The plugin provides CLI command handlers that can be registered with OpenClaw:
+
+### `status`
+Check API connectivity.
+
+```typescript
+const result = await plugin.cli.status()
+// { success: true, message: 'API is healthy (latency: 50ms)', data: { ... } }
+```
+
+### `users`
+Show user scoping configuration.
+
+```typescript
+const result = await plugin.cli.users()
+// { success: true, data: { scopingMode: 'agent', description: '...', currentUserId: '...' } }
+```
+
+### `recall`
+Search memories from CLI.
+
+```typescript
+const result = await plugin.cli.recall({ query: 'preferences', limit: 10 })
+// { success: true, data: { memories: [...], query: '...', limit: 10 } }
+```
+
+### `stats`
+Show memory statistics.
+
+```typescript
+const result = await plugin.cli.stats()
+// { success: true, data: { totalMemories: 42, byCategory: { ... } } }
+```
+
+### `export`
+Export all memories (GDPR data portability).
+
+```typescript
+const result = await plugin.cli.export({ output: '/path/to/export.json' })
+// { success: true, data: { memories: [...], exportedAt: '...', userId: '...' } }
+```
+
+## Health Check
+
+```typescript
+const health = await plugin.healthCheck()
+if (!health.healthy) {
+  console.error('Plugin unhealthy:', health.error)
+}
+```
+
+## Security
+
+### API Key Management
+
+- Store API keys in environment variables, never in code
+- Use secrets management in production (Vault, AWS Secrets Manager, etc.)
+- Rotate keys regularly
+
+### Data Isolation
+
+- All data is scoped to the configured user scope
+- Cross-user access is prevented at the API level
+- Audit logs track all data access
+
+### Sensitive Content
+
+- The plugin filters sensitive content (API keys, passwords, credit cards)
+- PII is not logged at info level
+- Error messages are sanitized to prevent information leakage
+
+### HTTPS
+
+- Use HTTPS in production
+- HTTP is only recommended for local development
+
+## Error Handling
+
+All tool executions return a result object:
+
+```typescript
+interface ToolResult {
+  success: boolean
+  content?: string   // Human-readable response
+  data?: unknown     // Structured data
+  error?: string     // Error message if success is false
+}
+```
+
+## Troubleshooting
+
+### Connection Issues
+
+```typescript
+// Check health
+const health = await plugin.healthCheck()
+console.log('Healthy:', health.healthy, 'Error:', health.error)
+
+// Check status via CLI
+const status = await plugin.cli.status()
+console.log('Status:', status.message, 'Latency:', status.data?.latencyMs)
+```
+
+### No Memories Found
+
+- Verify the user scoping mode matches your setup
+- Check that memories were stored for the same user scope
+- Try broadening your search query
+
+### API Errors
+
+- Verify API URL is correct and accessible
+- Check API key is valid
+- Review network connectivity
+
+## API Reference
+
+Full TypeScript types are exported:
+
+```typescript
+import type {
+  PluginConfig,
+  PluginInstance,
+  MemoryRecallParams,
+  MemoryStoreParams,
+  ProjectListParams,
+  TodoCreateParams,
+  ContactSearchParams,
+  // ... and more
+} from '@troykelly/openclaw-projects'
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Write tests for new functionality
+4. Submit a pull request
+
+## License
+
+MIT
+
+## Links
+
+- [OpenClaw Documentation](https://docs.openclaw.ai/)
+- [openclaw-projects Backend](https://github.com/troykelly/openclaw-projects)
+- [Report Issues](https://github.com/troykelly/openclaw-projects/issues)

package/dist/api-client.d.ts

@@ -0,0 +1,81 @@
+/**
+ * HTTP API client for openclaw-projects backend.
+ * Handles authentication, request/response formatting, error handling,
+ * retry logic with exponential backoff, and timeout handling.
+ */
+import type { PluginConfig } from './config.js';
+import { type Logger } from './logger.js';
+/** API error response */
+export interface ApiError {
+    status: number;
+    message: string;
+    code?: string;
+    details?: Record<string, unknown>;
+    /** Retry-After value in seconds (for 429 responses) */
+    retryAfter?: number;
+}
+/** API response wrapper */
+export type ApiResponse<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ApiError;
+};
+/** Request options */
+export interface RequestOptions {
+    /** User ID for scoping */
+    userId?: string;
+    /** Custom timeout (overrides config) */
+    timeout?: number;
+    /** Mark request as coming from an agent (adds X-OpenClaw-Agent header) */
+    isAgent?: boolean;
+}
+/** API client options */
+export interface ApiClientOptions {
+    config: PluginConfig;
+    logger?: Logger;
+}
+/** Health check result */
+export interface HealthCheckResult {
+    healthy: boolean;
+    latencyMs: number;
+}
+/**
+ * HTTP API client for the openclaw-projects backend.
+ */
+export declare class ApiClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly logger;
+    private readonly timeout;
+    private readonly maxRetries;
+    constructor(options: ApiClientOptions);
+    /**
+     * Makes an authenticated request to the API with retry logic.
+     */
+    private request;
+    /**
+     * Execute a single request with timeout handling.
+     */
+    private executeRequest;
+    /** GET request */
+    get<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    /** POST request */
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResponse<T>>;
+    /** PUT request */
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResponse<T>>;
+    /** PATCH request */
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResponse<T>>;
+    /** DELETE request */
+    delete<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    /**
+     * Health check endpoint.
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+}
+/**
+ * Creates a new API client instance.
+ */
+export declare function createApiClient(options: ApiClientOptions): ApiClient;
+//# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../src/api-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,aAAa,CAAA;AAEvD,yBAAyB;AACzB,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,2BAA2B;AAC3B,MAAM,MAAM,WAAW,CAAC,CAAC,IACrB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAC1B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEvC,sBAAsB;AACtB,MAAM,WAAW,cAAc;IAC7B,0BAA0B;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,yBAAyB;AACzB,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,0BAA0B;AAC1B,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CAClB;AA+CD;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAEvB,OAAO,EAAE,gBAAgB;IASrC;;OAEG;YACW,OAAO;IAmErB;;OAEG;YACW,cAAc;IAiE5B,kBAAkB;IACZ,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAI7E,mBAAmB;IACb,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAI9F,kBAAkB;IACZ,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAI7F,oBAAoB;IACd,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAI/F,qBAAqB;IACf,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAIhF;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;CAYhD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAEpE"}

package/dist/api-client.js

@@ -0,0 +1,216 @@
+/**
+ * HTTP API client for openclaw-projects backend.
+ * Handles authentication, request/response formatting, error handling,
+ * retry logic with exponential backoff, and timeout handling.
+ */
+import { createLogger } from './logger.js';
+/**
+ * Sleep for a specified duration.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Generate a unique request ID for tracing.
+ */
+function generateRequestId() {
+    return crypto.randomUUID();
+}
+/**
+ * Calculate retry delay with exponential backoff and jitter.
+ */
+function calculateRetryDelay(attempt, baseDelay = 1000, maxDelay = 10000) {
+    // Exponential backoff: 1s, 2s, 4s, 8s...
+    const exponentialDelay = baseDelay * Math.pow(2, attempt);
+    // Add jitter (±25%) to prevent thundering herd
+    const jitter = exponentialDelay * (0.75 + Math.random() * 0.5);
+    return Math.min(jitter, maxDelay);
+}
+/**
+ * Check if an error is retryable.
+ */
+function isRetryableStatus(status) {
+    // Retry on 5xx server errors and network errors (status 0)
+    return status === 0 || (status >= 500 && status < 600);
+}
+/**
+ * Map HTTP status to error code.
+ */
+function getErrorCode(status) {
+    if (status === 401 || status === 403)
+        return 'AUTH_ERROR';
+    if (status === 404)
+        return 'NOT_FOUND';
+    if (status === 429)
+        return 'RATE_LIMITED';
+    if (status >= 500)
+        return 'SERVER_ERROR';
+    if (status === 0)
+        return 'NETWORK_ERROR';
+    return 'CLIENT_ERROR';
+}
+/**
+ * HTTP API client for the openclaw-projects backend.
+ */
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    logger;
+    timeout;
+    maxRetries;
+    constructor(options) {
+        // Ensure URL doesn't have trailing slash
+        this.baseUrl = options.config.apiUrl.replace(/\/$/, '');
+        this.apiKey = options.config.apiKey;
+        this.logger = options.logger ?? createLogger('api-client');
+        this.timeout = options.config.timeout;
+        this.maxRetries = options.config.maxRetries;
+    }
+    /**
+     * Makes an authenticated request to the API with retry logic.
+     */
+    async request(method, path, body, options) {
+        const url = `${this.baseUrl}${path}`;
+        const requestId = generateRequestId();
+        const timeout = options?.timeout ?? this.timeout;
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (attempt > 0) {
+                const delay = calculateRetryDelay(attempt - 1);
+                this.logger.debug(`Retrying request (attempt ${attempt + 1}/${this.maxRetries + 1})`, {
+                    path,
+                    delay,
+                });
+                await sleep(delay);
+            }
+            try {
+                const result = await this.executeRequest(method, url, body, requestId, options, timeout);
+                if (result.success) {
+                    return result;
+                }
+                lastError = result.error;
+                // Don't retry 4xx errors (except we could retry 429, but typically you'd wait for Retry-After)
+                if (!isRetryableStatus(result.error.status)) {
+                    return result;
+                }
+            }
+            catch (error) {
+                // Handle timeout or network errors
+                lastError = {
+                    status: 0,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    code: error instanceof Error && error.name === 'AbortError' ? 'TIMEOUT' : 'NETWORK_ERROR',
+                };
+                this.logger.error('API request failed', {
+                    method,
+                    path,
+                    requestId,
+                    error: lastError.message,
+                });
+                // Network errors are retryable
+                if (attempt < this.maxRetries) {
+                    continue;
+                }
+            }
+        }
+        return {
+            success: false,
+            error: lastError ?? {
+                status: 0,
+                message: 'Request failed after retries',
+                code: 'NETWORK_ERROR',
+            },
+        };
+    }
+    /**
+     * Execute a single request with timeout handling.
+     */
+    async executeRequest(method, url, body, requestId, options, timeout) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const headers = {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                'X-Request-Id': requestId,
+            };
+            if (options?.userId) {
+                headers['X-Agent-Id'] = options.userId;
+            }
+            // Mark request as coming from an agent for privacy filtering
+            if (options?.isAgent) {
+                headers['X-OpenClaw-Agent'] = options.userId || 'plugin-agent';
+            }
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorBody = await response.json().catch(() => ({}));
+                const retryAfter = response.headers.get('Retry-After');
+                return {
+                    success: false,
+                    error: {
+                        status: response.status,
+                        message: errorBody.message || response.statusText,
+                        code: getErrorCode(response.status),
+                        details: errorBody.details,
+                        retryAfter: retryAfter ? parseInt(retryAfter, 10) : undefined,
+                    },
+                };
+            }
+            // Handle no content
+            if (response.status === 204) {
+                return { success: true, data: undefined };
+            }
+            const data = (await response.json());
+            return { success: true, data };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+    /** GET request */
+    async get(path, options) {
+        return this.request('GET', path, undefined, options);
+    }
+    /** POST request */
+    async post(path, body, options) {
+        return this.request('POST', path, body, options);
+    }
+    /** PUT request */
+    async put(path, body, options) {
+        return this.request('PUT', path, body, options);
+    }
+    /** PATCH request */
+    async patch(path, body, options) {
+        return this.request('PATCH', path, body, options);
+    }
+    /** DELETE request */
+    async delete(path, options) {
+        return this.request('DELETE', path, undefined, options);
+    }
+    /**
+     * Health check endpoint.
+     */
+    async healthCheck() {
+        const start = Date.now();
+        const result = await this.get('/api/health');
+        const latencyMs = Date.now() - start;
+        return {
+            healthy: result.success,
+            latencyMs,
+        };
+    }
+}
+/**
+ * Creates a new API client instance.
+ */
+export function createApiClient(options) {
+    return new ApiClient(options);
+}
+//# sourceMappingURL=api-client.js.map