crca 1.4.0__py3-none-any.whl

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

@@ -0,0 +1,463 @@
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { createDataStream, generateId } from 'ai';
+import { MAX_RESPONSE_SEGMENTS, MAX_TOKENS, type FileMap } from '~/lib/.server/llm/constants';
+import { CONTINUE_PROMPT } from '~/lib/common/prompts/prompts';
+import { streamText, type Messages, type StreamingOptions } from '~/lib/.server/llm/stream-text';
+import SwitchableStream from '~/lib/.server/llm/switchable-stream';
+import type { IProviderSetting } from '~/types/model';
+import { createScopedLogger } from '~/utils/logger';
+import { getFilePaths, selectContext } from '~/lib/.server/llm/select-context';
+import type { ContextAnnotation, ProgressAnnotation } from '~/types/context';
+import { WORK_DIR } from '~/utils/constants';
+import { createSummary } from '~/lib/.server/llm/create-summary';
+import { extractPropertiesFromMessage } from '~/lib/.server/llm/utils';
+import type { DesignScheme } from '~/types/design-scheme';
+import { MCPService } from '~/lib/services/mcpService';
+import { StreamRecoveryManager } from '~/lib/.server/llm/stream-recovery';
+
+export async function action(args: ActionFunctionArgs) {
+  return chatAction(args);
+}
+
+const logger = createScopedLogger('api.chat');
+
+function parseCookies(cookieHeader: string): Record<string, string> {
+  const cookies: Record<string, string> = {};
+
+  const items = cookieHeader.split(';').map((cookie) => cookie.trim());
+
+  items.forEach((item) => {
+    const [name, ...rest] = item.split('=');
+
+    if (name && rest) {
+      const decodedName = decodeURIComponent(name.trim());
+      const decodedValue = decodeURIComponent(rest.join('=').trim());
+      cookies[decodedName] = decodedValue;
+    }
+  });
+
+  return cookies;
+}
+
+async function chatAction({ context, request }: ActionFunctionArgs) {
+  const streamRecovery = new StreamRecoveryManager({
+    timeout: 45000,
+    maxRetries: 2,
+    onTimeout: () => {
+      logger.warn('Stream timeout - attempting recovery');
+    },
+  });
+
+  const { messages, files, promptId, contextOptimization, supabase, chatMode, designScheme, maxLLMSteps } =
+    await request.json<{
+      messages: Messages;
+      files: any;
+      promptId?: string;
+      contextOptimization: boolean;
+      chatMode: 'discuss' | 'build';
+      designScheme?: DesignScheme;
+      supabase?: {
+        isConnected: boolean;
+        hasSelectedProject: boolean;
+        credentials?: {
+          anonKey?: string;
+          supabaseUrl?: string;
+        };
+      };
+      maxLLMSteps: number;
+    }>();
+
+  const cookieHeader = request.headers.get('Cookie');
+  const apiKeys = JSON.parse(parseCookies(cookieHeader || '').apiKeys || '{}');
+  const providerSettings: Record<string, IProviderSetting> = JSON.parse(
+    parseCookies(cookieHeader || '').providers || '{}',
+  );
+
+  const stream = new SwitchableStream();
+
+  const cumulativeUsage = {
+    completionTokens: 0,
+    promptTokens: 0,
+    totalTokens: 0,
+  };
+  const encoder: TextEncoder = new TextEncoder();
+  let progressCounter: number = 1;
+
+  try {
+    const mcpService = MCPService.getInstance();
+    const totalMessageContent = messages.reduce((acc, message) => acc + message.content, '');
+    logger.debug(`Total message length: ${totalMessageContent.split(' ').length}, words`);
+
+    let lastChunk: string | undefined = undefined;
+
+    const dataStream = createDataStream({
+      async execute(dataStream) {
+        streamRecovery.startMonitoring();
+
+        const filePaths = getFilePaths(files || {});
+        let filteredFiles: FileMap | undefined = undefined;
+        let summary: string | undefined = undefined;
+        let messageSliceId = 0;
+
+        const processedMessages = await mcpService.processToolInvocations(messages, dataStream);
+
+        if (processedMessages.length > 3) {
+          messageSliceId = processedMessages.length - 3;
+        }
+
+        if (filePaths.length > 0 && contextOptimization) {
+          logger.debug('Generating Chat Summary');
+          dataStream.writeData({
+            type: 'progress',
+            label: 'summary',
+            status: 'in-progress',
+            order: progressCounter++,
+            message: 'Analysing Request',
+          } satisfies ProgressAnnotation);
+
+          // Create a summary of the chat
+          console.log(`Messages count: ${processedMessages.length}`);
+
+          summary = await createSummary({
+            messages: [...processedMessages],
+            env: context.cloudflare?.env,
+            apiKeys,
+            providerSettings,
+            promptId,
+            contextOptimization,
+            onFinish(resp) {
+              if (resp.usage) {
+                logger.debug('createSummary token usage', JSON.stringify(resp.usage));
+                cumulativeUsage.completionTokens += resp.usage.completionTokens || 0;
+                cumulativeUsage.promptTokens += resp.usage.promptTokens || 0;
+                cumulativeUsage.totalTokens += resp.usage.totalTokens || 0;
+              }
+            },
+          });
+          dataStream.writeData({
+            type: 'progress',
+            label: 'summary',
+            status: 'complete',
+            order: progressCounter++,
+            message: 'Analysis Complete',
+          } satisfies ProgressAnnotation);
+
+          dataStream.writeMessageAnnotation({
+            type: 'chatSummary',
+            summary,
+            chatId: processedMessages.slice(-1)?.[0]?.id,
+          } as ContextAnnotation);
+
+          // Update context buffer
+          logger.debug('Updating Context Buffer');
+          dataStream.writeData({
+            type: 'progress',
+            label: 'context',
+            status: 'in-progress',
+            order: progressCounter++,
+            message: 'Determining Files to Read',
+          } satisfies ProgressAnnotation);
+
+          // Select context files
+          console.log(`Messages count: ${processedMessages.length}`);
+          filteredFiles = await selectContext({
+            messages: [...processedMessages],
+            env: context.cloudflare?.env,
+            apiKeys,
+            files,
+            providerSettings,
+            promptId,
+            contextOptimization,
+            summary,
+            onFinish(resp) {
+              if (resp.usage) {
+                logger.debug('selectContext token usage', JSON.stringify(resp.usage));
+                cumulativeUsage.completionTokens += resp.usage.completionTokens || 0;
+                cumulativeUsage.promptTokens += resp.usage.promptTokens || 0;
+                cumulativeUsage.totalTokens += resp.usage.totalTokens || 0;
+              }
+            },
+          });
+
+          if (filteredFiles) {
+            logger.debug(`files in context : ${JSON.stringify(Object.keys(filteredFiles))}`);
+          }
+
+          dataStream.writeMessageAnnotation({
+            type: 'codeContext',
+            files: Object.keys(filteredFiles).map((key) => {
+              let path = key;
+
+              if (path.startsWith(WORK_DIR)) {
+                path = path.replace(WORK_DIR, '');
+              }
+
+              return path;
+            }),
+          } as ContextAnnotation);
+
+          dataStream.writeData({
+            type: 'progress',
+            label: 'context',
+            status: 'complete',
+            order: progressCounter++,
+            message: 'Code Files Selected',
+          } satisfies ProgressAnnotation);
+
+          // logger.debug('Code Files Selected');
+        }
+
+        const options: StreamingOptions = {
+          supabaseConnection: supabase,
+          toolChoice: 'auto',
+          tools: mcpService.toolsWithoutExecute,
+          maxSteps: maxLLMSteps,
+          onStepFinish: ({ toolCalls }) => {
+            // add tool call annotations for frontend processing
+            toolCalls.forEach((toolCall) => {
+              mcpService.processToolCall(toolCall, dataStream);
+            });
+          },
+          onFinish: async ({ text: content, finishReason, usage }) => {
+            logger.debug('usage', JSON.stringify(usage));
+
+            if (usage) {
+              cumulativeUsage.completionTokens += usage.completionTokens || 0;
+              cumulativeUsage.promptTokens += usage.promptTokens || 0;
+              cumulativeUsage.totalTokens += usage.totalTokens || 0;
+            }
+
+            if (finishReason !== 'length') {
+              dataStream.writeMessageAnnotation({
+                type: 'usage',
+                value: {
+                  completionTokens: cumulativeUsage.completionTokens,
+                  promptTokens: cumulativeUsage.promptTokens,
+                  totalTokens: cumulativeUsage.totalTokens,
+                },
+              });
+              dataStream.writeData({
+                type: 'progress',
+                label: 'response',
+                status: 'complete',
+                order: progressCounter++,
+                message: 'Response Generated',
+              } satisfies ProgressAnnotation);
+              await new Promise((resolve) => setTimeout(resolve, 0));
+
+              // stream.close();
+              return;
+            }
+
+            if (stream.switches >= MAX_RESPONSE_SEGMENTS) {
+              throw Error('Cannot continue message: Maximum segments reached');
+            }
+
+            const switchesLeft = MAX_RESPONSE_SEGMENTS - stream.switches;
+
+            logger.info(`Reached max token limit (${MAX_TOKENS}): Continuing message (${switchesLeft} switches left)`);
+
+            const lastUserMessage = processedMessages.filter((x) => x.role == 'user').slice(-1)[0];
+            const { model, provider } = extractPropertiesFromMessage(lastUserMessage);
+            processedMessages.push({ id: generateId(), role: 'assistant', content });
+            processedMessages.push({
+              id: generateId(),
+              role: 'user',
+              content: `[Model: ${model}]\n\n[Provider: ${provider}]\n\n${CONTINUE_PROMPT}`,
+            });
+
+            const result = await streamText({
+              messages: [...processedMessages],
+              env: context.cloudflare?.env,
+              options,
+              apiKeys,
+              files,
+              providerSettings,
+              promptId,
+              contextOptimization,
+              contextFiles: filteredFiles,
+              chatMode,
+              designScheme,
+              summary,
+              messageSliceId,
+            });
+
+            result.mergeIntoDataStream(dataStream);
+
+            (async () => {
+              for await (const part of result.fullStream) {
+                if (part.type === 'error') {
+                  const error: any = part.error;
+                  logger.error(`${error}`);
+
+                  return;
+                }
+              }
+            })();
+
+            return;
+          },
+        };
+
+        dataStream.writeData({
+          type: 'progress',
+          label: 'response',
+          status: 'in-progress',
+          order: progressCounter++,
+          message: 'Generating Response',
+        } satisfies ProgressAnnotation);
+
+        const result = await streamText({
+          messages: [...processedMessages],
+          env: context.cloudflare?.env,
+          options,
+          apiKeys,
+          files,
+          providerSettings,
+          promptId,
+          contextOptimization,
+          contextFiles: filteredFiles,
+          chatMode,
+          designScheme,
+          summary,
+          messageSliceId,
+        });
+
+        (async () => {
+          for await (const part of result.fullStream) {
+            streamRecovery.updateActivity();
+
+            if (part.type === 'error') {
+              const error: any = part.error;
+              logger.error('Streaming error:', error);
+              streamRecovery.stop();
+
+              // Enhanced error handling for common streaming issues
+              if (error.message?.includes('Invalid JSON response')) {
+                logger.error('Invalid JSON response detected - likely malformed API response');
+              } else if (error.message?.includes('token')) {
+                logger.error('Token-related error detected - possible token limit exceeded');
+              }
+
+              return;
+            }
+          }
+          streamRecovery.stop();
+        })();
+        result.mergeIntoDataStream(dataStream);
+      },
+      onError: (error: any) => {
+        // Provide more specific error messages for common issues
+        const errorMessage = error.message || 'Unknown error';
+
+        if (errorMessage.includes('model') && errorMessage.includes('not found')) {
+          return 'Custom error: Invalid model selected. Please check that the model name is correct and available.';
+        }
+
+        if (errorMessage.includes('Invalid JSON response')) {
+          return 'Custom error: The AI service returned an invalid response. This may be due to an invalid model name, API rate limiting, or server issues. Try selecting a different model or check your API key.';
+        }
+
+        if (
+          errorMessage.includes('API key') ||
+          errorMessage.includes('unauthorized') ||
+          errorMessage.includes('authentication')
+        ) {
+          return 'Custom error: Invalid or missing API key. Please check your API key configuration.';
+        }
+
+        if (errorMessage.includes('token') && errorMessage.includes('limit')) {
+          return 'Custom error: Token limit exceeded. The conversation is too long for the selected model. Try using a model with larger context window or start a new conversation.';
+        }
+
+        if (errorMessage.includes('rate limit') || errorMessage.includes('429')) {
+          return 'Custom error: API rate limit exceeded. Please wait a moment before trying again.';
+        }
+
+        if (errorMessage.includes('network') || errorMessage.includes('timeout')) {
+          return 'Custom error: Network error. Please check your internet connection and try again.';
+        }
+
+        return `Custom error: ${errorMessage}`;
+      },
+    }).pipeThrough(
+      new TransformStream({
+        transform: (chunk, controller) => {
+          if (!lastChunk) {
+            lastChunk = ' ';
+          }
+
+          if (typeof chunk === 'string') {
+            if (chunk.startsWith('g') && !lastChunk.startsWith('g')) {
+              controller.enqueue(encoder.encode(`0: "<div class=\\"__boltThought__\\">"\n`));
+            }
+
+            if (lastChunk.startsWith('g') && !chunk.startsWith('g')) {
+              controller.enqueue(encoder.encode(`0: "</div>\\n"\n`));
+            }
+          }
+
+          lastChunk = chunk;
+
+          let transformedChunk = chunk;
+
+          if (typeof chunk === 'string' && chunk.startsWith('g')) {
+            let content = chunk.split(':').slice(1).join(':');
+
+            if (content.endsWith('\n')) {
+              content = content.slice(0, content.length - 1);
+            }
+
+            transformedChunk = `0:${content}\n`;
+          }
+
+          // Convert the string stream to a byte stream
+          const str = typeof transformedChunk === 'string' ? transformedChunk : JSON.stringify(transformedChunk);
+          controller.enqueue(encoder.encode(str));
+        },
+      }),
+    );
+
+    return new Response(dataStream, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream; charset=utf-8',
+        Connection: 'keep-alive',
+        'Cache-Control': 'no-cache',
+        'Text-Encoding': 'chunked',
+      },
+    });
+  } catch (error: any) {
+    logger.error(error);
+
+    const errorResponse = {
+      error: true,
+      message: error.message || 'An unexpected error occurred',
+      statusCode: error.statusCode || 500,
+      isRetryable: error.isRetryable !== false, // Default to retryable unless explicitly false
+      provider: error.provider || 'unknown',
+    };
+
+    if (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',
+        },
+      );
+    }
+
+    return new Response(JSON.stringify(errorResponse), {
+      status: errorResponse.statusCode,
+      headers: { 'Content-Type': 'application/json' },
+      statusText: 'Error',
+    });
+  }
+}

tools/bolt.diy/app/routes/api.check-env-key.ts

@@ -0,0 +1,41 @@
+import type { LoaderFunction } from '@remix-run/cloudflare';
+import { LLMManager } from '~/lib/modules/llm/manager';
+import { getApiKeysFromCookie } from '~/lib/api/cookies';
+
+export const loader: LoaderFunction = async ({ context, request }) => {
+  const url = new URL(request.url);
+  const provider = url.searchParams.get('provider');
+
+  if (!provider) {
+    return Response.json({ isSet: false });
+  }
+
+  const llmManager = LLMManager.getInstance(context?.cloudflare?.env as any);
+  const providerInstance = llmManager.getProvider(provider);
+
+  if (!providerInstance || !providerInstance.config.apiTokenKey) {
+    return Response.json({ isSet: false });
+  }
+
+  const envVarName = providerInstance.config.apiTokenKey;
+
+  // Get API keys from cookie
+  const cookieHeader = request.headers.get('Cookie');
+  const apiKeys = getApiKeysFromCookie(cookieHeader);
+
+  /*
+   * Check API key in order of precedence:
+   * 1. Client-side API keys (from cookies)
+   * 2. Server environment variables (from Cloudflare env)
+   * 3. Process environment variables (from .env.local)
+   * 4. LLMManager environment variables
+   */
+  const isSet = !!(
+    apiKeys?.[provider] ||
+    (context?.cloudflare?.env as Record<string, any>)?.[envVarName] ||
+    process.env[envVarName] ||
+    llmManager.env[envVarName]
+  );
+
+  return Response.json({ isSet });
+};

tools/bolt.diy/app/routes/api.configured-providers.ts

@@ -0,0 +1,110 @@
+import type { LoaderFunction } from '@remix-run/cloudflare';
+import { json } from '@remix-run/cloudflare';
+import { LLMManager } from '~/lib/modules/llm/manager';
+import { LOCAL_PROVIDERS } from '~/lib/stores/settings';
+
+interface ConfiguredProvider {
+  name: string;
+  isConfigured: boolean;
+  configMethod: 'environment' | 'none';
+}
+
+interface ConfiguredProvidersResponse {
+  providers: ConfiguredProvider[];
+}
+
+/**
+ * API endpoint that detects which providers are configured via environment variables
+ * This helps auto-enable providers that have been set up by the user
+ */
+export const loader: LoaderFunction = async ({ context }) => {
+  try {
+    const llmManager = LLMManager.getInstance(context?.cloudflare?.env as any);
+    const configuredProviders: ConfiguredProvider[] = [];
+
+    // Check each local provider for environment configuration
+    for (const providerName of LOCAL_PROVIDERS) {
+      const providerInstance = llmManager.getProvider(providerName);
+      let isConfigured = false;
+      let configMethod: 'environment' | 'none' = 'none';
+
+      if (providerInstance) {
+        const config = providerInstance.config;
+
+        /*
+         * Check if required environment variables are set
+         * For providers with baseUrlKey (Ollama, LMStudio, OpenAILike)
+         */
+        if (config.baseUrlKey) {
+          const baseUrlEnvVar = config.baseUrlKey;
+          const cloudflareEnv = (context?.cloudflare?.env as Record<string, any>)?.[baseUrlEnvVar];
+          const processEnv = process.env[baseUrlEnvVar];
+          const managerEnv = llmManager.env[baseUrlEnvVar];
+
+          const envBaseUrl = cloudflareEnv || processEnv || managerEnv;
+
+          /*
+           * Only consider configured if environment variable is explicitly set
+           * Don't count default config.baseUrl values or placeholder values
+           */
+          const isValidEnvValue =
+            envBaseUrl &&
+            typeof envBaseUrl === 'string' &&
+            envBaseUrl.trim().length > 0 &&
+            !envBaseUrl.includes('your_') && // Filter out placeholder values like "your_openai_like_base_url_here"
+            !envBaseUrl.includes('_here') &&
+            envBaseUrl.startsWith('http'); // Must be a valid URL
+
+          if (isValidEnvValue) {
+            isConfigured = true;
+            configMethod = 'environment';
+          }
+        }
+
+        // For providers that might need API keys as well (check this separately, not as fallback)
+        if (config.apiTokenKey && !isConfigured) {
+          const apiTokenEnvVar = config.apiTokenKey;
+          const envApiToken =
+            (context?.cloudflare?.env as Record<string, any>)?.[apiTokenEnvVar] ||
+            process.env[apiTokenEnvVar] ||
+            llmManager.env[apiTokenEnvVar];
+
+          // Only consider configured if API key is set and not a placeholder
+          const isValidApiToken =
+            envApiToken &&
+            typeof envApiToken === 'string' &&
+            envApiToken.trim().length > 0 &&
+            !envApiToken.includes('your_') && // Filter out placeholder values
+            !envApiToken.includes('_here') &&
+            envApiToken.length > 10; // API keys are typically longer than 10 chars
+
+          if (isValidApiToken) {
+            isConfigured = true;
+            configMethod = 'environment';
+          }
+        }
+      }
+
+      configuredProviders.push({
+        name: providerName,
+        isConfigured,
+        configMethod,
+      });
+    }
+
+    return json<ConfiguredProvidersResponse>({
+      providers: configuredProviders,
+    });
+  } catch (error) {
+    console.error('Error detecting configured providers:', error);
+
+    // Return default state on error
+    return json<ConfiguredProvidersResponse>({
+      providers: LOCAL_PROVIDERS.map((name) => ({
+        name,
+        isConfigured: false,
+        configMethod: 'none' as const,
+      })),
+    });
+  }
+};

tools/bolt.diy/app/routes/api.corporate-swarm-status.ts

@@ -0,0 +1,55 @@
+/**
+ * CorporateSwarm status API endpoint.
+ * 
+ * Queries CorporateSwarm for proposal and mandate status.
+ */
+
+import { type LoaderFunctionArgs, json } from '@remix-run/cloudflare';
+import { createScopedLogger } from '~/utils/logger';
+
+const logger = createScopedLogger('api.corporate-swarm-status');
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  const proposalId = url.searchParams.get("proposal_id");
+  const mandateId = url.searchParams.get("mandate_id");
+
+  if (!proposalId && !mandateId) {
+    return json({ error: "proposal_id or mandate_id is required" }, { status: 400 });
+  }
+
+  try {
+    const corporateSwarmUrl = process.env.CORPORATE_SWARM_URL || "http://localhost:8000";
+    let data = null;
+
+    if (proposalId) {
+      const response = await fetch(`${corporateSwarmUrl}/api/proposal/${proposalId}`, {
+        headers: { "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(5000)
+      });
+      
+      if (response.ok) {
+        data = await response.json();
+      } else {
+        return json({ error: "Proposal not found" }, { status: 404 });
+      }
+    } else if (mandateId) {
+      const response = await fetch(`${corporateSwarmUrl}/api/mandate/${mandateId}`, {
+        headers: { "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(5000)
+      });
+      
+      if (response.ok) {
+        data = await response.json();
+      } else {
+        return json({ error: "Mandate not found" }, { status: 404 });
+      }
+    }
+
+    return json(data || {});
+  } catch (error) {
+    logger.error(`Error fetching CorporateSwarm status: ${error}`);
+    return json({ error: "Failed to fetch CorporateSwarm status" }, { status: 500 });
+  }
+}
+