@protoboxai/sdk 1.0.0

package/dist/modules/prompts.d.ts

@@ -0,0 +1,128 @@
+import { ChanlSDK } from "../client";
+import { ApiResponse } from "../types/config";
+export interface PromptVariable {
+    name: string;
+    description?: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    required: boolean;
+    default?: string | number | boolean | unknown[] | Record<string, unknown>;
+}
+export interface Prompt {
+    id: string;
+    _id?: string;
+    name: string;
+    description?: string;
+    content: string;
+    category?: 'support' | 'sales' | 'onboarding' | 'general';
+    status?: 'active' | 'draft' | 'archived';
+    version?: number;
+    versionName?: string;
+    notes?: string;
+    icon?: string;
+    color?: string;
+    tags?: string[];
+    variables?: PromptVariable[];
+    usageCount?: number;
+    avgScore?: number;
+    lastModified?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface PromptVersion {
+    id: string;
+    _id?: string;
+    promptId: string;
+    version: string;
+    versionName?: string;
+    content: string;
+    variables?: PromptVariable[];
+    notes?: string;
+    isActive: boolean;
+    author?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface CreatePromptData {
+    name: string;
+    description?: string;
+    content: string;
+    category?: 'support' | 'sales' | 'onboarding' | 'general';
+    status?: 'active' | 'draft' | 'archived';
+    icon?: string;
+    color?: string;
+    tags?: string[];
+    variables?: PromptVariable[];
+    notes?: string;
+}
+export interface UpdatePromptData {
+    name?: string;
+    description?: string;
+    content?: string;
+    category?: 'support' | 'sales' | 'onboarding' | 'general';
+    status?: 'active' | 'draft' | 'archived';
+    icon?: string;
+    color?: string;
+    tags?: string[];
+    variables?: PromptVariable[];
+    notes?: string;
+    versionName?: string;
+}
+export interface CreatePromptVersionData {
+    versionName?: string;
+    notes?: string;
+    content?: string;
+    variables?: PromptVariable[];
+}
+export interface PromptFilters {
+    search?: string;
+    category?: 'support' | 'sales' | 'onboarding' | 'general';
+    status?: 'active' | 'draft' | 'archived';
+    tags?: string[];
+    page?: number;
+    limit?: number;
+}
+export declare class PromptsModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * List all prompts with optional filters
+     */
+    list(filters?: PromptFilters): Promise<ApiResponse<Prompt[]>>;
+    /**
+     * Get a single prompt by ID
+     */
+    get(id: string): Promise<ApiResponse<Prompt>>;
+    /**
+     * Create a new prompt
+     */
+    create(data: CreatePromptData): Promise<ApiResponse<Prompt>>;
+    /**
+     * Update an existing prompt (updates current version)
+     */
+    update(id: string, data: UpdatePromptData): Promise<ApiResponse<Prompt>>;
+    /**
+     * Delete a prompt
+     */
+    delete(id: string): Promise<ApiResponse<void>>;
+    /**
+     * Get version history for a prompt
+     */
+    getVersions(promptId: string): Promise<ApiResponse<PromptVersion[]>>;
+    /**
+     * Get a specific version of a prompt
+     */
+    getVersion(promptId: string, versionId: string): Promise<ApiResponse<PromptVersion>>;
+    /**
+     * Create a new version explicitly (save as new version)
+     */
+    createVersion(promptId: string, data: CreatePromptVersionData): Promise<ApiResponse<PromptVersion>>;
+    /**
+     * Restore a version (make it the active version)
+     */
+    restoreVersion(promptId: string, versionId: string): Promise<ApiResponse<Prompt>>;
+    /**
+     * Delete a version (soft delete)
+     */
+    deleteVersion(promptId: string, versionId: string): Promise<ApiResponse<void>>;
+}
+//# sourceMappingURL=prompts.d.ts.map

package/dist/modules/prompts.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptsModule = void 0;
+// ============================================================================
+// PROMPTS MODULE
+// ============================================================================
+class PromptsModule {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * List all prompts with optional filters
+     */
+    async list(filters) {
+        const queryParams = new URLSearchParams();
+        if (filters?.search) {
+            queryParams.append("search", filters.search);
+        }
+        if (filters?.category) {
+            queryParams.append("category", filters.category);
+        }
+        if (filters?.status) {
+            queryParams.append("status", filters.status);
+        }
+        if (filters?.tags && filters.tags.length > 0) {
+            queryParams.append("tags", filters.tags.join(","));
+        }
+        if (filters?.page) {
+            queryParams.append("page", filters.page.toString());
+        }
+        if (filters?.limit) {
+            queryParams.append("limit", filters.limit.toString());
+        }
+        const url = `/api/v1/prompts${queryParams.toString() ? `?${queryParams.toString()}` : ""}`;
+        return this.sdk.request("GET", url);
+    }
+    /**
+     * Get a single prompt by ID
+     */
+    async get(id) {
+        return this.sdk.request("GET", `/api/v1/prompts/${id}`);
+    }
+    /**
+     * Create a new prompt
+     */
+    async create(data) {
+        return this.sdk.request("POST", "/api/v1/prompts", data);
+    }
+    /**
+     * Update an existing prompt (updates current version)
+     */
+    async update(id, data) {
+        return this.sdk.request("PUT", `/api/v1/prompts/${id}`, data);
+    }
+    /**
+     * Delete a prompt
+     */
+    async delete(id) {
+        return this.sdk.request("DELETE", `/api/v1/prompts/${id}`);
+    }
+    /**
+     * Get version history for a prompt
+     */
+    async getVersions(promptId) {
+        return this.sdk.request("GET", `/api/v1/prompts/${promptId}/versions`);
+    }
+    /**
+     * Get a specific version of a prompt
+     */
+    async getVersion(promptId, versionId) {
+        return this.sdk.request("GET", `/api/v1/prompts/${promptId}/versions/${versionId}`);
+    }
+    /**
+     * Create a new version explicitly (save as new version)
+     */
+    async createVersion(promptId, data) {
+        return this.sdk.request("POST", `/api/v1/prompts/${promptId}/versions`, data);
+    }
+    /**
+     * Restore a version (make it the active version)
+     */
+    async restoreVersion(promptId, versionId) {
+        return this.sdk.request("POST", `/api/v1/prompts/${promptId}/versions/${versionId}/restore`);
+    }
+    /**
+     * Delete a version (soft delete)
+     */
+    async deleteVersion(promptId, versionId) {
+        return this.sdk.request("DELETE", `/api/v1/prompts/${promptId}/versions/${versionId}`);
+    }
+}
+exports.PromptsModule = PromptsModule;
+//# sourceMappingURL=prompts.js.map

package/dist/modules/tools.d.ts

@@ -0,0 +1,222 @@
+/**
+ * ToolsModule - SDK module for MCP tool management and execution
+ *
+ * TDD Phase: GREEN - Implementation to make tests pass
+ *
+ * Provides CRUD operations for tools and execution capabilities.
+ * Supports both JWT auth (admin UI) and MCP API key auth.
+ */
+import { ChanlSDK } from '../client';
+import { ApiResponse } from '../types/config';
+import type { Tool, ExecuteResult, CreateToolInput, UpdateToolInput, ToolFilters, ExecutionFilters, ToolListResponse, ToolDeleteResponse, ExecutionListResponse, ToolCategoriesResponse } from '../types/tools';
+export declare class ToolsModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * List all tools with optional filters
+     *
+     * @param filters - Optional filters for the query
+     * @returns Paginated list of tools
+     *
+     * @example
+     * ```typescript
+     * // List all tools
+     * const { data } = await sdk.tools.list();
+     *
+     * // Filter by type and status
+     * const { data } = await sdk.tools.list({
+     *   type: 'http',
+     *   isEnabled: true,
+     *   page: 1,
+     *   limit: 10
+     * });
+     *
+     * // Exclude system tools (kb_search, chanl_reason, etc.)
+     * const { data } = await sdk.tools.list({
+     *   includeSystem: false
+     * });
+     * ```
+     */
+    list(filters?: ToolFilters): Promise<ApiResponse<ToolListResponse>>;
+    /**
+     * Get a single tool by ID
+     *
+     * @param id - Tool ID
+     * @returns Tool details
+     * @throws NotFoundError if tool doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.get('tool_abc123');
+     * console.log(data.tool.name);
+     * ```
+     */
+    get(id: string): Promise<ApiResponse<Tool>>;
+    /**
+     * Create a new tool
+     *
+     * @param workspaceId - Workspace ID
+     * @param input - Tool creation data
+     * @returns Created tool
+     * @throws ValidationError if input is invalid
+     * @throws ConflictError if tool name already exists
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.create({
+     *   name: 'get_weather',
+     *   description: 'Get weather for a city',
+     *   type: 'http',
+     *   inputSchema: {
+     *     type: 'object',
+     *     properties: { city: { type: 'string' } },
+     *     required: ['city']
+     *   },
+     *   configuration: {
+     *     http: { method: 'GET', url: 'https://wttr.in/{{city}}' }
+     *   }
+     * });
+     * ```
+     */
+    create(input: CreateToolInput): Promise<ApiResponse<Tool>>;
+    /**
+     * Update an existing tool
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @param input - Update data
+     * @returns Updated tool
+     * @throws NotFoundError if tool doesn't exist
+     * @throws ValidationError if input is invalid
+     * @throws ConflictError if new name already exists
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.update('tool_abc123', {
+     *   description: 'Updated description',
+     *   isEnabled: false
+     * });
+     * ```
+     */
+    update(id: string, input: UpdateToolInput): Promise<ApiResponse<Tool>>;
+    /**
+     * Delete a tool
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @returns Deletion confirmation
+     * @throws NotFoundError if tool doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.delete('tool_abc123');
+     * console.log(data.deleted); // true
+     * ```
+     */
+    delete(id: string): Promise<ApiResponse<ToolDeleteResponse>>;
+    /**
+     * Execute a tool with given arguments
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @param args - Arguments to pass to the tool
+     * @returns Execution result
+     * @throws NotFoundError if tool doesn't exist
+     * @throws ValidationError if args don't match input schema
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.execute('tool_abc123', {
+     *   city: 'London',
+     *   units: 'celsius'
+     * });
+     * console.log(data.output); // { temperature: 12, ... }
+     * ```
+     */
+    execute(id: string, args: Record<string, unknown>): Promise<ApiResponse<ExecuteResult>>;
+    /**
+     * Test a tool execution (same as execute but for testing in admin UI)
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @param args - Arguments to pass to the tool
+     * @returns Execution result
+     * @throws NotFoundError if tool doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.test('tool_abc123', {
+     *   city: 'London'
+     * });
+     * ```
+     */
+    test(id: string, args: Record<string, unknown>): Promise<ApiResponse<ExecuteResult>>;
+    /**
+     * Get execution history for a tool
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @param filters - Optional filters for the query
+     * @returns Paginated list of executions
+     * @throws NotFoundError if tool doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Get all executions
+     * const { data } = await sdk.tools.getExecutions('ws_123', 'tool_abc123');
+     *
+     * // Filter by status and date range
+     * const { data } = await sdk.tools.getExecutions('ws_123', 'tool_abc123', {
+     *   status: 'completed',
+     *   fromDate: '2025-01-01',
+     *   toDate: '2025-01-31'
+     * });
+     * ```
+     */
+    getExecutions(id: string, filters?: ExecutionFilters): Promise<ApiResponse<ExecutionListResponse>>;
+    /**
+     * Enable a tool (shortcut for setting isEnabled=true)
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @returns Updated tool
+     * @throws NotFoundError if tool doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.enable('tool_abc123');
+     * console.log(data.tool.isEnabled); // true
+     * ```
+     */
+    enable(id: string): Promise<ApiResponse<Tool>>;
+    /**
+     * Disable a tool (shortcut for setting isEnabled=false)
+     *
+     * @param workspaceId - Workspace ID
+     * @param id - Tool ID
+     * @returns Updated tool
+     * @throws NotFoundError if tool doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.disable('tool_abc123');
+     * console.log(data.tool.isEnabled); // false
+     * ```
+     */
+    disable(id: string): Promise<ApiResponse<Tool>>;
+    /**
+     * Get tool categories (aggregated tags with counts)
+     *
+     * @param workspaceId - Workspace ID
+     * @returns List of categories with counts
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.tools.getCategories('ws_123');
+     * console.log(data.categories);
+     * // [{ name: 'weather', count: 5, enabledCount: 3 }, ...]
+     * ```
+     */
+    getCategories(): Promise<ApiResponse<ToolCategoriesResponse>>;
+}
+//# sourceMappingURL=tools.d.ts.map