crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/routes/api.llmcall.ts

@@ -0,0 +1,298 @@
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { streamText } from '~/lib/.server/llm/stream-text';
+import type { IProviderSetting, ProviderInfo } from '~/types/model';
+import { generateText } from 'ai';
+import { PROVIDER_LIST } from '~/utils/constants';
+import { MAX_TOKENS, PROVIDER_COMPLETION_LIMITS, isReasoningModel } from '~/lib/.server/llm/constants';
+import { LLMManager } from '~/lib/modules/llm/manager';
+import type { ModelInfo } from '~/lib/modules/llm/types';
+import { getApiKeysFromCookie, getProviderSettingsFromCookie } from '~/lib/api/cookies';
+import { createScopedLogger } from '~/utils/logger';
+
+export async function action(args: ActionFunctionArgs) {
+  return llmCallAction(args);
+}
+
+async function getModelList(options: {
+  apiKeys?: Record<string, string>;
+  providerSettings?: Record<string, IProviderSetting>;
+  serverEnv?: Record<string, string>;
+}) {
+  const llmManager = LLMManager.getInstance(import.meta.env);
+  return llmManager.updateModelList(options);
+}
+
+const logger = createScopedLogger('api.llmcall');
+
+function getCompletionTokenLimit(modelDetails: ModelInfo): number {
+  // 1. If model specifies completion tokens, use that
+  if (modelDetails.maxCompletionTokens && modelDetails.maxCompletionTokens > 0) {
+    return modelDetails.maxCompletionTokens;
+  }
+
+  // 2. Use provider-specific default
+  const providerDefault = PROVIDER_COMPLETION_LIMITS[modelDetails.provider];
+
+  if (providerDefault) {
+    return providerDefault;
+  }
+
+  // 3. Final fallback to MAX_TOKENS, but cap at reasonable limit for safety
+  return Math.min(MAX_TOKENS, 16384);
+}
+
+function validateTokenLimits(modelDetails: ModelInfo, requestedTokens: number): { valid: boolean; error?: string } {
+  const modelMaxTokens = modelDetails.maxTokenAllowed || 128000;
+  const maxCompletionTokens = getCompletionTokenLimit(modelDetails);
+
+  // Check against model's context window
+  if (requestedTokens > modelMaxTokens) {
+    return {
+      valid: false,
+      error: `Requested tokens (${requestedTokens}) exceed model's context window (${modelMaxTokens}). Please reduce your request size.`,
+    };
+  }
+
+  // Check against completion token limits
+  if (requestedTokens > maxCompletionTokens) {
+    return {
+      valid: false,
+      error: `Requested tokens (${requestedTokens}) exceed model's completion limit (${maxCompletionTokens}). Consider using a model with higher token limits.`,
+    };
+  }
+
+  return { valid: true };
+}
+
+async function llmCallAction({ context, request }: ActionFunctionArgs) {
+  const { system, message, model, provider, streamOutput } = await request.json<{
+    system: string;
+    message: string;
+    model: string;
+    provider: ProviderInfo;
+    streamOutput?: boolean;
+  }>();
+
+  const { name: providerName } = provider;
+
+  // validate 'model' and 'provider' fields
+  if (!model || typeof model !== 'string') {
+    throw new Response('Invalid or missing model', {
+      status: 400,
+      statusText: 'Bad Request',
+    });
+  }
+
+  if (!providerName || typeof providerName !== 'string') {
+    throw new Response('Invalid or missing provider', {
+      status: 400,
+      statusText: 'Bad Request',
+    });
+  }
+
+  const cookieHeader = request.headers.get('Cookie');
+  const apiKeys = getApiKeysFromCookie(cookieHeader);
+  const providerSettings = getProviderSettingsFromCookie(cookieHeader);
+
+  if (streamOutput) {
+    try {
+      const result = await streamText({
+        options: {
+          system,
+        },
+        messages: [
+          {
+            role: 'user',
+            content: `${message}`,
+          },
+        ],
+        env: context.cloudflare?.env as any,
+        apiKeys,
+        providerSettings,
+      });
+
+      return new Response(result.textStream, {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/plain; charset=utf-8',
+        },
+      });
+    } catch (error: unknown) {
+      console.log(error);
+
+      if (error instanceof Error && error.message?.includes('API key')) {
+        throw new Response('Invalid or missing API key', {
+          status: 401,
+          statusText: 'Unauthorized',
+        });
+      }
+
+      // Handle token limit errors with helpful messages
+      if (
+        error instanceof Error &&
+        (error.message?.includes('max_tokens') ||
+          error.message?.includes('token') ||
+          error.message?.includes('exceeds') ||
+          error.message?.includes('maximum'))
+      ) {
+        throw new Response(
+          `Token limit error: ${error.message}. Try reducing your request size or using a model with higher token limits.`,
+          {
+            status: 400,
+            statusText: 'Token Limit Exceeded',
+          },
+        );
+      }
+
+      throw new Response(null, {
+        status: 500,
+        statusText: 'Internal Server Error',
+      });
+    }
+  } else {
+    try {
+      const models = await getModelList({ apiKeys, providerSettings, serverEnv: context.cloudflare?.env as any });
+      const modelDetails = models.find((m: ModelInfo) => m.name === model);
+
+      if (!modelDetails) {
+        throw new Error('Model not found');
+      }
+
+      const dynamicMaxTokens = modelDetails ? getCompletionTokenLimit(modelDetails) : Math.min(MAX_TOKENS, 16384);
+
+      // Validate token limits before making API request
+      const validation = validateTokenLimits(modelDetails, dynamicMaxTokens);
+
+      if (!validation.valid) {
+        throw new Response(validation.error, {
+          status: 400,
+          statusText: 'Token Limit Exceeded',
+        });
+      }
+
+      const providerInfo = PROVIDER_LIST.find((p) => p.name === provider.name);
+
+      if (!providerInfo) {
+        throw new Error('Provider not found');
+      }
+
+      logger.info(`Generating response Provider: ${provider.name}, Model: ${modelDetails.name}`);
+
+      // DEBUG: Log reasoning model detection
+      const isReasoning = isReasoningModel(modelDetails.name);
+      logger.info(`DEBUG: Model "${modelDetails.name}" detected as reasoning model: ${isReasoning}`);
+
+      // Use maxCompletionTokens for reasoning models (o1, GPT-5), maxTokens for traditional models
+      const tokenParams = isReasoning ? { maxCompletionTokens: dynamicMaxTokens } : { maxTokens: dynamicMaxTokens };
+
+      // Filter out unsupported parameters for reasoning models
+      const baseParams = {
+        system,
+        messages: [
+          {
+            role: 'user' as const,
+            content: `${message}`,
+          },
+        ],
+        model: providerInfo.getModelInstance({
+          model: modelDetails.name,
+          serverEnv: context.cloudflare?.env as any,
+          apiKeys,
+          providerSettings,
+        }),
+        ...tokenParams,
+        toolChoice: 'none' as const,
+      };
+
+      // For reasoning models, set temperature to 1 (required by OpenAI API)
+      const finalParams = isReasoning
+        ? { ...baseParams, temperature: 1 } // Set to 1 for reasoning models (only supported value)
+        : { ...baseParams, temperature: 0 };
+
+      // DEBUG: Log final parameters
+      logger.info(
+        `DEBUG: Final params for model "${modelDetails.name}":`,
+        JSON.stringify(
+          {
+            isReasoning,
+            hasTemperature: 'temperature' in finalParams,
+            hasMaxTokens: 'maxTokens' in finalParams,
+            hasMaxCompletionTokens: 'maxCompletionTokens' in finalParams,
+            paramKeys: Object.keys(finalParams).filter((key) => !['model', 'messages', 'system'].includes(key)),
+            tokenParams,
+            finalParams: Object.fromEntries(
+              Object.entries(finalParams).filter(([key]) => !['model', 'messages', 'system'].includes(key)),
+            ),
+          },
+          null,
+          2,
+        ),
+      );
+
+      const result = await generateText(finalParams);
+      logger.info(`Generated response`);
+
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (error: unknown) {
+      console.log(error);
+
+      const errorResponse = {
+        error: true,
+        message: error instanceof Error ? error.message : 'An unexpected error occurred',
+        statusCode: (error as any).statusCode || 500,
+        isRetryable: (error as any).isRetryable !== false,
+        provider: (error as any).provider || 'unknown',
+      };
+
+      if (error instanceof Error && error.message?.includes('API key')) {
+        return new Response(
+          JSON.stringify({
+            ...errorResponse,
+            message: 'Invalid or missing API key',
+            statusCode: 401,
+            isRetryable: false,
+          }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+            statusText: 'Unauthorized',
+          },
+        );
+      }
+
+      // Handle token limit errors with helpful messages
+      if (
+        error instanceof Error &&
+        (error.message?.includes('max_tokens') ||
+          error.message?.includes('token') ||
+          error.message?.includes('exceeds') ||
+          error.message?.includes('maximum'))
+      ) {
+        return new Response(
+          JSON.stringify({
+            ...errorResponse,
+            message: `Token limit error: ${error.message}. Try reducing your request size or using a model with higher token limits.`,
+            statusCode: 400,
+            isRetryable: false,
+          }),
+          {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+            statusText: 'Token Limit Exceeded',
+          },
+        );
+      }
+
+      return new Response(JSON.stringify(errorResponse), {
+        status: errorResponse.statusCode,
+        headers: { 'Content-Type': 'application/json' },
+        statusText: 'Error',
+      });
+    }
+  }
+}

tools/bolt.diy/app/routes/api.mandate.ts

@@ -0,0 +1,351 @@
+/**
+ * Mandate API endpoint for autonomous code generation.
+ * 
+ * Receives structured mandates from CorporateSwarm and executes
+ * code generation cycles autonomously with governance oversight.
+ */
+
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { createScopedLogger } from '~/utils/logger';
+import type { Mandate, ExecutionResult } from '~/types/mandate';
+import { eventRegistry } from '~/lib/runtime/execution-events';
+import { createEventStreamResponse, broadcastEvent } from '~/lib/runtime/event-stream';
+
+const logger = createScopedLogger('api.mandate');
+
+/**
+ * Validate mandate structure and constraints.
+ */
+function validateMandate(mandate: Mandate): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Validate mandate_id
+  if (!mandate.mandate_id || typeof mandate.mandate_id !== 'string') {
+    errors.push('mandate_id is required and must be a string');
+  }
+
+  // Validate objectives
+  if (!Array.isArray(mandate.objectives) || mandate.objectives.length === 0) {
+    errors.push('objectives must be a non-empty array');
+  }
+
+  // Validate constraints
+  if (!mandate.constraints) {
+    errors.push('constraints are required');
+  } else {
+    if (mandate.constraints.maxDependencies < 0) {
+      errors.push('maxDependencies must be non-negative');
+    }
+    if (mandate.constraints.maxFileSize < 0) {
+      errors.push('maxFileSize must be non-negative');
+    }
+    if (mandate.constraints.maxFiles < 0) {
+      errors.push('maxFiles must be non-negative');
+    }
+  }
+
+  // Validate budget
+  if (!mandate.budget) {
+    errors.push('budget is required');
+  } else {
+    if (mandate.budget.token < 0) {
+      errors.push('budget.token must be non-negative');
+    }
+    if (mandate.budget.time < 0) {
+      errors.push('budget.time must be non-negative');
+    }
+    if (mandate.budget.cost < 0) {
+      errors.push('budget.cost must be non-negative');
+    }
+  }
+
+  // Validate deliverables
+  if (!Array.isArray(mandate.deliverables) || mandate.deliverables.length === 0) {
+    errors.push('deliverables must be a non-empty array');
+  }
+
+  // Validate iteration_config
+  if (!mandate.iteration_config) {
+    errors.push('iteration_config is required');
+  } else {
+    if (mandate.iteration_config.max_iterations < 1) {
+      errors.push('max_iterations must be at least 1');
+    }
+    if (
+      mandate.iteration_config.quality_threshold < 0 ||
+      mandate.iteration_config.quality_threshold > 1
+    ) {
+      errors.push('quality_threshold must be between 0 and 1');
+    }
+  }
+
+  // Validate deployment config if enabled
+  if (mandate.deployment?.enabled) {
+    if (!mandate.deployment.provider) {
+      errors.push('deployment.provider is required when deployment is enabled');
+    } else {
+      const validProviders = ['netlify', 'vercel', 'github', 'gitlab'];
+      if (!validProviders.includes(mandate.deployment.provider)) {
+        errors.push(`deployment.provider must be one of: ${validProviders.join(', ')}`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Main mandate action handler.
+ */
+export async function action(args: ActionFunctionArgs) {
+  return mandateAction(args);
+}
+
+async function mandateAction({ context, request }: ActionFunctionArgs) {
+  try {
+    // Parse mandate from request
+    const mandate: Mandate = await request.json();
+
+    logger.info(`Received mandate: ${mandate.mandate_id}`);
+
+    // Validate mandate
+    const validation = validateMandate(mandate);
+    if (!validation.valid) {
+      logger.error(`Mandate validation failed: ${validation.errors.join(', ')}`);
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: 'Invalid mandate',
+          errors: validation.errors,
+        }),
+        {
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    // Check if this is a request for event stream
+    const url = new URL(request.url);
+    const streamRequested = url.searchParams.get('stream') === 'true';
+
+    if (streamRequested) {
+      // Return event stream for real-time observability
+      return createEventStreamResponse(mandate.mandate_id);
+    }
+
+    // Check if Execution Governor is enabled
+    const governorEnabled = process.env.EXECUTION_GOVERNOR_ENABLED === 'true' || 
+                           process.env.EXECUTION_GOVERNOR_URL !== undefined;
+    const governorUrl = process.env.EXECUTION_GOVERNOR_URL || 'http://localhost:3000';
+
+    if (governorEnabled) {
+      // Forward mandate to Execution Governor
+      try {
+        logger.info(`Forwarding mandate ${mandate.mandate_id} to Execution Governor at ${governorUrl}`);
+        
+        const governorResponse = await fetch(`${governorUrl}/mandates`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(mandate),
+        });
+
+        if (!governorResponse.ok) {
+          const errorText = await governorResponse.text();
+          logger.error(`Governor rejected mandate: ${governorResponse.status} - ${errorText}`);
+          
+          // Fall back to direct execution if governor fails
+          logger.warn('Falling back to direct execution mode');
+        } else {
+          const governorData = await governorResponse.json() as { queue_position?: number; estimated_wait_time?: number };
+          logger.info(`Mandate ${mandate.mandate_id} queued in governor:`, governorData);
+
+          // Initialize event emitter for observability
+          const emitter = eventRegistry.getEmitter(mandate.mandate_id);
+          
+          // Store mandate for later retrieval
+          eventRegistry.storeMandate(mandate.mandate_id, mandate);
+          
+          emitter.emitLog('info', `Mandate ${mandate.mandate_id} queued in Execution Governor`, 'api');
+
+          return new Response(
+            JSON.stringify({
+              success: true,
+              mandate_id: mandate.mandate_id,
+              status: 'queued',
+              message: 'Mandate queued in Execution Governor',
+              queue_position: governorData.queue_position,
+              estimated_wait_time: governorData.estimated_wait_time,
+              event_stream_url: `/api/mandate?stream=true&mandate_id=${mandate.mandate_id}`,
+              governor_url: governorUrl,
+            }),
+            {
+              status: 202, // Accepted
+              headers: { 'Content-Type': 'application/json' },
+            }
+          );
+        }
+      } catch (error) {
+        logger.error('Error forwarding to governor, falling back to direct execution:', error);
+        // Fall through to direct execution
+      }
+    }
+
+    // Direct execution mode (fallback or when governor disabled)
+    // Initialize event emitter for this mandate
+    const emitter = eventRegistry.getEmitter(mandate.mandate_id);
+    
+    // Store mandate for later retrieval
+    eventRegistry.storeMandate(mandate.mandate_id, mandate);
+
+    // Emit initial acceptance event
+    emitter.emitIterationStart(0, {
+      model_used: 'pending',
+    });
+
+    emitter.emitLog('info', `Mandate ${mandate.mandate_id} accepted and queued for execution`, 'api');
+
+    // Note: Actual execution will be handled client-side where WebContainer is available
+    // The mandate is validated and accepted here, execution happens via client-side MandateExecutor
+    logger.info(`Mandate ${mandate.mandate_id} accepted, ready for client-side execution`);
+
+    return new Response(
+      JSON.stringify({
+        success: true,
+        mandate_id: mandate.mandate_id,
+        status: 'accepted',
+        message: 'Mandate accepted, execution started',
+        event_stream_url: `/api/mandate?stream=true&mandate_id=${mandate.mandate_id}`,
+      }),
+      {
+        status: 202, // Accepted
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  } catch (error: unknown) {
+    logger.error('Error processing mandate:', error);
+
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to process mandate',
+        message: errorMessage,
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+}
+
+/**
+ * GET handler for mandate status and event polling.
+ */
+export async function loader({ request }: ActionFunctionArgs) {
+  const url = new URL(request.url);
+  
+  // Check if this is a request for active mandates list (no mandate_id required)
+  if (url.searchParams.get('list') === 'true') {
+    const allMandateIds = eventRegistry.getActiveMandates();
+    const mandates = allMandateIds.slice(-10).reverse().map(mandateId => {
+      const emitter = eventRegistry.getEmitter(mandateId);
+      const events = emitter.getEvents();
+      const latestEvent = events[events.length - 1];
+      
+      return {
+        mandate_id: mandateId,
+        last_event_time: latestEvent?.timestamp || Date.now() / 1000,
+        event_count: events.length,
+        status: latestEvent?.type === 'iteration_end' ? 'completed' : 
+                latestEvent?.type === 'error' ? 'failed' :
+                events.length > 0 ? 'running' : 'accepted'
+      };
+    });
+
+    return new Response(
+      JSON.stringify({
+        mandates,
+        count: mandates.length,
+      }),
+      {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+
+  // For other requests, mandate_id is required
+  const mandateId = url.searchParams.get('mandate_id');
+
+  if (!mandateId) {
+    return new Response(
+      JSON.stringify({
+        error: 'mandate_id parameter is required (or use ?list=true for mandates list)',
+      }),
+      {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+
+  // Check if this is a request for the mandate object itself
+  if (url.searchParams.get('get') === 'true') {
+    const storedMandate = eventRegistry.getMandate(mandateId);
+    if (storedMandate) {
+      return new Response(
+        JSON.stringify({
+          mandate: storedMandate,
+        }),
+        {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    } else {
+      return new Response(
+        JSON.stringify({
+          error: 'Mandate not found',
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+  }
+
+  // Check if streaming is requested
+  const streamRequested = url.searchParams.get('stream') === 'true';
+  if (streamRequested) {
+    return createEventStreamResponse(mandateId);
+  }
+
+  // Return current events for polling
+  const { getMandateEvents, getMandateEventsSince } = await import('~/lib/runtime/event-stream');
+  const since = url.searchParams.get('since');
+  const events = since
+    ? getMandateEventsSince(mandateId, parseInt(since, 10))
+    : getMandateEvents(mandateId);
+
+  return new Response(
+    JSON.stringify({
+      mandate_id: mandateId,
+      events,
+      count: events.length,
+    }),
+    {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    }
+  );
+}
+

tools/bolt.diy/app/routes/api.mcp-check.ts

@@ -0,0 +1,16 @@
+import { createScopedLogger } from '~/utils/logger';
+import { MCPService } from '~/lib/services/mcpService';
+
+const logger = createScopedLogger('api.mcp-check');
+
+export async function loader() {
+  try {
+    const mcpService = MCPService.getInstance();
+    const serverTools = await mcpService.checkServersAvailabilities();
+
+    return Response.json(serverTools);
+  } catch (error) {
+    logger.error('Error checking MCP servers:', error);
+    return Response.json({ error: 'Failed to check MCP servers' }, { status: 500 });
+  }
+}

tools/bolt.diy/app/routes/api.mcp-update-config.ts

@@ -0,0 +1,23 @@
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { createScopedLogger } from '~/utils/logger';
+import { MCPService, type MCPConfig } from '~/lib/services/mcpService';
+
+const logger = createScopedLogger('api.mcp-update-config');
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const mcpConfig = (await request.json()) as MCPConfig;
+
+    if (!mcpConfig || typeof mcpConfig !== 'object') {
+      return Response.json({ error: 'Invalid MCP servers configuration' }, { status: 400 });
+    }
+
+    const mcpService = MCPService.getInstance();
+    const serverTools = await mcpService.updateConfig(mcpConfig);
+
+    return Response.json(serverTools);
+  } catch (error) {
+    logger.error('Error updating MCP config:', error);
+    return Response.json({ error: 'Failed to update MCP config' }, { status: 500 });
+  }
+}

tools/bolt.diy/app/routes/api.models.$provider.ts

@@ -0,0 +1,2 @@
+import { loader } from './api.models';
+export { loader };