@runtypelabs/sdk 0.1.1

package/dist/endpoints.js

@@ -0,0 +1,725 @@
+"use strict";
+/**
+ * API endpoint handlers with automatic camelCase/snake_case transformation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvalEndpoint = exports.ToolsEndpoint = exports.ContextTemplatesEndpoint = exports.FlowStepsEndpoint = exports.AnalyticsEndpoint = exports.UsersEndpoint = exports.ChatEndpoint = exports.DispatchEndpoint = exports.ModelConfigsEndpoint = exports.ApiKeysEndpoint = exports.RecordsEndpoint = exports.PromptsEndpoint = exports.FlowsEndpoint = void 0;
+/**
+ * Flows endpoint handlers
+ */
+class FlowsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all flows for the authenticated user
+     */
+    async list(params) {
+        return this.client.get('/flows', params);
+    }
+    /**
+     * Get a specific flow by ID
+     */
+    async get(id) {
+        const response = await this.client.get(`/flows/${id}`);
+        return response;
+    }
+    /**
+     * Create a new flow
+     */
+    async create(data) {
+        return this.client.post('/flows', data);
+    }
+    /**
+     * Update an existing flow
+     */
+    async update(id, data) {
+        return this.client.put(`/flows/${id}`, data);
+    }
+    /**
+     * Delete a flow
+     */
+    async delete(id) {
+        return this.client.delete(`/flows/${id}`);
+    }
+    /**
+     * Run a flow on all records of a specific type
+     */
+    async runOnRecordType(id, recordType) {
+        return this.client.post(`/flows/${id}/run-on-record-type`, {
+            recordType
+        });
+    }
+    /**
+     * Publish flow (promote draft to published)
+     */
+    async publish(id) {
+        return this.client.post(`/flows/${id}/publish`);
+    }
+}
+exports.FlowsEndpoint = FlowsEndpoint;
+/**
+ * Prompts endpoint handlers
+ */
+class PromptsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all prompts for the authenticated user
+     */
+    async list(params) {
+        return this.client.get('/prompts', params);
+    }
+    /**
+     * Get a specific prompt by ID
+     */
+    async get(id) {
+        return this.client.get(`/prompts/${id}`);
+    }
+    /**
+     * Create a new prompt
+     */
+    async create(data) {
+        return this.client.post('/prompts', data);
+    }
+    /**
+     * Update an existing prompt
+     */
+    async update(id, data) {
+        return this.client.put(`/prompts/${id}`, data);
+    }
+    /**
+     * Delete a prompt
+     */
+    async delete(id) {
+        return this.client.delete(`/prompts/${id}`);
+    }
+    /**
+     * Run a prompt on a specific record
+     */
+    async runOnRecord(id, recordId) {
+        return this.client.post(`/prompts/${id}/run-on-record`, { recordId });
+    }
+    /**
+     * Get flows using this prompt
+     */
+    async getFlows(id) {
+        return this.client.get(`/prompts/${id}/flows`);
+    }
+    /**
+     * Update flow attachments for a prompt
+     */
+    async updateFlows(id, flowIds) {
+        return this.client.put(`/prompts/${id}/flows`, { flowIds });
+    }
+}
+exports.PromptsEndpoint = PromptsEndpoint;
+/**
+ * Records endpoint handlers
+ */
+class RecordsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all records for the authenticated user
+     */
+    async list(params) {
+        return this.client.get('/records', params);
+    }
+    /**
+     * Get a specific record by ID
+     */
+    async get(id) {
+        return this.client.get(`/records/${id}`);
+    }
+    /**
+     * Create a new record
+     */
+    async create(data) {
+        return this.client.post('/records', data);
+    }
+    /**
+     * Update an existing record
+     */
+    async update(id, data) {
+        return this.client.put(`/records/${id}`, data);
+    }
+    /**
+     * Delete a record
+     */
+    async delete(id) {
+        return this.client.delete(`/records/${id}`);
+    }
+    /**
+     * Bulk delete multiple records
+     */
+    async bulkDelete(ids) {
+        return this.client.post('/records/bulk-delete', { ids });
+    }
+    /**
+     * Bulk edit multiple records
+     */
+    async bulkEdit(data) {
+        return this.client.post('/records/bulk-edit', data);
+    }
+    /**
+     * Get results for a record
+     */
+    async getResults(id, params) {
+        return this.client.get(`/records/${id}/results`, params);
+    }
+    /**
+     * Delete a specific result for a record
+     */
+    async deleteResult(id, resultId) {
+        return this.client.delete(`/records/${id}/results`, { resultId });
+    }
+    /**
+     * Upload CSV file to create multiple records
+     */
+    async uploadCsv(file, params) {
+        const formData = new FormData();
+        formData.append('file', file);
+        if (params?.typeColumn) {
+            formData.append('typeColumn', params.typeColumn);
+        }
+        if (params?.nameColumn) {
+            formData.append('nameColumn', params.nameColumn);
+        }
+        return this.client.postFormData('/records/upload-csv', formData);
+    }
+    /**
+     * Get record types (distinct values)
+     */
+    async getTypes() {
+        return this.client.get('/records?distinct=types');
+    }
+    /**
+     * Get example record by type and/or name
+     */
+    async getExample(params) {
+        return this.client.get('/records', {
+            ...params,
+            includeFields: true,
+            limit: 1
+        });
+    }
+}
+exports.RecordsEndpoint = RecordsEndpoint;
+/**
+ * API Keys endpoint handlers
+ */
+class ApiKeysEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all API keys for the authenticated user
+     */
+    async list() {
+        const response = await this.client.get('/api-keys');
+        return response.apiKeys;
+    }
+    /**
+     * Get a specific API key by ID
+     */
+    async get(id) {
+        return this.client.get(`/api-keys/${id}`);
+    }
+    /**
+     * Create a new API key
+     */
+    async create(data) {
+        return this.client.post('/api-keys', data);
+    }
+    /**
+     * Update an existing API key
+     */
+    async update(id, data) {
+        return this.client.put(`/api-keys/${id}`, data);
+    }
+    /**
+     * Delete an API key
+     */
+    async delete(id) {
+        return this.client.delete(`/api-keys/${id}`);
+    }
+    /**
+     * Regenerate an API key
+     */
+    async regenerate(id) {
+        return this.client.post(`/api-keys/${id}/regenerate`);
+    }
+    /**
+     * Get API key analytics
+     */
+    async getAnalytics(id) {
+        return this.client.get(`/api-keys/${id}/analytics`);
+    }
+    /**
+     * Get usage logs for an API key
+     */
+    async getUsage(id, params) {
+        return this.client.get(`/api-keys/${id}/usage`, params);
+    }
+    /**
+     * Get API key analytics (all keys or specific key)
+     */
+    async getAnalyticsEnhanced(apiKeyId, params) {
+        const endpoint = apiKeyId === 'all'
+            ? '/api-keys/analytics'
+            : `/api-keys/${apiKeyId}/analytics`;
+        return this.client.get(endpoint, params);
+    }
+    /**
+     * Get API key usage logs (all keys or specific key)
+     */
+    async getLogs(apiKeyId, params) {
+        const endpoint = apiKeyId === 'all'
+            ? '/api-keys/logs'
+            : `/api-keys/${apiKeyId}/logs`;
+        return this.client.get(endpoint, params);
+    }
+    /**
+     * Get API key permission options
+     */
+    async getPermissionOptions() {
+        return this.client.get('/api-keys/options');
+    }
+    /**
+     * Get API key security logs
+     */
+    async getSecurityLogs(id) {
+        return this.client.get(`/api-keys/${id}/security-logs`);
+    }
+    /**
+     * Update API key security settings
+     */
+    async updateSecurity(id, data) {
+        return this.client.put(`/api-keys/${id}/security`, data);
+    }
+    /**
+     * Clear suspicious activity for API key
+     */
+    async clearSuspiciousActivity(id) {
+        return this.client.post(`/api-keys/${id}/clear-suspicious`);
+    }
+}
+exports.ApiKeysEndpoint = ApiKeysEndpoint;
+/**
+ * Model Configurations endpoint handlers
+ */
+class ModelConfigsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get available models catalog
+     */
+    async getAvailable() {
+        const response = await this.client.get('/model-configs/available');
+        // Handle both wrapped and direct array responses
+        return Array.isArray(response) ? response : response.data || [];
+    }
+    /**
+     * Get search-capable models (all available, regardless of user configuration)
+     */
+    async getSearchCapable() {
+        const response = await this.client.get('/model-configs/search-capable');
+        return response.data || [];
+    }
+    /**
+     * Get configured search-capable models (only user's configured and enabled models)
+     */
+    async getSearchConfigured() {
+        const response = await this.client.get('/model-configs/search-configured');
+        return response.data || [];
+    }
+    /**
+     * List user's model configurations
+     */
+    async list() {
+        const response = await this.client.get('/model-configs');
+        // Handle both wrapped and direct array responses
+        return Array.isArray(response) ? response : response.data || [];
+    }
+    /**
+     * Create a new model configuration
+     */
+    async create(data) {
+        return this.client.post('/model-configs', data);
+    }
+    /**
+     * Update an existing model configuration
+     */
+    async update(id, data) {
+        return this.client.put(`/model-configs/${id}`, data);
+    }
+    /**
+     * Delete a model configuration
+     */
+    async delete(id) {
+        return this.client.delete(`/model-configs/${id}`);
+    }
+    /**
+     * Enable/disable a model configuration
+     */
+    async updateStatus(id, isEnabled) {
+        return this.client.patch(`/model-configs/${id}/status`, { isEnabled });
+    }
+    /**
+     * Set a model configuration as default
+     */
+    async setDefault(id) {
+        return this.client.patch(`/model-configs/${id}/default`);
+    }
+    /**
+     * Get usage statistics
+     */
+    async getUsage() {
+        return this.client.get('/model-configs/usage');
+    }
+}
+exports.ModelConfigsEndpoint = ModelConfigsEndpoint;
+/**
+ * Dispatch endpoint handler for atomic record/flow creation and execution
+ */
+class DispatchEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Dispatch: create and/or execute flows on records atomically
+     */
+    async execute(data) {
+        return this.client.post('/dispatch', data);
+    }
+    /**
+     * Dispatch with streaming response
+     */
+    async executeStream(data) {
+        return this.client.requestStream('/dispatch', {
+            method: 'POST',
+            body: JSON.stringify(data)
+        });
+    }
+    /**
+     * Resume paused flow execution
+     * API expects snake_case field names
+     *
+     * @param data.execution_id - The execution ID to resume
+     * @param data.tool_outputs - Tool outputs to inject into the flow
+     * @param data.stream_response - Whether to stream the response
+     * @param data.messages - Optional messages to override the original dispatch messages
+     */
+    async resume(data) {
+        if (data.stream_response) {
+            return this.client.requestStream('/dispatch/resume', {
+                method: 'POST',
+                body: JSON.stringify(data)
+            });
+        }
+        return this.client.post('/dispatch/resume', data);
+    }
+}
+exports.DispatchEndpoint = DispatchEndpoint;
+/**
+ * Chat endpoint handler
+ */
+class ChatEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Send a chat message
+     */
+    async send(message) {
+        return this.client.post('/chat', { message });
+    }
+    /**
+     * Send a chat message with streaming response
+     */
+    async sendStream(message, options) {
+        return this.client.requestStream('/chat', {
+            method: 'POST',
+            body: JSON.stringify({ message, ...options })
+        });
+    }
+}
+exports.ChatEndpoint = ChatEndpoint;
+/**
+ * Users endpoint handlers
+ */
+class UsersEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get current user profile
+     */
+    async getProfile() {
+        return this.client.get('/users/profile');
+    }
+    /**
+     * Update user profile
+     */
+    async updateProfile(data) {
+        return this.client.put('/users/profile', data);
+    }
+}
+exports.UsersEndpoint = UsersEndpoint;
+/**
+ * Analytics endpoint handlers
+ */
+class AnalyticsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get analytics stats
+     */
+    async getStats(params) {
+        return this.client.get('/analytics/stats', params);
+    }
+    /**
+     * Get analytics executions
+     */
+    async getExecutions(params) {
+        return this.client.get('/analytics/record-results', params);
+    }
+    /**
+     * Get all record results (same as executions)
+     */
+    async getAllRecordResults(params) {
+        return this.client.get('/analytics/record-results', params);
+    }
+    /**
+     * Get model usage analytics
+     */
+    async getModelUsage(params) {
+        return this.client.get('/model-usage', params);
+    }
+}
+exports.AnalyticsEndpoint = AnalyticsEndpoint;
+/**
+ * Flow Steps endpoint handlers
+ */
+class FlowStepsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get flow steps for a flow
+     */
+    async getByFlow(flowId) {
+        return this.client.get(`/flow-steps/flow/${flowId}`);
+    }
+    /**
+     * Get a specific flow step
+     */
+    async get(id) {
+        return this.client.get(`/flow-steps/${id}`);
+    }
+    /**
+     * Create a flow step
+     */
+    async create(data) {
+        return this.client.post('/flow-steps', data);
+    }
+    /**
+     * Update a flow step
+     */
+    async update(id, data) {
+        return this.client.put(`/flow-steps/${id}`, data);
+    }
+    /**
+     * Delete a flow step
+     */
+    async delete(id) {
+        return this.client.delete(`/flow-steps/${id}`);
+    }
+    /**
+     * Reorder flow steps
+     */
+    async reorder(flowId, stepOrders) {
+        return this.client.post('/flow-steps/reorder', {
+            flowId,
+            stepOrders
+        });
+    }
+}
+exports.FlowStepsEndpoint = FlowStepsEndpoint;
+/**
+ * Context Templates endpoint handlers
+ */
+class ContextTemplatesEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List context templates
+     */
+    async list(params) {
+        return this.client.get('/context-templates', params);
+    }
+    /**
+     * Get a specific context template
+     */
+    async get(id) {
+        return this.client.get(`/context-templates/${id}`);
+    }
+    /**
+     * Create a context template
+     */
+    async create(data) {
+        return this.client.post('/context-templates', data);
+    }
+    /**
+     * Update a context template
+     */
+    async update(id, data) {
+        return this.client.put(`/context-templates/${id}`, data);
+    }
+    /**
+     * Delete a context template
+     */
+    async delete(id) {
+        return this.client.delete(`/context-templates/${id}`);
+    }
+}
+exports.ContextTemplatesEndpoint = ContextTemplatesEndpoint;
+/**
+ * Tools endpoint handlers
+ */
+class ToolsEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all tools for the authenticated user
+     */
+    async list(params) {
+        return this.client.get('/tools', params);
+    }
+    /**
+     * Get a specific tool by ID
+     */
+    async get(id) {
+        return this.client.get(`/tools/${id}`);
+    }
+    /**
+     * Create a new tool
+     */
+    async create(data) {
+        return this.client.post('/tools', data);
+    }
+    /**
+     * Update an existing tool
+     */
+    async update(id, data) {
+        return this.client.put(`/tools/${id}`, data);
+    }
+    /**
+     * Delete a tool
+     */
+    async delete(id) {
+        return this.client.delete(`/tools/${id}`);
+    }
+    /**
+     * Execute a tool
+     */
+    async execute(id, data) {
+        return this.client.post(`/tools/${id}/execute`, data);
+    }
+    /**
+     * Execute a tool with streaming response
+     */
+    async executeStream(id, data) {
+        return this.client.requestStream(`/tools/${id}/execute`, {
+            method: 'POST',
+            body: JSON.stringify(data)
+        });
+    }
+    /**
+     * Test a tool (same as execute but for testing purposes)
+     */
+    async test(id, data) {
+        return this.client.post(`/tools/${id}/test`, data);
+    }
+    /**
+     * Get tool executions for a specific tool
+     */
+    async getExecutions(toolId, params) {
+        return this.client.get(`/tools/${toolId}/executions`, params);
+    }
+    /**
+     * Get AI SDK compatible tool schemas
+     */
+    async getSchemas(params) {
+        return this.client.get('/tools/schema', params);
+    }
+    /**
+     * Get available tools for prompts
+     */
+    async getAvailable() {
+        const response = await this.client.get('/tools', {
+            isActive: true,
+            limit: 200,
+        });
+        const payload = response;
+        if (Array.isArray(payload?.data)) {
+            return payload.data;
+        }
+        if (Array.isArray(payload)) {
+            return payload;
+        }
+        return [];
+    }
+    /**
+     * Convert a flow to a tool
+     */
+    async convertFromFlow(flowId, data) {
+        return this.client.post(`/flows/${flowId}/convert-to-tool`, data);
+    }
+    /**
+     * Get all built-in tools
+     */
+    async getBuiltInTools() {
+        return this.client.get('/tools/builtin');
+    }
+    /**
+     * Get built-in tools compatible with a specific model and provider
+     */
+    async getCompatibleBuiltInTools(model, provider) {
+        return this.client.get('/tools/builtin/compatible', { model, provider });
+    }
+    /**
+     * Get parameter schema for a specific built-in tool
+     */
+    async getBuiltInToolSchema(toolId) {
+        return this.client.get(`/tools/builtin/${toolId}/schema`);
+    }
+}
+exports.ToolsEndpoint = ToolsEndpoint;
+/**
+ * Eval endpoint handlers
+ */
+class EvalEndpoint {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Run virtual eval with streaming response
+     * Executes multiple eval configs simultaneously and streams results via multiplexed SSE
+     */
+    async runVirtualEval(data) {
+        return this.client.requestStream('/eval/stream', {
+            method: 'POST',
+            body: JSON.stringify(data)
+        });
+    }
+}
+exports.EvalEndpoint = EvalEndpoint;
+//# sourceMappingURL=endpoints.js.map