@aerostack/core 0.7.6 → 0.7.7

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { Product, Cart, AerostackRPC, CollectionItem, StoreConfig, ProductVariant, Category } from './types';
+import { Product, Cart, AerostackRPC, CollectionItem, StoreConfig, ProductVariant, Category, CacheListResult, CacheSetEntry, StorageListResult, JobRecord } from './types';
 /** @deprecated Use AerostackConfig instead. */
 export interface AerocallConfig {
     baseUrl?: string;
@@ -15,9 +15,21 @@ export declare class AerocallClient implements AerostackRPC {
     private jwt?;
     private projectId?;
     constructor(config: AerocallConfig);
+    private getHeaders;
     private request;
     get db(): {
         query: <T = any>(sql: string, params?: any[]) => Promise<T[]>;
+        batch: (queries: Array<{
+            sql: string;
+            params?: any[];
+        }>) => Promise<{
+            results: Array<{
+                results: any[];
+                success: boolean;
+                error?: string;
+            }>;
+            success: boolean;
+        }>;
     };
     get cache(): {
         get: <T = any>(key: string) => Promise<{
@@ -30,12 +42,62 @@ export declare class AerocallClient implements AerostackRPC {
         delete: (key: string) => Promise<{
             success: boolean;
         }>;
+        list: (prefix?: string, options?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<CacheListResult>;
+        keys: (prefix?: string) => Promise<string[]>;
+        getMany: <T = any>(keys: string[]) => Promise<{
+            key: string;
+            value: T | null;
+            exists: boolean;
+        }[]>;
+        setMany: (entries: CacheSetEntry[]) => Promise<{
+            success: boolean;
+            count: number;
+        }>;
+        deleteMany: (keys: string[]) => Promise<{
+            success: boolean;
+            count: number;
+            deleted: number;
+        }>;
+        flush: (prefix?: string) => Promise<{
+            success: boolean;
+            deleted: number;
+        }>;
+        expire: (key: string, ttl: number) => Promise<{
+            success: boolean;
+        }>;
+        increment: (key: string, amount?: number, options?: {
+            initialValue?: number;
+            ttl?: number;
+        }) => Promise<{
+            value: number;
+        }>;
     };
     get queue(): {
         enqueue: (type: string, data: any) => Promise<{
             success: boolean;
             jobId: string;
         }>;
+        getJob: (jobId: string) => Promise<{
+            job: JobRecord | null;
+            exists: boolean;
+        }>;
+        listJobs: (options?: {
+            status?: string;
+            type?: string;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<{
+            jobs: JobRecord[];
+            list_complete: boolean;
+            cursor?: string;
+        }>;
+        cancelJob: (jobId: string) => Promise<{
+            success: boolean;
+            note?: string;
+        }>;
     };
     get ai(): {
         chat: (messages: {
@@ -69,12 +131,57 @@ export declare class AerocallClient implements AerostackRPC {
             }) => Promise<{
                 success: boolean;
             }>;
+            update: (id: string, content: string, options?: {
+                type?: string;
+                metadata?: Record<string, any>;
+            }) => Promise<{
+                success: boolean;
+            }>;
+            get: (id: string) => Promise<{
+                result: any | null;
+                exists: boolean;
+            }>;
+            count: (type?: string) => Promise<{
+                count: number;
+            }>;
         };
     };
     get storage(): {
         upload: (key: string, file: File | Blob, contentType?: string) => Promise<{
             url: string;
         }>;
+        get: (key: string) => Promise<{
+            data: Response | null;
+            exists: boolean;
+        }>;
+        getUrl: (key: string) => Promise<{
+            url: string;
+        }>;
+        list: (prefix?: string, options?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<StorageListResult>;
+        delete: (key: string) => Promise<{
+            success: boolean;
+        }>;
+        exists: (key: string) => Promise<{
+            exists: boolean;
+        }>;
+        getMetadata: (key: string) => Promise<{
+            exists: boolean;
+            size?: number;
+            contentType?: string;
+            lastModified?: Date;
+            etag?: string;
+        }>;
+        copy: (sourceKey: string, destKey: string) => Promise<{
+            success: boolean;
+            url: string;
+        }>;
+        move: (sourceKey: string, destKey: string) => Promise<{
+            success: boolean;
+            url: string;
+        }>;
     };
     get services(): {
         invoke: <T = any>(serviceName: string, data?: any) => Promise<{

package/dist/client.js

@@ -9,13 +9,10 @@ class AerocallClient {
         this.jwt = config.jwt;
         this.projectId = config.projectId;
     }
-    async request(path, method, body, isMultipart = false) {
-        const headers = {
-            'X-SDK-Version': '0.4.0'
-        };
-        if (!isMultipart) {
+    getHeaders(isMultipart = false) {
+        const headers = { 'X-SDK-Version': '0.5.0' };
+        if (!isMultipart)
             headers['Content-Type'] = 'application/json';
-        }
         if (this.apiKey)
             headers['X-API-Key'] = this.apiKey;
         if (this.jwt)
@@ -23,9 +20,12 @@ class AerocallClient {
         if (this.projectId)
             headers['X-Project-Id'] = this.projectId;
         headers['X-Request-ID'] = crypto.randomUUID();
+        return headers;
+    }
+    async request(path, method, body, isMultipart = false) {
         const response = await fetch(`${this.baseUrl}${path}`, {
             method,
-            headers,
+            headers: this.getHeaders(isMultipart),
             body: isMultipart ? body : (body ? JSON.stringify(body) : undefined)
         });
         if (!response.ok) {
@@ -39,19 +39,32 @@ class AerocallClient {
             query: async (sql, params) => {
                 const res = await this.request('/db/query', 'POST', { sql, params });
                 return (res?.results ?? []);
-            }
+            },
+            batch: (queries) => this.request('/db/batch', 'POST', { queries }),
         };
     }
     get cache() {
         return {
             get: (key) => this.request('/cache/get', 'POST', { key }),
             set: (key, value, ttl) => this.request('/cache/set', 'POST', { key, value, ttl }),
-            delete: (key) => this.request('/cache/delete', 'POST', { key })
+            delete: (key) => this.request('/cache/delete', 'POST', { key }),
+            list: (prefix, options) => this.request('/cache/list', 'POST', { prefix, ...options }),
+            keys: (prefix) => this.request('/cache/keys', 'POST', { prefix })
+                .then(r => r.keys),
+            getMany: (keys) => this.request('/cache/getMany', 'POST', { keys }).then(r => r.results),
+            setMany: (entries) => this.request('/cache/setMany', 'POST', { entries }),
+            deleteMany: (keys) => this.request('/cache/deleteMany', 'POST', { keys }),
+            flush: (prefix) => this.request('/cache/flush', 'POST', { prefix }),
+            expire: (key, ttl) => this.request('/cache/expire', 'POST', { key, ttl }),
+            increment: (key, amount, options) => this.request('/cache/increment', 'POST', { key, amount, ...options }),
         };
     }
     get queue() {
         return {
-            enqueue: (type, data) => this.request('/queue/enqueue', 'POST', { type, data })
+            enqueue: (type, data) => this.request('/queue/enqueue', 'POST', { type, data }),
+            getJob: (jobId) => this.request('/queue/job', 'POST', { jobId }),
+            listJobs: (options) => this.request('/queue/jobs', 'POST', options ?? {}),
+            cancelJob: (jobId) => this.request('/queue/cancel', 'POST', { jobId }),
         };
     }
     get ai() {
@@ -63,7 +76,10 @@ class AerocallClient {
                 delete: (id) => this.request('/ai/search/delete', 'POST', { id }),
                 deleteByType: (type) => this.request('/ai/search/deleteByType', 'POST', { type }),
                 listTypes: () => this.request('/ai/search/listTypes', 'GET'),
-                configure: (options) => this.request('/ai/search/configure', 'POST', options)
+                configure: (options) => this.request('/ai/search/configure', 'POST', options),
+                update: (id, content, options) => this.request('/ai/search/update', 'POST', { id, content, ...options }),
+                get: (id) => this.request('/ai/search/get', 'POST', { id }),
+                count: (type) => this.request('/ai/search/count', 'POST', { type }),
             }
         };
     }
@@ -76,7 +92,29 @@ class AerocallClient {
                 if (contentType)
                     formData.append('contentType', contentType);
                 return this.request('/storage/upload', 'POST', formData, true);
-            }
+            },
+            // get() returns binary — must bypass request() which calls .json()
+            get: async (key) => {
+                const response = await fetch(`${this.baseUrl}/storage/get`, {
+                    method: 'POST',
+                    headers: this.getHeaders(),
+                    body: JSON.stringify({ key }),
+                });
+                if (response.status === 404)
+                    return { data: null, exists: false };
+                if (!response.ok) {
+                    const err = await response.json().catch(() => ({ error: { message: response.statusText } }));
+                    throw new Error(err.error?.message || 'Storage get failed');
+                }
+                return { data: response, exists: true };
+            },
+            getUrl: (key) => this.request('/storage/getUrl', 'POST', { key }),
+            list: (prefix, options) => this.request('/storage/list', 'POST', { prefix, ...options }),
+            delete: (key) => this.request('/storage/delete', 'POST', { key }),
+            exists: (key) => this.request('/storage/exists', 'POST', { key }),
+            getMetadata: (key) => this.request('/storage/getMetadata', 'POST', { key }),
+            copy: (sourceKey, destKey) => this.request('/storage/copy', 'POST', { sourceKey, destKey }),
+            move: (sourceKey, destKey) => this.request('/storage/move', 'POST', { sourceKey, destKey }),
         };
     }
     get services() {

package/dist/types.d.ts

@@ -109,9 +109,54 @@ export interface Customer {
     phone?: string | null;
     created_at: number;
 }
+export interface CacheKeyEntry {
+    key: string;
+    expiration?: number;
+}
+export interface CacheListResult {
+    keys: CacheKeyEntry[];
+    list_complete: boolean;
+    cursor?: string;
+}
+export interface CacheSetEntry {
+    key: string;
+    value: any;
+    ttl?: number;
+}
+export interface StorageObject {
+    key: string;
+    size: number;
+    lastModified: Date;
+    contentType?: string;
+    etag?: string;
+}
+export interface StorageListResult {
+    objects: StorageObject[];
+    truncated: boolean;
+    cursor?: string;
+}
+export interface JobRecord {
+    id: string;
+    type: string;
+    data: any;
+    status: 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    projectId: string;
+    createdAt: string;
+}
 export interface AerostackRPC {
     db: {
         query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+        batch(queries: Array<{
+            sql: string;
+            params?: any[];
+        }>): Promise<{
+            results: Array<{
+                results: any[];
+                success: boolean;
+                error?: string;
+            }>;
+            success: boolean;
+        }>;
     };
     cache: {
         get<T = any>(key: string): Promise<{
@@ -124,12 +169,62 @@ export interface AerostackRPC {
         delete(key: string): Promise<{
             success: boolean;
         }>;
+        list(prefix?: string, options?: {
+            limit?: number;
+            cursor?: string;
+        }): Promise<CacheListResult>;
+        keys(prefix?: string): Promise<string[]>;
+        getMany<T = any>(keys: string[]): Promise<Array<{
+            key: string;
+            value: T | null;
+            exists: boolean;
+        }>>;
+        setMany(entries: CacheSetEntry[]): Promise<{
+            success: boolean;
+            count: number;
+        }>;
+        deleteMany(keys: string[]): Promise<{
+            success: boolean;
+            count: number;
+            deleted: number;
+        }>;
+        flush(prefix?: string): Promise<{
+            success: boolean;
+            deleted: number;
+        }>;
+        expire(key: string, ttl: number): Promise<{
+            success: boolean;
+        }>;
+        increment(key: string, amount?: number, options?: {
+            initialValue?: number;
+            ttl?: number;
+        }): Promise<{
+            value: number;
+        }>;
     };
     queue: {
         enqueue(type: string, data: any): Promise<{
             success: boolean;
             jobId: string;
         }>;
+        getJob(jobId: string): Promise<{
+            job: JobRecord | null;
+            exists: boolean;
+        }>;
+        listJobs(options?: {
+            status?: string;
+            type?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<{
+            jobs: JobRecord[];
+            list_complete: boolean;
+            cursor?: string;
+        }>;
+        cancelJob(jobId: string): Promise<{
+            success: boolean;
+            note?: string;
+        }>;
     };
     ai: {
         chat(messages: Array<{
@@ -163,12 +258,57 @@ export interface AerostackRPC {
             }): Promise<{
                 success: boolean;
             }>;
+            update(id: string, content: string, options?: {
+                type?: string;
+                metadata?: Record<string, any>;
+            }): Promise<{
+                success: boolean;
+            }>;
+            get(id: string): Promise<{
+                result: any | null;
+                exists: boolean;
+            }>;
+            count(type?: string): Promise<{
+                count: number;
+            }>;
         };
     };
     storage: {
         upload(key: string, file: any, contentType?: string): Promise<{
             url: string;
         }>;
+        get(key: string): Promise<{
+            data: Response | null;
+            exists: boolean;
+        }>;
+        getUrl(key: string): Promise<{
+            url: string;
+        }>;
+        list(prefix?: string, options?: {
+            limit?: number;
+            cursor?: string;
+        }): Promise<StorageListResult>;
+        delete(key: string): Promise<{
+            success: boolean;
+        }>;
+        exists(key: string): Promise<{
+            exists: boolean;
+        }>;
+        getMetadata(key: string): Promise<{
+            exists: boolean;
+            size?: number;
+            contentType?: string;
+            lastModified?: Date;
+            etag?: string;
+        }>;
+        copy(sourceKey: string, destKey: string): Promise<{
+            success: boolean;
+            url: string;
+        }>;
+        move(sourceKey: string, destKey: string): Promise<{
+            success: boolean;
+            url: string;
+        }>;
     };
     services: {
         invoke<T = any>(serviceName: string, data?: any): Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerostack/core",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Shared types and RPC client for Aerostack SDKs",
   "sideEffects": false,
   "main": "dist/index.js",

package/src/client.ts

@@ -1,4 +1,4 @@
-import { Product, Order, Cart, Customer, AerostackRPC, CollectionItem, StoreConfig, ProductVariant, Category } from './types';
+import { Product, Order, Cart, Customer, AerostackRPC, CollectionItem, StoreConfig, ProductVariant, Category, CacheListResult, CacheSetEntry, StorageListResult, JobRecord } from './types';
 
 /** @deprecated Use AerostackConfig instead. */
 export interface AerocallConfig {
@@ -24,22 +24,20 @@ export class AerocallClient implements AerostackRPC {
         this.projectId = config.projectId;
     }
 
-    private async request<T>(path: string, method: string, body?: any, isMultipart = false): Promise<T> {
-        const headers: Record<string, string> = {
-            'X-SDK-Version': '0.4.0'
-        };
-        if (!isMultipart) {
-            headers['Content-Type'] = 'application/json';
-        }
+    private getHeaders(isMultipart = false): Record<string, string> {
+        const headers: Record<string, string> = { 'X-SDK-Version': '0.5.0' };
+        if (!isMultipart) headers['Content-Type'] = 'application/json';
         if (this.apiKey) headers['X-API-Key'] = this.apiKey;
         if (this.jwt) headers['Authorization'] = `Bearer ${this.jwt}`;
         if (this.projectId) headers['X-Project-Id'] = this.projectId;
-
         headers['X-Request-ID'] = crypto.randomUUID();
+        return headers;
+    }
 
+    private async request<T>(path: string, method: string, body?: any, isMultipart = false): Promise<T> {
         const response = await fetch(`${this.baseUrl}${path}`, {
             method,
-            headers,
+            headers: this.getHeaders(isMultipart),
             body: isMultipart ? body : (body ? JSON.stringify(body) : undefined)
         });
 
@@ -55,21 +53,54 @@ export class AerocallClient implements AerostackRPC {
             query: async <T = any>(sql: string, params?: any[]) => {
                 const res = await this.request<{ results: T[]; meta?: any }>('/db/query', 'POST', { sql, params });
                 return (res?.results ?? []) as T[];
-            }
+            },
+            batch: (queries: Array<{ sql: string; params?: any[] }>) =>
+                this.request<{ results: Array<{ results: any[]; success: boolean; error?: string }>; success: boolean }>(
+                    '/db/batch', 'POST', { queries }
+                ),
         };
     }
 
     public get cache() {
         return {
-            get: <T = any>(key: string) => this.request<{ value: T | null, exists: boolean }>('/cache/get', 'POST', { key }),
-            set: (key: string, value: any, ttl?: number) => this.request<{ success: boolean }>('/cache/set', 'POST', { key, value, ttl }),
-            delete: (key: string) => this.request<{ success: boolean }>('/cache/delete', 'POST', { key })
+            get: <T = any>(key: string) =>
+                this.request<{ value: T | null; exists: boolean }>('/cache/get', 'POST', { key }),
+            set: (key: string, value: any, ttl?: number) =>
+                this.request<{ success: boolean }>('/cache/set', 'POST', { key, value, ttl }),
+            delete: (key: string) =>
+                this.request<{ success: boolean }>('/cache/delete', 'POST', { key }),
+            list: (prefix?: string, options?: { limit?: number; cursor?: string }) =>
+                this.request<CacheListResult>('/cache/list', 'POST', { prefix, ...options }),
+            keys: (prefix?: string) =>
+                this.request<{ keys: string[]; truncated: boolean }>('/cache/keys', 'POST', { prefix })
+                    .then(r => r.keys),
+            getMany: <T = any>(keys: string[]) =>
+                this.request<{ results: Array<{ key: string; value: T | null; exists: boolean }> }>(
+                    '/cache/getMany', 'POST', { keys }
+                ).then(r => r.results),
+            setMany: (entries: CacheSetEntry[]) =>
+                this.request<{ success: boolean; count: number }>('/cache/setMany', 'POST', { entries }),
+            deleteMany: (keys: string[]) =>
+                this.request<{ success: boolean; count: number; deleted: number }>('/cache/deleteMany', 'POST', { keys }),
+            flush: (prefix?: string) =>
+                this.request<{ success: boolean; deleted: number }>('/cache/flush', 'POST', { prefix }),
+            expire: (key: string, ttl: number) =>
+                this.request<{ success: boolean }>('/cache/expire', 'POST', { key, ttl }),
+            increment: (key: string, amount?: number, options?: { initialValue?: number; ttl?: number }) =>
+                this.request<{ value: number }>('/cache/increment', 'POST', { key, amount, ...options }),
         };
     }
 
     public get queue() {
         return {
-            enqueue: (type: string, data: any) => this.request<{ success: boolean; jobId: string }>('/queue/enqueue', 'POST', { type, data })
+            enqueue: (type: string, data: any) =>
+                this.request<{ success: boolean; jobId: string }>('/queue/enqueue', 'POST', { type, data }),
+            getJob: (jobId: string) =>
+                this.request<{ job: JobRecord | null; exists: boolean }>('/queue/job', 'POST', { jobId }),
+            listJobs: (options?: { status?: string; type?: string; limit?: number; cursor?: string }) =>
+                this.request<{ jobs: JobRecord[]; list_complete: boolean; cursor?: string }>('/queue/jobs', 'POST', options ?? {}),
+            cancelJob: (jobId: string) =>
+                this.request<{ success: boolean; note?: string }>('/queue/cancel', 'POST', { jobId }),
         };
     }
 
@@ -82,10 +113,20 @@ export class AerocallClient implements AerostackRPC {
                     this.request<{ success: boolean }>('/ai/search/ingest', 'POST', { content, metadata, type }),
                 query: (text: string, options?: { limit?: number; threshold?: number; filter?: Record<string, any> }) =>
                     this.request<{ results: any[] }>('/ai/search/query', 'POST', { text, ...options }),
-                delete: (id: string) => this.request<{ success: boolean }>('/ai/search/delete', 'POST', { id }),
-                deleteByType: (type: string) => this.request<{ success: boolean }>('/ai/search/deleteByType', 'POST', { type }),
-                listTypes: () => this.request<{ types: string[] }>('/ai/search/listTypes', 'GET'),
-                configure: (options: { embeddingModel: string }) => this.request<{ success: boolean }>('/ai/search/configure', 'POST', options)
+                delete: (id: string) =>
+                    this.request<{ success: boolean }>('/ai/search/delete', 'POST', { id }),
+                deleteByType: (type: string) =>
+                    this.request<{ success: boolean }>('/ai/search/deleteByType', 'POST', { type }),
+                listTypes: () =>
+                    this.request<{ types: string[] }>('/ai/search/listTypes', 'GET'),
+                configure: (options: { embeddingModel: string }) =>
+                    this.request<{ success: boolean }>('/ai/search/configure', 'POST', options),
+                update: (id: string, content: string, options?: { type?: string; metadata?: Record<string, any> }) =>
+                    this.request<{ success: boolean }>('/ai/search/update', 'POST', { id, content, ...options }),
+                get: (id: string) =>
+                    this.request<{ result: any | null; exists: boolean }>('/ai/search/get', 'POST', { id }),
+                count: (type?: string) =>
+                    this.request<{ count: number }>('/ai/search/count', 'POST', { type }),
             }
         };
     }
@@ -98,7 +139,37 @@ export class AerocallClient implements AerostackRPC {
                 formData.append('file', file);
                 if (contentType) formData.append('contentType', contentType);
                 return this.request<{ url: string }>('/storage/upload', 'POST', formData, true);
-            }
+            },
+            // get() returns binary — must bypass request() which calls .json()
+            get: async (key: string): Promise<{ data: Response | null; exists: boolean }> => {
+                const response = await fetch(`${this.baseUrl}/storage/get`, {
+                    method: 'POST',
+                    headers: this.getHeaders(),
+                    body: JSON.stringify({ key }),
+                });
+                if (response.status === 404) return { data: null, exists: false };
+                if (!response.ok) {
+                    const err = await response.json().catch(() => ({ error: { message: response.statusText } }));
+                    throw new Error((err as any).error?.message || 'Storage get failed');
+                }
+                return { data: response, exists: true };
+            },
+            getUrl: (key: string) =>
+                this.request<{ url: string }>('/storage/getUrl', 'POST', { key }),
+            list: (prefix?: string, options?: { limit?: number; cursor?: string }) =>
+                this.request<StorageListResult>('/storage/list', 'POST', { prefix, ...options }),
+            delete: (key: string) =>
+                this.request<{ success: boolean }>('/storage/delete', 'POST', { key }),
+            exists: (key: string) =>
+                this.request<{ exists: boolean }>('/storage/exists', 'POST', { key }),
+            getMetadata: (key: string) =>
+                this.request<{ exists: boolean; size?: number; contentType?: string; lastModified?: Date; etag?: string }>(
+                    '/storage/getMetadata', 'POST', { key }
+                ),
+            copy: (sourceKey: string, destKey: string) =>
+                this.request<{ success: boolean; url: string }>('/storage/copy', 'POST', { sourceKey, destKey }),
+            move: (sourceKey: string, destKey: string) =>
+                this.request<{ success: boolean; url: string }>('/storage/move', 'POST', { sourceKey, destKey }),
         };
     }
 

package/src/types.ts

@@ -119,17 +119,74 @@ export interface Customer {
     created_at: number;
 }
 
+// --- Enterprise module types ---
+
+export interface CacheKeyEntry {
+    key: string;
+    expiration?: number; // Unix timestamp when this key expires
+}
+
+export interface CacheListResult {
+    keys: CacheKeyEntry[];
+    list_complete: boolean;
+    cursor?: string;
+}
+
+export interface CacheSetEntry {
+    key: string;
+    value: any;
+    ttl?: number;
+}
+
+export interface StorageObject {
+    key: string;         // User-facing key (project prefix stripped)
+    size: number;
+    lastModified: Date;
+    contentType?: string;
+    etag?: string;
+}
+
+export interface StorageListResult {
+    objects: StorageObject[];
+    truncated: boolean;
+    cursor?: string;
+}
+
+export interface JobRecord {
+    id: string;
+    type: string;
+    data: any;
+    status: 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    projectId: string;
+    createdAt: string;
+}
+
 export interface AerostackRPC {
     db: {
         query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+        batch(queries: Array<{ sql: string; params?: any[] }>): Promise<{
+            results: Array<{ results: any[]; success: boolean; error?: string }>;
+            success: boolean;
+        }>;
     };
     cache: {
         get<T = any>(key: string): Promise<{ value: T | null; exists: boolean }>;
         set(key: string, value: any, ttl?: number): Promise<{ success: boolean }>;
         delete(key: string): Promise<{ success: boolean }>;
+        list(prefix?: string, options?: { limit?: number; cursor?: string }): Promise<CacheListResult>;
+        keys(prefix?: string): Promise<string[]>;
+        getMany<T = any>(keys: string[]): Promise<Array<{ key: string; value: T | null; exists: boolean }>>;
+        setMany(entries: CacheSetEntry[]): Promise<{ success: boolean; count: number }>;
+        deleteMany(keys: string[]): Promise<{ success: boolean; count: number; deleted: number }>;
+        flush(prefix?: string): Promise<{ success: boolean; deleted: number }>;
+        expire(key: string, ttl: number): Promise<{ success: boolean }>;
+        increment(key: string, amount?: number, options?: { initialValue?: number; ttl?: number }): Promise<{ value: number }>;
     };
     queue: {
         enqueue(type: string, data: any): Promise<{ success: boolean; jobId: string }>;
+        getJob(jobId: string): Promise<{ job: JobRecord | null; exists: boolean }>;
+        listJobs(options?: { status?: string; type?: string; limit?: number; cursor?: string }): Promise<{ jobs: JobRecord[]; list_complete: boolean; cursor?: string }>;
+        cancelJob(jobId: string): Promise<{ success: boolean; note?: string }>;
     };
     ai: {
         chat(messages: Array<{ role: 'user' | 'assistant' | 'system'; content: string }>, model?: string): Promise<{ response: string }>;
@@ -140,10 +197,21 @@ export interface AerostackRPC {
             deleteByType(type: string): Promise<{ success: boolean }>;
             listTypes(): Promise<{ types: string[] }>;
             configure(options: { embeddingModel: string }): Promise<{ success: boolean }>;
+            update(id: string, content: string, options?: { type?: string; metadata?: Record<string, any> }): Promise<{ success: boolean }>;
+            get(id: string): Promise<{ result: any | null; exists: boolean }>;
+            count(type?: string): Promise<{ count: number }>;
         };
     };
     storage: {
         upload(key: string, file: any, contentType?: string): Promise<{ url: string }>;
+        get(key: string): Promise<{ data: Response | null; exists: boolean }>;
+        getUrl(key: string): Promise<{ url: string }>;
+        list(prefix?: string, options?: { limit?: number; cursor?: string }): Promise<StorageListResult>;
+        delete(key: string): Promise<{ success: boolean }>;
+        exists(key: string): Promise<{ exists: boolean }>;
+        getMetadata(key: string): Promise<{ exists: boolean; size?: number; contentType?: string; lastModified?: Date; etag?: string }>;
+        copy(sourceKey: string, destKey: string): Promise<{ success: boolean; url: string }>;
+        move(sourceKey: string, destKey: string): Promise<{ success: boolean; url: string }>;
     };
     services: {
         invoke<T = any>(serviceName: string, data?: any): Promise<{ success: true; result: T }>;