@protoboxai/sdk 1.0.0

package/dist/modules/workspace.d.ts

@@ -0,0 +1,48 @@
+import { ChanlSDK } from "../client";
+import { ApiResponse } from "../types/config";
+export type WorkspaceSettings = Record<string, unknown>;
+export interface Workspace {
+    id: string;
+    name: string;
+    description?: string;
+    settings: WorkspaceSettings;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class WorkspaceModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * Create a new workspace
+     */
+    create(data: {
+        name: string;
+        description?: string;
+        settings?: WorkspaceSettings;
+    }): Promise<ApiResponse<Workspace>>;
+    /**
+     * Get workspace by ID
+     */
+    getById(id: string): Promise<ApiResponse<Workspace>>;
+    /**
+     * Get all workspaces for current user
+     * Uses /api/v1/auth/workspaces which returns user's accessible workspaces
+     */
+    getAll(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<Workspace[]>>;
+    /**
+     * Update workspace
+     */
+    update(id: string, data: {
+        name?: string;
+        description?: string;
+        settings?: WorkspaceSettings;
+    }): Promise<ApiResponse<Workspace>>;
+    /**
+     * Delete workspace
+     */
+    delete(id: string): Promise<ApiResponse<void>>;
+}
+//# sourceMappingURL=workspace.d.ts.map

package/dist/modules/workspace.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceModule = void 0;
+class WorkspaceModule {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Create a new workspace
+     */
+    async create(data) {
+        return this.sdk.request("POST", "/api/v1/workspaces", data);
+    }
+    /**
+     * Get workspace by ID
+     */
+    async getById(id) {
+        return this.sdk.request("GET", `/api/v1/workspaces/${id}`);
+    }
+    /**
+     * Get all workspaces for current user
+     * Uses /api/v1/auth/workspaces which returns user's accessible workspaces
+     */
+    async getAll(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.page) {
+            queryParams.append("page", params.page.toString());
+        }
+        if (params?.limit) {
+            queryParams.append("limit", params.limit.toString());
+        }
+        const url = `/api/v1/auth/workspaces${queryParams.toString() ? `?${queryParams.toString()}` : ""}`;
+        return this.sdk.request("GET", url);
+    }
+    /**
+     * Update workspace
+     */
+    async update(id, data) {
+        return this.sdk.request("PATCH", `/api/v1/workspaces/${id}`, data);
+    }
+    /**
+     * Delete workspace
+     */
+    async delete(id) {
+        return this.sdk.request("DELETE", `/api/v1/workspaces/${id}`);
+    }
+}
+exports.WorkspaceModule = WorkspaceModule;
+//# sourceMappingURL=workspace.js.map

package/dist/types/api.d.ts

@@ -0,0 +1,4 @@
+export * from '../modules/workspace';
+export * from '../modules/auth';
+export * from '../modules/health';
+//# sourceMappingURL=api.d.ts.map

package/dist/types/api.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all types from modules
+__exportStar(require("../modules/workspace"), exports);
+__exportStar(require("../modules/auth"), exports);
+__exportStar(require("../modules/health"), exports);
+//# sourceMappingURL=api.js.map

package/dist/types/config.d.ts

@@ -0,0 +1,81 @@
+export interface ChanlConfig {
+    /** API base URL (e.g., 'https://api.chanl.ai' or 'http://localhost:18005') */
+    baseUrl: string;
+    /** Same as baseUrl — supported for tooling that uses `server` (e.g. local eval). */
+    server?: string;
+    /**
+     * When `local`, `/api/v1/...` paths are rewritten to the OSS server shape (`/scenarios`, etc.).
+     * When `cloud` or omitted, the platform `/api/v1` prefix is kept.
+     */
+    deployment?: 'local' | 'cloud';
+    /**
+     * Override API path prefix. Use `''` for a flat root (`/scenarios`). If set, takes precedence over `deployment`.
+     */
+    apiPrefix?: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** JWT token for authentication */
+    jwtToken?: string;
+    /** Auto-resolved from API key. Only needed for workspace-in-URL endpoints (audio, transcript). Set automatically — do not pass manually unless you know what you are doing. */
+    workspaceId?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom headers to include with all requests */
+    headers?: Record<string, string>;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Retry configuration */
+    retry?: {
+        maxRetries: number;
+        retryDelay: number;
+        backoffMultiplier: number;
+    };
+}
+export interface ChanlAuthConfig {
+    /** API key for authentication */
+    apiKey?: string;
+    /** JWT token for authentication */
+    jwtToken?: string;
+    /** User ID for user-specific operations */
+    userId?: string;
+}
+export interface RequestConfig {
+    /** Request timeout */
+    timeout?: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Whether to retry on failure */
+    retry?: boolean;
+}
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    message: string;
+    timestamp: string;
+    requestId?: string;
+}
+export interface PaginatedResponse<T = unknown> {
+    success: boolean;
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+    message: string;
+    timestamp: string;
+}
+export interface ApiError {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    timestamp: string;
+    requestId?: string;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/types/config.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config.js.map

package/dist/types/tool-calls.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Tool Call Types for @chanl/sdk
+ *
+ * Normalized tool call data returned by Chat, Scenarios, and Calls APIs.
+ */
+/**
+ * Tool call execution status
+ */
+export type ToolCallStatus = 'success' | 'error' | 'pending' | 'timeout';
+/**
+ * Structured error from a tool execution
+ */
+export interface ToolCallError {
+    /** Error code (e.g., 'TIMEOUT', 'NETWORK_ERROR') */
+    code?: string;
+    /** Human-readable error message */
+    message: string;
+    /** Additional error details (provider-specific) */
+    details?: unknown;
+}
+/**
+ * Normalized tool call record
+ *
+ * Consistent format returned by Chat, Scenarios, and Call transcript APIs.
+ * Contains the tool name, input parameters, execution result, timing, and status.
+ *
+ * @example
+ * ```typescript
+ * const response = await sdk.chat.sendMessage(wsId, sessionId, 'What is the weather?');
+ * for (const tc of response.data.toolCalls ?? []) {
+ *   console.log(`${tc.name}(${JSON.stringify(tc.parameters)}) → ${tc.status}`);
+ *   if (tc.durationMs) console.log(`  took ${tc.durationMs}ms`);
+ * }
+ * ```
+ */
+export interface ToolCall {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** Tool name (e.g., 'get_weather', 'kb_search') */
+    name: string;
+    /** Tool description (from tool definition) */
+    description?: string;
+    /** Input parameters passed to the tool */
+    parameters: Record<string, unknown>;
+    /** Tool execution result */
+    result?: unknown;
+    /** Execution status */
+    status: ToolCallStatus;
+    /** Execution duration in milliseconds */
+    durationMs?: number;
+    /** When the tool execution started (ISO timestamp) */
+    startedAt: string;
+    /** When the tool execution completed (ISO timestamp) */
+    completedAt?: string;
+    /** Seconds from call/session start (for timeline positioning) */
+    secondsFromStart?: number;
+    /** Structured error information (when status is 'error') */
+    error?: ToolCallError;
+}
+//# sourceMappingURL=tool-calls.d.ts.map

package/dist/types/tool-calls.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Tool Call Types for @chanl/sdk
+ *
+ * Normalized tool call data returned by Chat, Scenarios, and Calls APIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tool-calls.js.map

package/dist/types/tools.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Tool Types for @chanl/sdk
+ *
+ * TDD Phase: RED - These types define the contract for ToolsModule
+ * Based on chanl-api/src/tools/ schemas and DTOs
+ */
+export type ToolType = 'http' | 'javascript' | 'code';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'corrected';
+export type ExecutionSource = 'mcp' | 'api' | 'playground' | 'scheduled' | 'workflow';
+/**
+ * HTTP tool configuration for external API calls
+ */
+export interface HttpToolConfig {
+    /** HTTP method for the request */
+    method: HttpMethod;
+    /** URL template with {{variable}} placeholders */
+    url: string;
+    /** HTTP headers for the request */
+    headers?: Record<string, string>;
+    /** JSON body template with {{variable}} placeholders */
+    bodyTemplate?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * JavaScript tool configuration for sandboxed code execution
+ */
+export interface JavaScriptToolConfig {
+    /** JavaScript code to execute (sandboxed) */
+    code: string;
+    /** Allowed modules for execution */
+    allowedModules?: string[];
+}
+/**
+ * Code execution configuration for Python/JavaScript workers
+ */
+export interface CodeToolConfig {
+    /** Programming language */
+    language: 'python' | 'javascript';
+    /** Entry point function name */
+    entryPoint: string;
+    /** Cloudflare Worker name for execution */
+    workerName?: string;
+}
+/**
+ * Tool configuration - contains type-specific settings
+ */
+export interface ToolConfiguration {
+    http?: HttpToolConfig;
+    javascript?: JavaScriptToolConfig;
+    code?: CodeToolConfig;
+}
+/**
+ * Tool execution statistics
+ */
+export interface ToolStats {
+    totalCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    averageLatencyMs: number;
+    lastCalledAt?: string;
+}
+/**
+ * Tool entity representing an MCP-compatible tool
+ */
+export interface Tool {
+    /** Tool ID */
+    id: string;
+    /** Workspace ID this tool belongs to */
+    workspaceId: string;
+    /** Unique name for the tool (MCP tool name) */
+    name: string;
+    /** Description of what the tool does */
+    description: string;
+    /** Type of tool execution */
+    type: ToolType;
+    /** JSON Schema defining the tool input parameters */
+    inputSchema: Record<string, unknown>;
+    /** Tool configuration based on type */
+    configuration: ToolConfiguration;
+    /** Whether the tool is enabled */
+    isEnabled: boolean;
+    /** Tags for categorizing tools */
+    tags: string[];
+    /** User ID who created the tool */
+    createdBy: string;
+    /** User ID who last modified the tool */
+    lastModifiedBy?: string;
+    /** Execution statistics */
+    stats: ToolStats;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Input for creating a new tool
+ */
+export interface CreateToolInput {
+    /** Unique name for the tool (MCP tool name) */
+    name: string;
+    /** Description of what the tool does */
+    description: string;
+    /** Type of tool execution */
+    type: ToolType;
+    /** JSON Schema defining the tool input parameters */
+    inputSchema: Record<string, unknown>;
+    /** Tool configuration based on type */
+    configuration: ToolConfiguration;
+    /** Whether the tool is enabled (default: true) */
+    isEnabled?: boolean;
+    /** Tags for categorizing tools */
+    tags?: string[];
+}
+/**
+ * Input for updating an existing tool
+ */
+export interface UpdateToolInput {
+    /** Updated name */
+    name?: string;
+    /** Updated description */
+    description?: string;
+    /** Updated type */
+    type?: ToolType;
+    /** Updated input schema */
+    inputSchema?: Record<string, unknown>;
+    /** Updated configuration */
+    configuration?: ToolConfiguration;
+    /** Updated enabled status */
+    isEnabled?: boolean;
+    /** Updated tags */
+    tags?: string[];
+}
+/**
+ * Filters for listing tools
+ */
+export interface ToolFilters {
+    /** Filter by tool type */
+    type?: ToolType;
+    /** Filter by enabled status */
+    isEnabled?: boolean;
+    /** Search by name or description */
+    search?: string;
+    /** Filter by tag */
+    tag?: string;
+    /** Include system tools in results (default: true) */
+    includeSystem?: boolean;
+    /** Page number (1-indexed) */
+    page?: number;
+    /** Number of items per page (default: 20) */
+    limit?: number;
+    /** Sort field */
+    sortBy?: 'name' | 'createdAt' | 'updatedAt' | 'type';
+    /** Sort order */
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Correction record for input normalization
+ */
+export interface CorrectionRecord {
+    field: string;
+    original: unknown;
+    corrected: unknown;
+    rule: string;
+}
+/**
+ * Tool execution record
+ */
+export interface ToolExecution {
+    /** Execution ID */
+    id: string;
+    /** Tool ID that was executed */
+    toolId: string;
+    /** Workspace ID */
+    workspaceId: string;
+    /** User ID who triggered the execution */
+    userId?: string;
+    /** Source of the execution */
+    source: ExecutionSource;
+    /** Input arguments passed to the tool */
+    input: Record<string, unknown>;
+    /** Output from the tool execution */
+    output?: Record<string, unknown>;
+    /** Execution status */
+    status: ExecutionStatus;
+    /** Execution time in milliseconds */
+    executionTimeMs?: number;
+    /** Error message if execution failed */
+    errorMessage?: string;
+    /** Input corrections applied during normalization */
+    correctionsApplied?: CorrectionRecord[];
+    /** OpenTelemetry trace ID */
+    traceId?: string;
+    /** OpenTelemetry span ID */
+    spanId?: string;
+    /** When execution started */
+    startedAt?: string;
+    /** When execution completed */
+    completedAt?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Filters for listing executions
+ */
+export interface ExecutionFilters {
+    /** Filter by execution status */
+    status?: ExecutionStatus;
+    /** Filter by execution source */
+    source?: ExecutionSource;
+    /** Filter by start date */
+    fromDate?: string;
+    /** Filter by end date */
+    toDate?: string;
+    /** Page number (1-indexed) */
+    page?: number;
+    /** Number of items per page (default: 20) */
+    limit?: number;
+}
+/**
+ * Response for listing tools
+ */
+export interface ToolListResponse {
+    tools: Tool[];
+    total: number;
+    pagination: {
+        page: number;
+        limit: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+}
+/**
+ * Response for single tool operations
+ */
+export interface ToolResponse {
+    tool: Tool;
+}
+/**
+ * Response for tool deletion
+ */
+export interface ToolDeleteResponse {
+    deleted: boolean;
+}
+/**
+ * Real-time execution result (returned by execute/test endpoints)
+ * Different from ToolExecution which is a stored history record
+ */
+export interface ExecuteResult {
+    /** Whether the execution succeeded */
+    success: boolean;
+    /** The tool's output data */
+    data: unknown;
+    /** Execution time in milliseconds */
+    latencyMs: number;
+    /** OpenTelemetry trace ID */
+    traceId: string;
+    /** Execution record ID */
+    executionId: string;
+    /** Error message if execution failed */
+    error?: string;
+}
+/**
+ * Response for tool execution
+ * @deprecated Use ExecuteResult for real-time execution
+ */
+export interface ToolExecutionResponse {
+    execution: ToolExecution;
+}
+/**
+ * Response for listing executions
+ */
+export interface ExecutionListResponse {
+    data: ToolExecution[];
+    total: number;
+    page: number;
+    limit: number;
+    pagination: {
+        page: number;
+        limit: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+}
+/**
+ * Tool category (tag) with counts
+ */
+export interface ToolCategory {
+    /** Tag name */
+    tag: string;
+    /** Total count of tools with this tag */
+    count: number;
+    /** Count of enabled tools with this tag */
+    enabled: number;
+}
+/**
+ * Uncategorized tools count
+ */
+export interface UncategorizedCount {
+    /** Total count of tools without tags */
+    count: number;
+    /** Count of enabled tools without tags */
+    enabled: number;
+}
+/**
+ * Response for tool categories
+ */
+export interface ToolCategoriesResponse {
+    /** List of categories (tags) with counts */
+    categories: ToolCategory[];
+    /** Count of uncategorized tools */
+    uncategorized: UncategorizedCount;
+}
+//# sourceMappingURL=tools.d.ts.map

package/dist/types/tools.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Tool Types for @chanl/sdk
+ *
+ * TDD Phase: RED - These types define the contract for ToolsModule
+ * Based on chanl-api/src/tools/ schemas and DTOs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tools.js.map