beddel 0.1.0

package/tools/seed.ts

@@ -0,0 +1,365 @@
+// centralized seed file to update existing methods using Upstash KV
+//
+// how to run:
+// 1. make sure your environment variables for KV_REST_API_URL and KV_REST_API_TOKEN are set
+// 2. run the following command from the root of the project:
+//    npx dotenv-cli -- npx tsx packages/beddel/tools/seed.ts
+
+import { Redis } from "@upstash/redis";
+
+// --- Code block for: summarize-text ---
+const summarizeTextCode = `async function execute(input, props, context) {
+      try {
+        context.log("Starting text summarization...");
+        const { generateText } = await import("ai");
+        const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+
+        if (!input.text) {
+          return context.setError("Missing required parameter: text");
+        }
+
+        if (!props.gemini_api_key) {
+          return context.setError("Missing required prop: gemini_api_key");
+        }
+
+        const google = createGoogleGenerativeAI({
+          apiKey: props.gemini_api_key,
+        });
+
+        const { text } = await generateText({
+          model: google("models/gemini-flash-latest"),
+          prompt: "Summarize the following text into concise bullet points:\\n\\n" + input.text,
+        });
+
+        if (typeof text !== "string") {
+          return context.setError("AI service did not return a valid text response.");
+        }
+
+        context.log("Successfully generated summary.");
+        context.setOutput({ summary: text });
+
+      } catch (e) {
+        context.log("An unexpected error occurred: " + e.message);
+        context.setError(e.message || "An unknown error occurred during summarization.");
+      }
+    }`;
+
+// --- Code block for: extract-entities ---
+const extractEntitiesCode = `async function execute(input, props, context) {
+      try {
+        context.log("Starting entity extraction...");
+        const { generateText } = await import("ai");
+        const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+
+        if (!input.text) {
+          return context.setError("Missing required parameter: text");
+        }
+
+        if (!props.gemini_api_key) {
+          return context.setError("Missing required prop: gemini_api_key");
+        }
+
+        const google = createGoogleGenerativeAI({
+          apiKey: props.gemini_api_key,
+        });
+
+        const { text } = await generateText({
+          model: google("models/gemini-flash-latest"),
+          prompt: "Extract all named entities from the following text and categorize them as PERSON, PLACE, ORGANIZATION, or OTHER. Return as a valid JSON object string:\\n\\n" + input.text,
+        });
+
+        if (typeof text !== "string") {
+          return context.setError("AI service did not return a valid text response.");
+        }
+
+        context.log("Successfully extracted entities.");
+        context.setOutput({ entities: text });
+
+      } catch (e) {
+        context.log("An unexpected error occurred: " + e.message);
+        context.setError(e.message || "An unknown error occurred during entity extraction.");
+      }
+    }`;
+    
+// --- Code block for: generate-automation-ideas ---
+const generateIdeasCode = `async function execute(input, props, context) {
+      try {
+        context.log("Starting automation idea generation...");
+        const { generateText } = await import("ai");
+        const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+
+        if (!input.problem) {
+          return context.setError("Missing required parameter: problem");
+        }
+
+        if (!props.gemini_api_key) {
+          return context.setError("Missing required prop: gemini_api_key");
+        }
+
+        const google = createGoogleGenerativeAI({
+          apiKey: props.gemini_api_key,
+        });
+
+        const { text } = await generateText({
+          model: google("models/gemini-flash-latest"),
+          prompt: "Given this business problem: "" + input.problem + ""\\n\\nGenerate 5 creative automation workflow ideas that could solve or improve this situation. For each idea, include: 1) Workflow name, 2) Description, 3) Key steps, 4) Expected benefits.",
+        });
+
+        if (typeof text !== "string") {
+          return context.setError("AI service did not return a valid text response.");
+        }
+
+        context.log("Successfully generated ideas.");
+        context.setOutput({ ideas: text });
+
+      } catch (e) {
+        context.log("An unexpected error occurred: " + e.message);
+        context.setError(e.message || "An unknown error occurred during idea generation.");
+      }
+    }`;
+
+// --- Code block for: validate-json-schema ---
+const validateJsonCode = `async function execute(input, props, context) {
+      try {
+        context.log("Starting JSON validation...");
+        const { generateText } = await import("ai");
+        const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+
+        if (!input.json || !input.schema) {
+          return context.setError("Missing required parameters: json, schema");
+        }
+
+        if (!props.gemini_api_key) {
+          return context.setError("Missing required prop: gemini_api_key");
+        }
+
+        const google = createGoogleGenerativeAI({
+          apiKey: props.gemini_api_key,
+        });
+
+        const { text } = await generateText({
+          model: google("models/gemini-flash-latest"),
+          prompt: "Validate this JSON data against the schema and provide detailed feedback:\\n\\nJSON Data:\\n" + input.json + "\\n\\nSchema:\\n" + input.schema + "\\n\\nProvide: 1) Is it valid? 2) List of errors if any, 3) Suggested fixes",
+        });
+
+        if (typeof text !== "string") {
+          return context.setError("AI service did not return a valid text response.");
+        }
+
+        context.log("Successfully validated JSON.");
+        context.setOutput({ validation: text });
+
+      } catch (e) {
+        context.log("An unexpected error occurred: " + e.message);
+        context.setError(e.message || "An unknown error occurred during JSON validation.");
+      }
+    }`;
+
+// --- Code block for: create-endpoint-from-description ---
+const createEndpointFromDescriptionCode = `async function execute(input, props, context) {
+      const { generateText } = await import("ai");
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+      const { Redis } = await import("@upstash/redis");
+
+      try {
+        context.log("Starting endpoint generation from description...");
+
+        // 1. Validate input and props
+        if (!input.description) {
+          return context.setError("Missing required parameter: description");
+        }
+        const requiredPropsList = ["gemini_api_key", "kv_rest_api_url", "kv_rest_api_token"];
+        for (const prop of requiredPropsList) {
+          if (!props[prop]) {
+            return context.setError("Missing required prop: " + prop);
+          }
+        }
+
+        // 1.5. Fetch existing endpoints to inform AI
+        const redis = new Redis({
+          url: props.kv_rest_api_url,
+          token: props.kv_rest_api_token,
+        });
+
+        context.log("Fetching existing endpoints to inform AI...");
+        const existingEndpointIds = (await redis.get("endpoints:list")) || [];
+        const existingEndpoints = [];
+        for (const id of existingEndpointIds) {
+          const endpoint = await redis.get("endpoint:" + id);
+          if (endpoint) {
+            existingEndpoints.push({
+              id: endpoint.id,
+              name: endpoint.name,
+              description: endpoint.description,
+              requiredProps: endpoint.requiredProps,
+            });
+          }
+        }
+        const existingEndpointsString = JSON.stringify(existingEndpoints, null, 2);
+        context.log("Found " + existingEndpoints.length + " existing endpoints.");
+
+        // 2. Prepare the prompt for the AI
+        const generationPrompt = "# PROMPT PARA GERAÇÃO DE ENDPOINT DINÂMICO COM IA\\n\\n" +
+          "## Persona\\nVocê é um Engenheiro de Software Sênior especialista em criar funções serverless seguras, eficientes e robustas em JavaScript.\\n\\n" +
+          "## Contexto da Aplicação\\nVocê está trabalhing in um sistema que executa dinamicamente endpoints de código a partir de uma base de dados Upstash KV. Cada endpoint é uma função \\"execute\\" que recebe \\"input\\", \\"props\\", e \\"context\\".\\n- \\"context.setOutput(output)\\" para sucesso.\\n- \\"context.setError(error)\\" para falha.\\n\\n" +
+          "## Exemplo de Implementação Correta\\n**Descrição:** \"Resumir texto com Gemini.\"\\n**Saída JSON Esperada:**\\n" +
+          "{\\n  \"name\": \"summarize-text\",\\n  \"description\": \"Summarize long text into concise bullet points using Gemini AI\",\\n  \"requiredProps\": [\"gemini_api_key\"],\\n  \"code\": \"async function execute(input, props, context) { try { context.log(\\"Starting text summarization...\\"); const { generateText } = await import(\\"ai\\"); const { createGoogleGenerativeAI } = await import(\\"/@ai-sdk/google\\"); if (!input.text) { return context.setError(\\"Missing required parameter: text\\"); } if (!props.gemini_api_key) { return context.setError(\\"Missing required prop: gemini_api_key\\"); } const google = createGoogleGenerativeAI({ apiKey: props.gemini_api_key }); const { text } = await generateText({ model: google(\\"models/gemini-flash-latest\\"), prompt: \\"Summarize the following text into concise bullet points:\\\\\\\\n\\\\\\\\n\\" + input.text }); if (typeof text !== \\"string\\") { return context.setError(\\"AI service did not return a valid text response.\\"); } context.log(\\"Successfully generated summary.\\"); context.setOutput({ summary: text }); } catch (e) { context.log(\\"An unexpected error occurred: \\" + e.message); context.setError(e.message || \\"An unknown error occurred during summarization.\\"); } }"\\n}" +
+          "\\n\\n## Endpoints Existentes (para referência e reutilização de padrões)\\n\\`\\`\\`json\\n" + existingEndpointsString + "\\n\\`\\`\\`\\n\\n" +
+          "## Regras\\n1.  **Segurança:** Valide \\"input\\" e \\"props\\".\\n2.  **Saída JSON:** Sua resposta DEVE ser um único objeto JSON válido. O campo \\"code\\" deve ser uma string com quebras de linha escapadas como \\"\\\\n\\".\\n3.  **Bibliotecas Permitidas:** \\"ai\\", \\"@ai-sdk/google\\", \\"@upstash/redis\\".\\n4.  **Nome do Endpoint:** O \\"name\\" deve ser um slug em \\"kebab-case\\".\\n5.  **Reutilização:** Se um endpoint similar já existe, o novo endpoint DEVE tentar reutilizar lógica ou ao menos seguir o mesmo padrão de design e validação.\\n\\n" +
+          '## Sua Tarefa\\nGere o objeto JSON para o novo endpoint.\\n**Descrição do Usuário:** "" + input.description + """;
+
+        // 3. Call the AI to generate the endpoint details
+        context.log('Generating endpoint code with AI...');
+        const google = createGoogleGenerativeAI({ apiKey: props.gemini_api_key });
+        const { text } = await generateText({
+          model: google('models/gemini-flash-latest'),
+          prompt: generationPrompt,
+        });
+
+        let newEndpoint;
+        try {
+          newEndpoint = JSON.parse(text);
+        } catch (e) {
+          context.log('AI returned invalid JSON: ' + text);
+          return context.setError('Failed to parse AI response. The generated content was not valid JSON.');
+        }
+
+        // 4. Connect to Upstash KV and save the new endpoint
+        context.log('Connecting to Upstash KV to save \"' + newEndpoint.name + '\"...');
+        
+        const endpointId = 'endpoint_' + newEndpoint.name.replace(/-/g, '_') + '_' + Date.now();
+        const endpointData = {
+          id: endpointId,
+          name: newEndpoint.name,
+          description: newEndpoint.description,
+          code: newEndpoint.code,
+          requiredProps: newEndpoint.requiredProps || [],
+          isPublic: false,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        };
+
+        await redis.set('endpoint:' + endpointId, JSON.stringify(endpointData));
+        context.log('Successfully saved new endpoint.');
+
+        // 5. Update the main endpoint list
+        const endpointList = (await redis.get('endpoints:list')) || [];
+        if (!Array.isArray(endpointList)) {
+            await redis.set('endpoints:list', [endpointId]);
+        } else {
+            endpointList.push(endpointId);
+            await redis.set('endpoints:list', endpointList);
+        }
+        
+        context.log('Successfully updated endpoints list.');
+
+        context.setOutput({
+          message: 'Endpoint created successfully!',
+          endpointId: endpointId,
+          name: newEndpoint.name
+        });
+
+      } catch (e) {
+        context.log('An unexpected error occurred: ' + e.message);
+        context.setError(e.message || 'An unknown error occurred during endpoint creation.');
+      }
+    }`;
+
+// The list of methods to be updated with the correct code pattern.
+const methodsToUpdate = [
+  {
+    id: "endpoint_summarize_001",
+    name: "summarize-text",
+    description: "Summarize long text into concise bullet points using Gemini AI",
+    isPublic: true,
+    requiredProps: ["gemini_api_key"],
+    code: summarizeTextCode,
+  },
+  {
+    id: "endpoint_extract_entities_002",
+    name: "extract-entities",
+    description: "Extract named entities (people, places, organizations) from text",
+    isPublic: true,
+    requiredProps: ["gemini_api_key"],
+    code: extractEntitiesCode,
+  },
+  {
+    id: "endpoint_generate_ideas_003",
+    name: "generate-automation-ideas",
+    description: "Generate automation workflow ideas based on a business problem",
+    isPublic: true,
+    requiredProps: ["gemini_api_key"],
+    code: generateIdeasCode,
+  },
+  {
+    id: "endpoint_validate_json_004",
+    name: "validate-json-schema",
+    description: "Validate JSON data against a schema and suggest fixes",
+    isPublic: true,
+    requiredProps: ["gemini_api_key"],
+    code: validateJsonCode,
+  },
+  {
+    id: "endpoint_create_from_description_005",
+    name: "create-endpoint-from-description",
+    description: "Create a new dynamic endpoint from a natural language description using AI",
+    isPublic: false,
+    requiredProps: ["gemini_api_key", "kv_rest_api_url", "kv_rest_api_token"],
+    code: createEndpointFromDescriptionCode,
+  },
+];
+
+async function seedUpdatedMethods() {
+  console.log("[v1] Starting endpoint update seed...");
+
+  if (!process.env.KV_REST_API_URL || !process.env.KV_REST_API_TOKEN) {
+    console.error("[v1] ❌ Missing Upstash KV environment variables. Please set KV_REST_API_URL and KV_REST_API_TOKEN.");
+    process.exit(1);
+  }
+
+  console.log("[v1] Connecting to Upstash KV...");
+  const redis = new Redis({
+    url: process.env.KV_REST_API_URL as string,
+    token: process.env.KV_REST_API_TOKEN as string,
+  });
+
+  try {
+    const allEndpointIds = [];
+    for (const method of methodsToUpdate) {
+      console.log(`[v1] Updating endpoint: ${method.name} (${method.id})`);
+      
+      const oldRecord = await redis.get<any>(`endpoint:${method.id}`);
+      const createdAt = oldRecord?.createdAt || new Date().toISOString();
+
+      const updatedMethod = {
+        ...oldRecord,
+        ...method,
+        createdAt: createdAt,
+        updatedAt: new Date().toISOString(),
+      };
+      
+      await redis.set(`endpoint:${method.id}`, JSON.stringify(updatedMethod));
+      console.log(`[v1] ✓ Successfully updated ${method.name}`);
+      allEndpointIds.push(method.id);
+    }
+
+    // Check for endpoints that are in the list but not in methodsToUpdate
+    const existingEndpointIds = (await redis.get<string[]>("endpoints:list")) || [];
+    for(const existingId of existingEndpointIds) {
+        if(!allEndpointIds.includes(existingId)) {
+            allEndpointIds.push(existingId)
+        }
+    }
+    
+    await redis.set("endpoints:list", allEndpointIds);
+    console.log("[v1] ✓ Successfully created/updated the endpoints list index.");
+
+    console.log("\\n[v1] ✅ Endpoint update seed completed successfully!");
+
+  } catch (error) {
+    console.error("\\n[v1] ❌ Error updating endpoints:", error);
+    throw error;
+  }
+}
+
+seedUpdatedMethods();

package/tools/test-endpoints.ts

@@ -0,0 +1,174 @@
+
+import { Redis } from '@upstash/redis';
+import assert from 'assert';
+
+// Centralized test data for each endpoint
+const testData = {
+  "endpoint_summarize_001": {
+    success: { input: { text: "This is a long text to summarize into bullet points." } },
+    failure: { input: {} } // Missing 'text'
+  },
+  "endpoint_extract_entities_002": {
+    success: { input: { text: "John Doe works at Google in New York." } },
+    failure: { input: {} } // Missing 'text'
+  },
+  "endpoint_generate_ideas_003": {
+    success: { input: { problem: "Our customer support team is overwhelmed with tickets." } },
+    failure: { input: {} } // Missing 'problem'
+  },
+  "endpoint_validate_json_004": {
+    success: {
+      input: {
+        json: '{ \"name\": \"John\", \"age\": 30 }',
+        schema: '{ \"type\": \"object\", \"properties\": { \"name\": { \"type\": \"string\" }, \"age\": { \"type\": \"number\" } } }'
+      }
+    },
+    failure: { input: { json: '{ \"name\": \"John\" }' } } // Missing 'schema'
+  },
+  "endpoint_translate_005": {
+    success: { input: { text: "Hello, world!", targetLanguage: "Spanish" } },
+    failure: { input: { text: "Hello, world!" } } // Missing 'targetLanguage'
+  }
+};
+
+// Expected output keys for each endpoint\'s success case
+const expectedOutputKeys = {
+  endpoint_summarize_001: 'summary',
+  endpoint_extract_entities_002: 'entities',
+  endpoint_generate_ideas_003: 'ideas',
+  endpoint_validate_json_004: 'validation',
+  endpoint_translate_005: 'translation'
+};
+
+
+// Mock context object to capture test results
+function createMockContext() {
+  let output: any = null;
+  let error: string | null = null;
+  const logs: string[] = [];
+  return {
+    log: (message: string) => logs.push(message),
+    setOutput: (data: any) => { output = data; },
+    setError: (message: string) => { error = message; },
+    getOutput: () => output,
+    getError: () => error,
+    getLogs: () => logs,
+    reset: () => { output = null; error = null; logs.length = 0; },
+  };
+}
+
+// Runs the endpoint code in a sandboxed environment
+async function runCode(code: string, input: any, props: any, context: any) {
+  // Create a dynamic function to execute the user-provided code string
+  const execute = new Function('input', 'props', 'context', 'require', `
+    const userCode = ${code};
+    return userCode(input, props, context);
+  `);
+
+  // Execute the code, allowing it to use the real 'require' function
+  await execute(input, props, context, require);
+}
+
+async function testEndpoints() {
+  console.log("[TEST] Starting TRUE integration test...");
+
+  // Check for all required environment variables
+  if (!process.env.KV_REST_API_URL || !process.env.KV_REST_API_TOKEN || !process.env.GEMINI_API_KEY) {
+    console.error("[TEST] ❌ Missing required environment variables (KV_REST_API_URL, KV_REST_API_TOKEN, GEMINI_API_KEY).");
+    process.exit(1);
+  }
+
+  const redis = new Redis({
+    url: process.env.KV_REST_API_URL as string,
+    token: process.env.KV_REST_API_TOKEN as string,
+  });
+
+  const mockContext = createMockContext();
+  const endpointIdToTest = process.argv[2];
+  let endpointIds: string[] = [];
+
+  if (endpointIdToTest) {
+    console.log(`[TEST] 🎯 Targeting single endpoint: ${endpointIdToTest}`);
+    endpointIds = [endpointIdToTest];
+  } else {
+    console.log("[TEST] 🎯 Targeting all endpoints from master list...");
+    const idList = await redis.get<string[]>('endpoints:list');
+    if (!idList) {
+      console.error("[TEST] ❌ Master list 'endpoints:list' not found in Redis.");
+      process.exit(1);
+    }
+    endpointIds = idList;
+  }
+
+  if (endpointIds.length === 0) {
+    console.warn("[TEST] ⚠️ No endpoints found to test.");
+    return;
+  }
+
+  let passed = 0;
+  let failed = 0;
+
+  for (const endpointId of endpointIds) {
+    const key = `endpoint:${endpointId}`;
+    const endpoint = await redis.get<any>(key);
+
+    if (!endpoint || !endpoint.code || !endpoint.id) {
+      console.warn(`[TEST] ⚠️ Skipping invalid record for ID: ${endpointId} (key: ${key})`);
+      continue;
+    }
+
+    const specificTestData = testData[endpointId as keyof typeof testData];
+    const expectedKey = expectedOutputKeys[endpointId as keyof typeof expectedOutputKeys];
+
+    if (!specificTestData || !expectedKey) {
+      console.warn(`[TEST] ⚠️ No test data or expected output key for ${endpointId}. Skipping.`);
+      continue;
+    }
+
+    console.log(`\n[TEST] 🧪 Testing endpoint: ${endpoint.name} (${endpointId})`);
+    mockContext.reset();
+
+    try {
+      const realProps = { gemini_api_key: process.env.GEMINI_API_KEY };
+
+      // Test Case 1: Success (Real API Call)
+      console.log("  -> Running success case (REAL API call)...");
+      await runCode(endpoint.code, specificTestData.success.input, realProps, mockContext);
+      const output = mockContext.getOutput();
+      assert.strictEqual(mockContext.getError(), null, "Success case should not produce an error.");
+      assert.ok(output, "Output should not be null or undefined.");
+      assert.ok(output[expectedKey], `Output should have the key '${expectedKey}'.`);
+      assert.strictEqual(typeof output[expectedKey], 'string', `Value of '${expectedKey}' should be a string.`);
+      console.log(`     ✅ Success (Received: "${output[expectedKey].substring(0, 50)}...")`);
+
+      // Test Case 2: Failure (missing input)
+      console.log("  -> Running failure case (missing input)...");
+      mockContext.reset();
+      await runCode(endpoint.code, specificTestData.failure.input, realProps, mockContext);
+      assert.notStrictEqual(mockContext.getError(), null, "Failure case (missing input) should produce an error.");
+      console.log("     ✅ Success (Correctly caught error)");
+
+      // Test Case 3: Failure (missing prop)
+      console.log("  -> Running failure case (missing prop)...");
+      mockContext.reset();
+      await runCode(endpoint.code, specificTestData.success.input, {}, mockContext);
+      assert.notStrictEqual(mockContext.getError(), null, "Failure case (missing prop) 2should produce an error.");
+      console.log("     ✅ Success (Correctly caught error)");
+
+      passed++;
+    } catch (e: any) {
+      console.error(`[TEST] ❌ FAILED: ${endpoint.name}`);
+      console.error(`     Assertion Error: ${e.message}`);
+      failed++;
+    }
+  }
+
+  console.log(`\n[TEST] ✨ Test run complete.`);
+  console.log(`[TEST] Passed: ${passed}, Failed: ${failed}`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+testEndpoints();