@codeguide/core 0.0.27 → 0.0.29

package/codeguide.ts

@@ -18,6 +18,8 @@ import {
   CodespaceService,
   ExternalTokenService,
   SecurityKeysService,
+  UserService,
+  StarterKitsService,
 } from './services'
 import { APIServiceConfig, CodeGuideOptions } from './types'
 
@@ -33,6 +35,8 @@ export class CodeGuide {
   public codespace: CodespaceService
   public externalTokens: ExternalTokenService
   public securityKeys: SecurityKeysService
+  public users: UserService
+  public starterKits: StarterKitsService
   private options: CodeGuideOptions
 
   constructor(config: APIServiceConfig, options: CodeGuideOptions = {}) {
@@ -50,6 +54,8 @@ export class CodeGuide {
     this.codespace = new CodespaceService(config)
     this.externalTokens = new ExternalTokenService(config)
     this.securityKeys = new SecurityKeysService(config)
+    this.users = new UserService(config)
+    this.starterKits = new StarterKitsService(config)
   }
 
   // Convenience method for backward compatibility

package/dist/codeguide.d.ts

@@ -1,4 +1,4 @@
-import { GenerationService, ProjectService, UsageService, RepositoryAnalysisService, TaskService, ApiKeyEnhancedService, SubscriptionService, CancellationFunnelService, CodespaceService, ExternalTokenService, SecurityKeysService } from './services';
+import { GenerationService, ProjectService, UsageService, RepositoryAnalysisService, TaskService, ApiKeyEnhancedService, SubscriptionService, CancellationFunnelService, CodespaceService, ExternalTokenService, SecurityKeysService, UserService, StarterKitsService } from './services';
 import { APIServiceConfig, CodeGuideOptions } from './types';
 export declare class CodeGuide {
     generation: GenerationService;
@@ -12,6 +12,8 @@ export declare class CodeGuide {
     codespace: CodespaceService;
     externalTokens: ExternalTokenService;
     securityKeys: SecurityKeysService;
+    users: UserService;
+    starterKits: StarterKitsService;
     private options;
     constructor(config: APIServiceConfig, options?: CodeGuideOptions);
     getGuidance(prompt: string): Promise<any>;

package/dist/codeguide.js

@@ -27,6 +27,8 @@ class CodeGuide {
         this.codespace = new services_1.CodespaceService(config);
         this.externalTokens = new services_1.ExternalTokenService(config);
         this.securityKeys = new services_1.SecurityKeysService(config);
+        this.users = new services_1.UserService(config);
+        this.starterKits = new services_1.StarterKitsService(config);
     }
     // Convenience method for backward compatibility
     async getGuidance(prompt) {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { CodeGuide } from './codeguide';
 export * from './services';
 export * from './types';
-export type { ConnectRepositoryRequest, ConnectRepositoryResponse, ProjectRepository, GetProjectsRequest, PaginatedProjectsRequest, PaginatedProjectsResponse } from './services/projects/project-types';
-export type { CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest, CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, ModelApiKey, Attachment, GetCodespaceTaskResponse, CodespaceTaskData, TechnicalDocument, GetProjectTasksByCodespaceResponse } from './services/codespace/codespace-types';
-export type { StoreExternalTokenRequest, StoreExternalTokenResponse, ListTokensQuery, ListTokensResponse, ValidateTokenRequest, ValidateTokenResponse, FindBestMatchRequest, FindBestMatchResponse, Platform, TokenType } from './services/external-tokens/external-tokens-types';
+export type { ConnectRepositoryRequest, ConnectRepositoryResponse, ProjectRepository, GetProjectsRequest, PaginatedProjectsRequest, PaginatedProjectsResponse, } from './services/projects/project-types';
+export type { CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest, CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, ModelApiKey, Attachment, GetCodespaceTaskResponse, CodespaceTaskData, TechnicalDocument, GetProjectTasksByCodespaceResponse, } from './services/codespace/codespace-types';
+export type { StoreExternalTokenRequest, StoreExternalTokenResponse, ListTokensQuery, ListTokensResponse, ValidateTokenRequest, ValidateTokenResponse, FindBestMatchRequest, FindBestMatchResponse, Platform, TokenType, } from './services/external-tokens/external-tokens-types';
+export type { StarterKit, StarterKitMetadata, GetStarterKitsRequest, GetStarterKitsResponse, } from './services/starter-kits/starter-kits-types';

package/dist/services/base/base-service.d.ts

@@ -25,6 +25,27 @@ export declare abstract class BaseService {
     private formatErrorMessage;
     protected post<T>(url: string, data?: any, config?: any): Promise<T>;
     protected put<T>(url: string, data?: any, config?: any): Promise<T>;
+    protected patch<T>(url: string, data?: any, config?: any): Promise<T>;
     protected delete<T>(url: string, config?: any): Promise<T>;
     protected buildUrl(endpoint: string): string;
+    /**
+     * Create a streaming connection for Server-Sent Events (SSE)
+     *
+     * @param url - The endpoint URL for streaming
+     * @param config - Optional configuration for the stream request
+     * @returns Promise that resolves to EventSource for SSE streaming
+     */
+    protected createStream(url: string, config?: any): Promise<EventSource>;
+    /**
+     * Alternative streaming method using fetch for environments where EventSource is not available
+     * or when custom headers are needed for authentication
+     *
+     * @param url - The endpoint URL for streaming
+     * @param onMessage - Callback function for handling stream messages
+     * @param onError - Callback function for handling stream errors
+     * @param onComplete - Callback function for when stream completes
+     * @param config - Optional configuration for the stream request
+     * @returns Promise that resolves to a cleanup function
+     */
+    protected createStreamWithFetch(url: string, onMessage: (data: any) => void, onError?: (error: any) => void, onComplete?: () => void, config?: any): Promise<() => void>;
 }

package/dist/services/base/base-service.js

@@ -192,6 +192,10 @@ class BaseService {
         const response = await this.client.put(url, data, config);
         return response.data;
     }
+    async patch(url, data, config) {
+        const response = await this.client.patch(url, data, config);
+        return response.data;
+    }
     async delete(url, config) {
         const response = await this.client.delete(url, config);
         return response.data;
@@ -199,5 +203,115 @@ class BaseService {
     buildUrl(endpoint) {
         return endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
     }
+    /**
+     * Create a streaming connection for Server-Sent Events (SSE)
+     *
+     * @param url - The endpoint URL for streaming
+     * @param config - Optional configuration for the stream request
+     * @returns Promise that resolves to EventSource for SSE streaming
+     */
+    async createStream(url, config) {
+        // Build full URL
+        const fullUrl = `${this.client.defaults.baseURL}${this.buildUrl(url)}`;
+        // For SSE, we need to use EventSource API directly
+        // However, we need to handle authentication differently since EventSource doesn't support custom headers
+        // We'll pass auth info as query parameters for SSE endpoints
+        return new Promise((resolve, reject) => {
+            try {
+                const eventSource = new EventSource(fullUrl);
+                resolve(eventSource);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Alternative streaming method using fetch for environments where EventSource is not available
+     * or when custom headers are needed for authentication
+     *
+     * @param url - The endpoint URL for streaming
+     * @param onMessage - Callback function for handling stream messages
+     * @param onError - Callback function for handling stream errors
+     * @param onComplete - Callback function for when stream completes
+     * @param config - Optional configuration for the stream request
+     * @returns Promise that resolves to a cleanup function
+     */
+    async createStreamWithFetch(url, onMessage, onError, onComplete, config) {
+        const streamConfig = {
+            ...config,
+            headers: {
+                ...this.client.defaults.headers,
+                'Accept': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                ...config?.headers,
+            },
+        };
+        const fullUrl = `${this.client.defaults.baseURL}${this.buildUrl(url)}`;
+        try {
+            const response = await fetch(fullUrl, streamConfig);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Response body is not readable');
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            const processStream = async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            onComplete?.();
+                            break;
+                        }
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                        for (const line of lines) {
+                            if (line.startsWith('data: ')) {
+                                const data = line.slice(6); // Remove 'data: ' prefix
+                                if (data.trim()) {
+                                    try {
+                                        const parsedData = JSON.parse(data);
+                                        onMessage(parsedData);
+                                    }
+                                    catch (parseError) {
+                                        console.warn('Failed to parse SSE data:', data, parseError);
+                                    }
+                                }
+                            }
+                            else if (line.startsWith('event: ')) {
+                                const eventType = line.slice(7); // Remove 'event: ' prefix
+                                // Handle different event types if needed
+                                if (eventType === 'complete') {
+                                    onComplete?.();
+                                    return;
+                                }
+                                else if (eventType === 'error') {
+                                    onError?.(new Error('Stream error event received'));
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    onError?.(error);
+                }
+            };
+            processStream();
+            // Return cleanup function
+            return () => {
+                reader.cancel().catch(console.warn);
+            };
+        }
+        catch (error) {
+            onError?.(error);
+            return () => { }; // Return empty cleanup function on error
+        }
+    }
 }
 exports.BaseService = BaseService;

package/dist/services/codespace/codespace-service.d.ts

@@ -1,5 +1,5 @@
 import { BaseService } from '../base/base-service';
-import { GenerateTaskTitleRequest, GenerateTaskTitleResponse, CreateCodespaceTaskRequest, CreateCodespaceTaskResponse, CreateCodespaceTaskRequestV2, CreateCodespaceTaskResponseV2, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, GetCodespaceTaskResponse, GetProjectTasksByCodespaceResponse, GetCodespaceTasksByProjectRequest, GetCodespaceTasksByProjectResponse, CodespaceTaskDetailedResponse, CodespaceQuestionnaireRequest, CodespaceQuestionnaireResponse, GetCodespaceModelsQuery, GetCodespaceModelsResponse, GetCodespaceModelResponse, GetLLMModelProvidersResponse, GetLLMModelProviderResponse, GetModelsByProviderResponse } from './codespace-types';
+import { GenerateTaskTitleRequest, GenerateTaskTitleResponse, CreateCodespaceTaskRequest, CreateCodespaceTaskResponse, CreateCodespaceTaskRequestV2, CreateCodespaceTaskResponseV2, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, GetCodespaceTaskResponse, GetProjectTasksByCodespaceResponse, GetCodespaceTasksByProjectRequest, GetCodespaceTasksByProjectResponse, CodespaceTaskDetailedResponse, CodespaceQuestionnaireRequest, CodespaceQuestionnaireResponse, GetCodespaceModelsQuery, GetCodespaceModelsResponse, GetCodespaceModelResponse, GetLLMModelProvidersResponse, GetLLMModelProviderResponse, GetModelsByProviderResponse, GetCodespaceTasksRequest, GetCodespaceTasksResponse, GetTasksByCodespaceIdRequest, GetTasksByCodespaceIdResponse, UpdateFinalReportPopupStateRequest, UpdateFinalReportPopupStateResponse, GetCodespaceTaskLogsRequest, CodespaceTaskLogsResponse, StreamCodespaceTaskLogsRequest, CodespaceLogStreamEvent } from './codespace-types';
 export declare class CodespaceService extends BaseService {
     generateTaskTitle(request: GenerateTaskTitleRequest): Promise<GenerateTaskTitleResponse>;
     generateQuestionnaire(request: CodespaceQuestionnaireRequest): Promise<CodespaceQuestionnaireResponse>;
@@ -10,6 +10,57 @@ export declare class CodespaceService extends BaseService {
     getProjectTasksByCodespace(codespaceTaskId: string): Promise<GetProjectTasksByCodespaceResponse>;
     getCodespaceTasksByProject(params: GetCodespaceTasksByProjectRequest): Promise<GetCodespaceTasksByProjectResponse>;
     getCodespaceTaskDetailed(codespaceTaskId: string): Promise<CodespaceTaskDetailedResponse>;
+    /**
+     * Get tasks by codespace task ID with optional pagination and sorting
+     *
+     * GET /tasks/by-codespace-id/{codespace_task_id}
+     *
+     * @param params - Request parameters including codespace_task_id and optional pagination/sorting
+     * @returns Promise resolving to paginated list of tasks associated with the codespace task ID
+     */
+    getTasksByCodespaceId(params: GetTasksByCodespaceIdRequest): Promise<GetTasksByCodespaceIdResponse>;
+    /**
+     * Get codespace tasks with optional filtering and pagination
+     *
+     * GET /codespace/tasks
+     *
+     * @param params - Optional query parameters for filtering, sorting, and pagination
+     * @returns Promise resolving to paginated list of codespace tasks with model and attachment info
+     */
+    getCodespaceTasks(params?: GetCodespaceTasksRequest): Promise<GetCodespaceTasksResponse>;
+    /**
+     * Update the final report popup state for a codespace task
+     *
+     * PATCH /task/{codespace_task_id}/final-report-popup-state
+     *
+     * @param codespaceTaskId - The ID of the codespace task
+     * @param request - The request body containing the new popup state
+     * @returns Promise resolving to the updated popup state response
+     */
+    updateFinalReportPopupState(codespaceTaskId: string, request: UpdateFinalReportPopupStateRequest): Promise<UpdateFinalReportPopupStateResponse>;
+    /**
+     * Get paginated logs for a codespace task with optional filtering and sorting
+     *
+     * GET /codespace/task/{codespace_task_id}/logs
+     *
+     * @param request - Request parameters including codespace_task_id and optional filters
+     * @returns Promise resolving to paginated logs response
+     */
+    getCodespaceTaskLogs(request: GetCodespaceTaskLogsRequest): Promise<CodespaceTaskLogsResponse>;
+    /**
+     * Stream real-time logs from a codespace task using Server-Sent Events (SSE)
+     *
+     * GET /codespace/task/{codespace_task_id}/logs/stream
+     *
+     * @param request - Request parameters including codespace_task_id and optional streaming parameters
+     * @param onLog - Callback function for handling log events
+     * @param onHeartbeat - Callback function for handling heartbeat events
+     * @param onComplete - Callback function for handling completion events
+     * @param onError - Callback function for handling error events
+     * @param onTimeout - Callback function for handling timeout events
+     * @returns Promise resolving to a cleanup function to stop streaming
+     */
+    streamCodespaceTaskLogs(request: StreamCodespaceTaskLogsRequest, onLog: (log: CodespaceLogStreamEvent) => void, onHeartbeat?: (data: any) => void, onComplete?: (data: any) => void, onError?: (error: any) => void, onTimeout?: (data: any) => void): Promise<() => void>;
     /**
      * Get all codespace models with optional filtering
      *
@@ -63,4 +114,7 @@ export declare class CodespaceService extends BaseService {
     private buildQueryParams;
     private validateCodespaceTaskRequest;
     private validateQuestionnaireRequest;
+    private validateGetLogsRequest;
+    private validateStreamLogsRequest;
+    private validateGetTasksByCodespaceIdRequest;
 }

package/dist/services/codespace/codespace-service.js

@@ -57,6 +57,167 @@ class CodespaceService extends base_service_1.BaseService {
         }
         return this.get(`/codespace/task/${codespaceTaskId}/detailed`);
     }
+    /**
+     * Get tasks by codespace task ID with optional pagination and sorting
+     *
+     * GET /tasks/by-codespace-id/{codespace_task_id}
+     *
+     * @param params - Request parameters including codespace_task_id and optional pagination/sorting
+     * @returns Promise resolving to paginated list of tasks associated with the codespace task ID
+     */
+    async getTasksByCodespaceId(params) {
+        this.validateGetTasksByCodespaceIdRequest(params);
+        const queryParams = new URLSearchParams();
+        // Add pagination parameters
+        if (params.limit !== undefined) {
+            queryParams.append('limit', params.limit.toString());
+        }
+        if (params.offset !== undefined) {
+            queryParams.append('offset', params.offset.toString());
+        }
+        // Add sorting parameters
+        if (params.sort_by) {
+            queryParams.append('sort_by', params.sort_by);
+        }
+        if (params.sort_order) {
+            queryParams.append('sort_order', params.sort_order);
+        }
+        const url = `/tasks/by-codespace-id/${params.codespace_task_id}${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    /**
+     * Get codespace tasks with optional filtering and pagination
+     *
+     * GET /codespace/tasks
+     *
+     * @param params - Optional query parameters for filtering, sorting, and pagination
+     * @returns Promise resolving to paginated list of codespace tasks with model and attachment info
+     */
+    async getCodespaceTasks(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.task_status)
+            queryParams.append('task_status', params.task_status);
+        if (params?.project_id)
+            queryParams.append('project_id', params.project_id);
+        if (params?.limit !== undefined) {
+            // Validate limit is between 1 and 100
+            if (params.limit < 1 || params.limit > 100) {
+                throw new Error('limit must be between 1 and 100');
+            }
+            queryParams.append('limit', params.limit.toString());
+        }
+        if (params?.offset !== undefined) {
+            // Validate offset is non-negative
+            if (params.offset < 0) {
+                throw new Error('offset must be 0 or greater');
+            }
+            queryParams.append('offset', params.offset.toString());
+        }
+        if (params?.sort_by)
+            queryParams.append('sort_by', params.sort_by);
+        if (params?.sort_order)
+            queryParams.append('sort_order', params.sort_order);
+        const url = `/codespace/tasks${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    // ============================================================================
+    // Task Status Update Methods
+    // ============================================================================
+    /**
+     * Update the final report popup state for a codespace task
+     *
+     * PATCH /task/{codespace_task_id}/final-report-popup-state
+     *
+     * @param codespaceTaskId - The ID of the codespace task
+     * @param request - The request body containing the new popup state
+     * @returns Promise resolving to the updated popup state response
+     */
+    async updateFinalReportPopupState(codespaceTaskId, request) {
+        if (!codespaceTaskId) {
+            throw new Error('codespace_task_id is required');
+        }
+        // Validate the popup state value
+        if (!['not_ready', 'open', 'closed'].includes(request.final_report_popup_state)) {
+            throw new Error('final_report_popup_state must be "not_ready", "open", or "closed"');
+        }
+        return this.patch(`/task/${codespaceTaskId}/final-report-popup-state`, request);
+    }
+    // ============================================================================
+    // Codespace Task Logs Methods
+    // ============================================================================
+    /**
+     * Get paginated logs for a codespace task with optional filtering and sorting
+     *
+     * GET /codespace/task/{codespace_task_id}/logs
+     *
+     * @param request - Request parameters including codespace_task_id and optional filters
+     * @returns Promise resolving to paginated logs response
+     */
+    async getCodespaceTaskLogs(request) {
+        this.validateGetLogsRequest(request);
+        const queryParams = new URLSearchParams();
+        // Add pagination parameters
+        if (request.limit !== undefined) {
+            queryParams.append('limit', request.limit.toString());
+        }
+        if (request.offset !== undefined) {
+            queryParams.append('offset', request.offset.toString());
+        }
+        // Add filter parameters
+        if (request.log_type) {
+            queryParams.append('log_type', request.log_type);
+        }
+        if (request.step_name) {
+            queryParams.append('step_name', request.step_name);
+        }
+        if (request.search) {
+            queryParams.append('search', request.search);
+        }
+        if (request.since) {
+            queryParams.append('since', request.since);
+        }
+        // Add sorting parameters
+        if (request.sort_by) {
+            queryParams.append('sort_by', request.sort_by);
+        }
+        if (request.sort_order) {
+            queryParams.append('sort_order', request.sort_order);
+        }
+        const url = `/codespace/task/${request.codespace_task_id}/logs${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    /**
+     * Stream real-time logs from a codespace task using Server-Sent Events (SSE)
+     *
+     * GET /codespace/task/{codespace_task_id}/logs/stream
+     *
+     * @param request - Request parameters including codespace_task_id and optional streaming parameters
+     * @param onLog - Callback function for handling log events
+     * @param onHeartbeat - Callback function for handling heartbeat events
+     * @param onComplete - Callback function for handling completion events
+     * @param onError - Callback function for handling error events
+     * @param onTimeout - Callback function for handling timeout events
+     * @returns Promise resolving to a cleanup function to stop streaming
+     */
+    async streamCodespaceTaskLogs(request, onLog, onHeartbeat, onComplete, onError, onTimeout) {
+        this.validateStreamLogsRequest(request);
+        const queryParams = new URLSearchParams();
+        // Add streaming parameters
+        if (request.since) {
+            queryParams.append('since', request.since);
+        }
+        if (request.timeout !== undefined) {
+            queryParams.append('timeout', request.timeout.toString());
+        }
+        const url = `/codespace/task/${request.codespace_task_id}/logs/stream${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        // Use the fetch-based streaming method since it supports custom headers for authentication
+        return this.createStreamWithFetch(url, data => {
+            // Handle different types of events based on the context
+            // The server will send different event types through the same data channel
+            onLog(data);
+        }, onError, () => onComplete?.({}) // Call onComplete with empty data when stream completes
+        );
+    }
     // ============================================================================
     // Codespace Models Methods
     // ============================================================================
@@ -70,9 +231,7 @@ class CodespaceService extends base_service_1.BaseService {
      */
     async getCodespaceModels(query) {
         const params = this.buildQueryParams(query);
-        const url = params
-            ? `/api/codespace-models/models?${params}`
-            : '/api/codespace-models/models';
+        const url = params ? `/api/codespace-models/models?${params}` : '/api/codespace-models/models';
         return this.get(url);
     }
     /**
@@ -152,8 +311,8 @@ class CodespaceService extends base_service_1.BaseService {
             throw new Error('task_description is required');
         }
         if (request.execution_mode &&
-            !['implementation', 'docs-only'].includes(request.execution_mode)) {
-            throw new Error('execution_mode must be either "implementation" or "docs-only"');
+            !['implementation', 'docs-only', 'direct'].includes(request.execution_mode)) {
+            throw new Error('execution_mode must be either "implementation", "docs-only", or "direct"');
         }
         // Validate model_api_keys if provided
         if (request.model_api_keys) {
@@ -219,5 +378,101 @@ class CodespaceService extends base_service_1.BaseService {
             }
         }
     }
+    validateGetLogsRequest(request) {
+        if (!request.codespace_task_id) {
+            throw new Error('codespace_task_id is required');
+        }
+        // Validate limit
+        if (request.limit !== undefined) {
+            if (!Number.isInteger(request.limit)) {
+                throw new Error('limit must be an integer');
+            }
+            if (request.limit < 1 || request.limit > 500) {
+                throw new Error('limit must be between 1 and 500');
+            }
+        }
+        // Validate offset
+        if (request.offset !== undefined) {
+            if (!Number.isInteger(request.offset)) {
+                throw new Error('offset must be an integer');
+            }
+            if (request.offset < 0) {
+                throw new Error('offset must be 0 or greater');
+            }
+        }
+        // Validate sort_by
+        if (request.sort_by && !['created_at', 'step_name', 'log_type'].includes(request.sort_by)) {
+            throw new Error('sort_by must be one of: created_at, step_name, log_type');
+        }
+        // Validate sort_order
+        if (request.sort_order && !['asc', 'desc'].includes(request.sort_order)) {
+            throw new Error('sort_order must be either "asc" or "desc"');
+        }
+        // Validate log_type
+        const validLogTypes = ['thinking', 'coding', 'info', 'error', 'success'];
+        if (request.log_type && !validLogTypes.includes(request.log_type)) {
+            throw new Error(`log_type must be one of: ${validLogTypes.join(', ')}`);
+        }
+        // Validate since timestamp format (basic ISO format check)
+        if (request.since) {
+            const sinceDate = new Date(request.since);
+            if (isNaN(sinceDate.getTime())) {
+                throw new Error('since must be a valid ISO timestamp');
+            }
+        }
+    }
+    validateStreamLogsRequest(request) {
+        if (!request.codespace_task_id) {
+            throw new Error('codespace_task_id is required');
+        }
+        // Validate timeout
+        if (request.timeout !== undefined) {
+            if (!Number.isInteger(request.timeout)) {
+                throw new Error('timeout must be an integer');
+            }
+            if (request.timeout < 30 || request.timeout > 1800) {
+                throw new Error('timeout must be between 30 and 1800 seconds');
+            }
+        }
+        // Validate since timestamp format (basic ISO format check)
+        if (request.since) {
+            const sinceDate = new Date(request.since);
+            if (isNaN(sinceDate.getTime())) {
+                throw new Error('since must be a valid ISO timestamp');
+            }
+        }
+    }
+    validateGetTasksByCodespaceIdRequest(request) {
+        if (!request.codespace_task_id) {
+            throw new Error('codespace_task_id is required');
+        }
+        // Validate limit
+        if (request.limit !== undefined) {
+            if (!Number.isInteger(request.limit)) {
+                throw new Error('limit must be an integer');
+            }
+            if (request.limit < 1 || request.limit > 100) {
+                throw new Error('limit must be between 1 and 100');
+            }
+        }
+        // Validate offset
+        if (request.offset !== undefined) {
+            if (!Number.isInteger(request.offset)) {
+                throw new Error('offset must be an integer');
+            }
+            if (request.offset < 0) {
+                throw new Error('offset must be 0 or greater');
+            }
+        }
+        // Validate sort_by
+        if (request.sort_by &&
+            !['created_at', 'updated_at', 'status', 'title'].includes(request.sort_by)) {
+            throw new Error('sort_by must be one of: created_at, updated_at, status, title');
+        }
+        // Validate sort_order
+        if (request.sort_order && !['asc', 'desc'].includes(request.sort_order)) {
+            throw new Error('sort_order must be either "asc" or "desc"');
+        }
+    }
 }
 exports.CodespaceService = CodespaceService;