@protoboxai/sdk 1.0.0

package/dist/modules/auth.d.ts

@@ -0,0 +1,76 @@
+import { ChanlSDK } from '../client';
+import { ApiResponse } from '../types/config';
+export interface ApiKey {
+    id: string;
+    name: string;
+    key: string;
+    workspaceId: string;
+    userId: string;
+    permissions: string[];
+    createdAt: string;
+    lastUsed?: string;
+}
+export interface CreateApiKeyRequest {
+    name: string;
+    workspaceId: string;
+    userId: string;
+    permissions?: string[];
+}
+export interface AuthTokenResponse {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    user: {
+        id: string;
+        email: string;
+        displayName?: string;
+    };
+    defaultWorkspaceId?: string;
+    workspaces?: Array<{
+        workspaceId: string;
+        name?: string;
+        role: string;
+    }>;
+}
+export declare class AuthModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * Exchange a Firebase ID token for platform JWT tokens.
+     * Used by CLI browser login flow.
+     */
+    exchangeFirebaseToken(firebaseToken: string): Promise<ApiResponse<AuthTokenResponse>>;
+    /**
+     * Refresh an access token using a refresh token.
+     */
+    refreshToken(refreshToken: string): Promise<ApiResponse<{
+        accessToken: string;
+        refreshToken: string;
+        expiresIn: number;
+    }>>;
+    /**
+     * Create a new API key
+     */
+    createApiKey(data: CreateApiKeyRequest): Promise<ApiResponse<ApiKey>>;
+    /**
+     * Get all API keys
+     */
+    getApiKeys(params?: {
+        workspaceId?: string;
+        userId?: string;
+    }): Promise<ApiResponse<ApiKey[]>>;
+    /**
+     * Revoke API key
+     */
+    revokeApiKey(keyId: string): Promise<ApiResponse<void>>;
+    /**
+     * Validate API key
+     */
+    validateApiKey(apiKey: string): Promise<ApiResponse<{
+        valid: boolean;
+        workspaceId?: string;
+        userId?: string;
+        permissions?: string[];
+    }>>;
+}
+//# sourceMappingURL=auth.d.ts.map

package/dist/modules/auth.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthModule = void 0;
+class AuthModule {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Exchange a Firebase ID token for platform JWT tokens.
+     * Used by CLI browser login flow.
+     */
+    async exchangeFirebaseToken(firebaseToken) {
+        return this.sdk.request('POST', '/api/v1/auth/firebase/exchange', {
+            firebaseToken,
+        });
+    }
+    /**
+     * Refresh an access token using a refresh token.
+     */
+    async refreshToken(refreshToken) {
+        return this.sdk.request('POST', '/api/v1/auth/token/refresh', {
+            refreshToken,
+        });
+    }
+    /**
+     * Create a new API key
+     */
+    async createApiKey(data) {
+        return this.sdk.request('POST', '/api/v1/auth/api-keys', data);
+    }
+    /**
+     * Get all API keys
+     */
+    async getApiKeys(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.workspaceId) {
+            queryParams.append('workspaceId', params.workspaceId);
+        }
+        if (params?.userId) {
+            queryParams.append('userId', params.userId);
+        }
+        const url = `/api/v1/auth/api-keys${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.sdk.request('GET', url);
+    }
+    /**
+     * Revoke API key
+     */
+    async revokeApiKey(keyId) {
+        return this.sdk.request('DELETE', `/api/v1/auth/api-keys/${keyId}`);
+    }
+    /**
+     * Validate API key
+     */
+    async validateApiKey(apiKey) {
+        return this.sdk.request('POST', '/api/v1/auth/validate', { apiKey });
+    }
+}
+exports.AuthModule = AuthModule;
+//# sourceMappingURL=auth.js.map

package/dist/modules/chat.d.ts

@@ -0,0 +1,164 @@
+/**
+ * ChatModule - SDK module for chat session management
+ *
+ * Provides operations for creating and managing text chat sessions
+ * with AI agents. This is the canonical way to test an agent via text:
+ * the platform owns the full lifecycle (interaction, transcript,
+ * billing, evaluation) so the SDK only deals with sessions and messages.
+ */
+import { ChanlSDK } from '../client';
+import { ApiResponse } from '../types/config';
+import { ToolCall } from '../types/tool-calls';
+export interface CreateChatSessionInput {
+    /** System prompt override */
+    systemPrompt?: string;
+    /** Variables for prompt substitution */
+    variables?: Record<string, string>;
+    /** Customer ID for memory retrieval */
+    customerId?: string;
+    /** HMAC hash for customer identity verification */
+    userHash?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Scorecard ID for post-chat evaluation (JWT only) */
+    scorecardId?: string;
+    /** Mark as internal/test interaction (JWT only) */
+    internal?: boolean;
+    /** How systemPrompt interacts with agent prompt (JWT only) */
+    promptOverrideMode?: 'replace' | 'prepend' | 'append';
+}
+export interface ChatSessionResponse {
+    interactionId: string;
+    sessionId: string;
+    agentId: string;
+    agentName?: string;
+    model?: string;
+    createdAt: string;
+}
+export interface ChatMessageResponse {
+    sessionId: string;
+    message: string;
+    toolCalls?: ToolCall[];
+    latencyMs?: number;
+}
+export interface ChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: string;
+}
+export interface ChatMessagesResponse {
+    sessionId: string;
+    messages: ChatMessage[];
+    toolCalls?: ToolCall[];
+}
+export interface EndChatResponse {
+    sessionId: string;
+    success: boolean;
+}
+export interface DeleteChatResponse {
+    deleted: boolean;
+    interactionId: string;
+}
+import { LiveChat } from '../live/live-chat';
+export declare class ChatModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * Create a new chat session with an agent
+     *
+     * The platform manages the session lifecycle including transcription,
+     * billing, and post-chat evaluation.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.createSession('ws_123', 'agent_abc', {
+     *   internal: true,
+     *   scorecardId: 'sc_456'
+     * });
+     * console.log('Session:', data.sessionId);
+     * ```
+     */
+    createSession(agentId: string, options?: CreateChatSessionInput): Promise<ApiResponse<ChatSessionResponse>>;
+    /**
+     * Send a message to an active chat session
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.sendMessage('ws_123', 'session_abc', 'Hello!');
+     * console.log('Reply:', data.message);
+     * ```
+     */
+    sendMessage(sessionId: string, message: string): Promise<ApiResponse<ChatMessageResponse>>;
+    /**
+     * Send a message and stream the response in real time.
+     *
+     * The backend uses Vercel AI SDK's `pipeTextStreamToResponse()` which
+     * sends raw UTF-8 text chunks (not SSE JSON). Each chunk is forwarded
+     * to the `onChunk` callback as it arrives.
+     *
+     * Note: Streaming returns `{ message, latencyMs }` only — tool calls
+     * and usage metadata are not available in the stream. Use `sendMessage()`
+     * for full metadata, or fetch message history after streaming completes.
+     *
+     * @example
+     * ```typescript
+     * const response = await sdk.chat.streamMessage('ws_123', 'session_abc', 'Hello!', (chunk) => {
+     *   process.stdout.write(chunk);
+     * });
+     * console.log('\nFull response:', response.data.message);
+     * ```
+     */
+    streamMessage(sessionId: string, message: string, onChunk: (text: string) => void): Promise<ApiResponse<ChatMessageResponse>>;
+    /**
+     * Get message history for a chat session
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.getMessages('ws_123', 'session_abc');
+     * data.messages.forEach(m => console.log(`${m.role}: ${m.content}`));
+     * ```
+     */
+    getMessages(sessionId: string): Promise<ApiResponse<ChatMessagesResponse>>;
+    /**
+     * End a chat session
+     *
+     * Finalizes the session, creating a transcript and triggering
+     * evaluation if a scorecard is configured.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.endSession('ws_123', 'session_abc');
+     * console.log('Ended:', data.success);
+     * ```
+     */
+    endSession(sessionId: string, options?: {
+        scorecardId?: string;
+    }): Promise<ApiResponse<EndChatResponse>>;
+    /**
+     * Delete a chat session and all associated data
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.deleteSession('ws_123', 'session_abc');
+     * console.log('Deleted:', data.deleted);
+     * ```
+     */
+    deleteSession(sessionId: string): Promise<ApiResponse<DeleteChatResponse>>;
+    /**
+     * Create a chat session and return a LiveChat wrapper
+     *
+     * Combines `createSession()` with event-driven messaging. The returned
+     * `LiveChat` emits events for messages and session lifecycle.
+     *
+     * @example
+     * ```typescript
+     * const chat = await sdk.chat.session('agent_abc');
+     * chat.on('message', (msg) => console.log('Agent:', msg.message));
+     *
+     * const reply = await chat.send('Hello!');
+     * await chat.end();
+     * ```
+     */
+    session(agentId: string, options?: CreateChatSessionInput): Promise<LiveChat>;
+}
+//# sourceMappingURL=chat.d.ts.map

package/dist/modules/chat.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * ChatModule - SDK module for chat session management
+ *
+ * Provides operations for creating and managing text chat sessions
+ * with AI agents. This is the canonical way to test an agent via text:
+ * the platform owns the full lifecycle (interaction, transcript,
+ * billing, evaluation) so the SDK only deals with sessions and messages.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatModule = void 0;
+// ============================================================================
+// MODULE
+// ============================================================================
+const live_chat_1 = require("../live/live-chat");
+class ChatModule {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Create a new chat session with an agent
+     *
+     * The platform manages the session lifecycle including transcription,
+     * billing, and post-chat evaluation.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.createSession('ws_123', 'agent_abc', {
+     *   internal: true,
+     *   scorecardId: 'sc_456'
+     * });
+     * console.log('Session:', data.sessionId);
+     * ```
+     */
+    async createSession(agentId, options) {
+        return this.sdk.request('POST', `/api/v1/interactions/chat?agentId=${encodeURIComponent(agentId)}`, options || {});
+    }
+    /**
+     * Send a message to an active chat session
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.sendMessage('ws_123', 'session_abc', 'Hello!');
+     * console.log('Reply:', data.message);
+     * ```
+     */
+    async sendMessage(sessionId, message) {
+        return this.sdk.request('POST', `/api/v1/interactions/${sessionId}/message`, { message });
+    }
+    /**
+     * Send a message and stream the response in real time.
+     *
+     * The backend uses Vercel AI SDK's `pipeTextStreamToResponse()` which
+     * sends raw UTF-8 text chunks (not SSE JSON). Each chunk is forwarded
+     * to the `onChunk` callback as it arrives.
+     *
+     * Note: Streaming returns `{ message, latencyMs }` only — tool calls
+     * and usage metadata are not available in the stream. Use `sendMessage()`
+     * for full metadata, or fetch message history after streaming completes.
+     *
+     * @example
+     * ```typescript
+     * const response = await sdk.chat.streamMessage('ws_123', 'session_abc', 'Hello!', (chunk) => {
+     *   process.stdout.write(chunk);
+     * });
+     * console.log('\nFull response:', response.data.message);
+     * ```
+     */
+    async streamMessage(sessionId, message, onChunk) {
+        const startTime = Date.now();
+        const response = await this.sdk.requestStream('POST', `/api/v1/interactions/${sessionId}/message?stream=true`, { message });
+        const body = response.body;
+        if (!body) {
+            throw new Error('No response body for stream');
+        }
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let fullText = '';
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value, { stream: true });
+                if (chunk) {
+                    fullText += chunk;
+                    onChunk(chunk);
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return {
+            success: true,
+            data: {
+                sessionId,
+                message: fullText,
+                latencyMs: Date.now() - startTime,
+            },
+            message: 'Success',
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Get message history for a chat session
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.getMessages('ws_123', 'session_abc');
+     * data.messages.forEach(m => console.log(`${m.role}: ${m.content}`));
+     * ```
+     */
+    async getMessages(sessionId) {
+        return this.sdk.request('GET', `/api/v1/interactions/${sessionId}/messages`);
+    }
+    /**
+     * End a chat session
+     *
+     * Finalizes the session, creating a transcript and triggering
+     * evaluation if a scorecard is configured.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.endSession('ws_123', 'session_abc');
+     * console.log('Ended:', data.success);
+     * ```
+     */
+    async endSession(sessionId, options) {
+        return this.sdk.request('POST', `/api/v1/interactions/${sessionId}/end`, options || {});
+    }
+    /**
+     * Delete a chat session and all associated data
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.chat.deleteSession('ws_123', 'session_abc');
+     * console.log('Deleted:', data.deleted);
+     * ```
+     */
+    async deleteSession(sessionId) {
+        return this.sdk.request('DELETE', `/api/v1/interactions/${sessionId}/chat`);
+    }
+    /**
+     * Create a chat session and return a LiveChat wrapper
+     *
+     * Combines `createSession()` with event-driven messaging. The returned
+     * `LiveChat` emits events for messages and session lifecycle.
+     *
+     * @example
+     * ```typescript
+     * const chat = await sdk.chat.session('agent_abc');
+     * chat.on('message', (msg) => console.log('Agent:', msg.message));
+     *
+     * const reply = await chat.send('Hello!');
+     * await chat.end();
+     * ```
+     */
+    async session(agentId, options) {
+        const response = await this.createSession(agentId, options);
+        if (!response.success || !response.data) {
+            throw new Error(response.message || 'Failed to create chat session');
+        }
+        return new live_chat_1.LiveChat(this.sdk, response.data);
+    }
+}
+exports.ChatModule = ChatModule;
+//# sourceMappingURL=chat.js.map

package/dist/modules/health.d.ts

@@ -0,0 +1,45 @@
+import { ChanlSDK } from '../client';
+import { ApiResponse } from '../types/config';
+export interface HealthStatus {
+    status: 'healthy' | 'unhealthy' | 'ok';
+    timestamp: string;
+    version: string;
+    uptime: number;
+}
+export interface DetailedHealthStatus {
+    status: 'healthy' | 'unhealthy' | 'ok';
+    timestamp: string;
+    version: string;
+    uptime: number;
+    components: {
+        database: {
+            status: 'healthy' | 'unhealthy';
+            responseTime: number;
+        };
+        redis?: {
+            status: 'healthy' | 'unhealthy';
+            responseTime: number;
+        };
+        deepgram?: {
+            status: 'healthy' | 'unhealthy';
+            responseTime: number;
+        };
+        openai?: {
+            status: 'healthy' | 'unhealthy';
+            responseTime: number;
+        };
+    };
+}
+export declare class HealthModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * Get basic health status
+     */
+    getHealth(): Promise<ApiResponse<HealthStatus>>;
+    /**
+     * Get detailed health status
+     */
+    getDetailedHealth(): Promise<ApiResponse<DetailedHealthStatus>>;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/modules/health.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthModule = void 0;
+class HealthModule {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Get basic health status
+     */
+    async getHealth() {
+        return this.sdk.request('GET', '/health');
+    }
+    /**
+     * Get detailed health status
+     */
+    async getDetailedHealth() {
+        return this.sdk.request('GET', '/health/ready');
+    }
+}
+exports.HealthModule = HealthModule;
+//# sourceMappingURL=health.js.map