@envisiongroup/create-alakazam 0.1.1

package/templates/default/src/mastra/agents/weather-agent/weather-agent.ts

@@ -0,0 +1,68 @@
+import { Agent } from '@mastra/core/agent';
+import { Memory } from '@mastra/memory';
+import { hubAgent } from '@envisiongroup/alakazam';
+import { weatherTool } from '../../tools/weather-tool';
+import { scorers } from '../../scorers/weather-scorer';
+import { getAzureClient } from '@envisiongroup/alakazam/services/azure-model';
+
+// Crea el cliente de Azure y selecciona el modelo LLM que se usara.
+const azureClient = getAzureClient();
+
+// Asegurate que el modelo especificado exista en tu proyecto de Azure Foundry
+const llmModel = azureClient('gpt-4.1-mini');
+
+/**
+ * Agente de ejemplo que consulta el clima y puede sugerir actividades según
+ * las condiciones actuales. También muestra cómo asociar evaluadores a un
+ * agente para medir el uso de tools, la completitud y la traducción.
+ */
+export const weatherAgent = new Agent({
+    id: 'weather-agent',
+    metadata: {
+        ...hubAgent({
+            catalog: { tags: ['weather', 'demo'] },
+            access: { public: true },
+        }),
+    },
+    name: 'Weather Agent',
+    instructions: `
+      You are a helpful weather assistant that provides accurate weather information and can help planning activities based on the weather.
+
+      Your primary function is to help users get weather details for specific locations. When responding:
+      - Always ask for a location if none is provided
+      - If the location name isn't in English, please translate it
+      - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
+      - Include relevant details like humidity, wind conditions, and precipitation
+      - Keep responses concise but informative
+      - If the user asks for activities and provides the weather forecast, suggest activities based on the weather forecast.
+      - If the user asks for activities, respond in the format they request.
+
+      Use the weatherTool to fetch current weather data.
+`,
+    model: llmModel,
+    tools: { weatherTool },
+    scorers: {
+        toolCallAppropriateness: {
+            scorer: scorers.toolCallAppropriatenessScorer,
+            sampling: {
+                type: 'ratio',
+                rate: 1,
+            },
+        },
+        completeness: {
+            scorer: scorers.completenessScorer,
+            sampling: {
+                type: 'ratio',
+                rate: 1,
+            },
+        },
+        translation: {
+            scorer: scorers.translationScorer,
+            sampling: {
+                type: 'ratio',
+                rate: 1,
+            },
+        },
+    },
+    memory: new Memory(),
+});

package/templates/default/src/mastra/index.ts

@@ -0,0 +1,47 @@
+import {
+    createAgentsHub,
+    entraIdentityProvider,
+    staticRoleResolver,
+} from '@envisiongroup/alakazam';
+
+// --- Dominio de ESTE proyecto ------------------------------------------------
+import { weatherAgent } from './agents/weather-agent/weather-agent';
+import { azureOpenAISandboxAgent } from './agents/azure-openai-sandbox-agent/azure-openai-sandbox-agent'; // __EXAMPLES__
+import { azureClaudeSandboxAgent } from './agents/azure-claude-sandbox-agent/azure-claude-sandbox-agent'; // __EXAMPLES__
+import { userContextAgent } from './agents/user-context-agent/user-context-agent'; // __EXAMPLES__
+import { weatherTool } from './tools/weather-tool';
+import { weatherWorkflow } from './workflows/weather-workflow';
+import {
+    toolCallAppropriatenessScorer,
+    completenessScorer,
+    translationScorer,
+} from './scorers/weather-scorer';
+import { ROLE_RULES } from './access/role-rules';
+
+// --- Hub transversal (@envisiongroup/alakazam) -------------------------------
+// Todo el wiring (storage, observability, middlewares de auth/origin, CORS y
+// rutas custom) lo resuelve `createAgentsHub`. Acá solo declaras tu dominio:
+// agents, tools, workflows y scorers propios.
+//
+// El catálogo y el acceso de cada recurso se declaran en su propia
+// `metadata.envisionHub` (vía `hubAgent()` / `hubWorkflow()`). Un recurso
+// registrado sin declaración de acceso falla el arranque (fail-fast).
+export const mastra = await createAgentsHub({
+    agents: {
+        weatherAgent,
+        azureOpenAISandboxAgent, // __EXAMPLES__
+        azureClaudeSandboxAgent, // __EXAMPLES__
+        userContextAgent, // __EXAMPLES__
+    },
+    tools: { weatherTool },
+    workflows: { weatherWorkflow },
+    scorers: {
+        toolCallAppropriatenessScorer,
+        completenessScorer,
+        translationScorer,
+    },
+    auth: {
+        providers: [entraIdentityProvider()],
+        roleResolver: staticRoleResolver(ROLE_RULES),
+    },
+});

package/templates/default/src/mastra/scorers/weather-scorer.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { createToolCallAccuracyScorerCode } from '@mastra/evals/scorers/prebuilt';
+import { createCompletenessScorer } from '@mastra/evals/scorers/prebuilt';
+import {
+    getAssistantMessageFromRunOutput,
+    getUserMessageFromRunInput,
+} from '@mastra/evals/scorers/utils';
+import { createScorer } from '@mastra/core/evals';
+
+/** Comprueba si el agente eligió la tool de clima esperada. */
+export const toolCallAppropriatenessScorer = createToolCallAccuracyScorerCode({
+    expectedTool: 'weatherTool',
+    strictMode: false,
+});
+
+/** Comprueba si la respuesta contiene la información necesaria. */
+export const completenessScorer = createCompletenessScorer();
+
+/**
+ * Evalúa con otro modelo si una ubicación en otro idioma se tradujo bien.
+ * Si la ubicación ya está en inglés, la evaluación otorga la puntuación máxima.
+ */
+export const translationScorer = createScorer({
+    id: 'translation-quality-scorer',
+    name: 'Translation Quality',
+    description:
+        'Checks that non-English location names are translated and used correctly',
+    type: 'agent',
+    judge: {
+        model: 'openai/gpt-5-mini',
+        instructions:
+            'You are an expert evaluator of translation quality for geographic locations. ' +
+            'Determine whether the user text mentions a non-English location and whether the assistant correctly uses an English translation of that location. ' +
+            'Be lenient with transliteration differences and diacritics. ' +
+            'Return only the structured JSON matching the provided schema.',
+    },
+})
+    .preprocess(({ run }) => {
+        const userText = getUserMessageFromRunInput(run.input) || '';
+        const assistantText =
+            getAssistantMessageFromRunOutput(run.output) || '';
+        return { userText, assistantText };
+    })
+    .analyze({
+        description:
+            'Extract location names and detect language/translation adequacy',
+        outputSchema: z.object({
+            nonEnglish: z.boolean(),
+            translated: z.boolean(),
+            confidence: z.number().min(0).max(1).default(1),
+            explanation: z.string().default(''),
+        }),
+        createPrompt: ({ results }) => `
+            You are evaluating if a weather assistant correctly handled translation of a non-English location.
+            User text:
+            """
+            ${results.preprocessStepResult.userText}
+            """
+            Assistant response:
+            """
+            ${results.preprocessStepResult.assistantText}
+            """
+            Tasks:
+            1) Identify if the user mentioned a location that appears non-English.
+            2) If non-English, check whether the assistant used a correct English translation of that location in its response.
+            3) Be lenient with transliteration differences (e.g., accents/diacritics).
+            Return JSON with fields:
+            {
+            "nonEnglish": boolean,
+            "translated": boolean,
+            "confidence": number,
+            "explanation": string
+            }
+        `,
+    })
+    .generateScore(({ results }) => {
+        const r = (results as any)?.analyzeStepResult || {};
+        if (!r.nonEnglish) return 1;
+        if (r.translated)
+            return Math.max(0, Math.min(1, 0.7 + 0.3 * (r.confidence ?? 1)));
+        return 0;
+    })
+    .generateReason(({ results, score }) => {
+        const r = (results as any)?.analyzeStepResult || {};
+        return `Translation scoring: nonEnglish=${r.nonEnglish ?? false}, translated=${r.translated ?? false}, confidence=${r.confidence ?? 0}. Score=${score}. ${r.explanation ?? ''}`;
+    });
+
+export const scorers = {
+    toolCallAppropriatenessScorer,
+    completenessScorer,
+    translationScorer,
+};

package/templates/default/src/mastra/tools/weather-tool.ts

@@ -0,0 +1,110 @@
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+
+interface GeocodingResponse {
+    results: {
+        latitude: number;
+        longitude: number;
+        name: string;
+    }[];
+}
+interface WeatherResponse {
+    current: {
+        time: string;
+        temperature_2m: number;
+        apparent_temperature: number;
+        relative_humidity_2m: number;
+        wind_speed_10m: number;
+        wind_gusts_10m: number;
+        weather_code: number;
+    };
+}
+
+/**
+ * Consulta el clima actual de una ubicación usando Open-Meteo.
+ *
+ * Primero convierte el nombre de la ciudad en coordenadas y después obtiene
+ * la temperatura, la humedad, el viento y las condiciones actuales.
+ */
+export const weatherTool = createTool({
+    id: 'get-weather',
+    description: 'Get current weather for a location',
+    inputSchema: z.object({
+        location: z.string().describe('City name'),
+    }),
+    outputSchema: z.object({
+        temperature: z.number(),
+        feelsLike: z.number(),
+        humidity: z.number(),
+        windSpeed: z.number(),
+        windGust: z.number(),
+        conditions: z.string(),
+        location: z.string(),
+    }),
+    execute: async (inputData) => {
+        return await getWeather(inputData.location);
+    },
+});
+
+/** Obtiene los datos del clima después de resolver la ubicación. */
+const getWeather = async (location: string) => {
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = (await geocodingResponse.json()) as GeocodingResponse;
+
+    if (!geocodingData.results?.[0]) {
+        throw new Error(`Location '${location}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
+
+    const response = await fetch(weatherUrl);
+    const data = (await response.json()) as WeatherResponse;
+
+    return {
+        temperature: data.current.temperature_2m,
+        feelsLike: data.current.apparent_temperature,
+        humidity: data.current.relative_humidity_2m,
+        windSpeed: data.current.wind_speed_10m,
+        windGust: data.current.wind_gusts_10m,
+        conditions: getWeatherCondition(data.current.weather_code),
+        location: name,
+    };
+};
+
+/** Convierte el código meteorológico de Open-Meteo en texto legible. */
+function getWeatherCondition(code: number): string {
+    const conditions: Record<number, string> = {
+        0: 'Clear sky',
+        1: 'Mainly clear',
+        2: 'Partly cloudy',
+        3: 'Overcast',
+        45: 'Foggy',
+        48: 'Depositing rime fog',
+        51: 'Light drizzle',
+        53: 'Moderate drizzle',
+        55: 'Dense drizzle',
+        56: 'Light freezing drizzle',
+        57: 'Dense freezing drizzle',
+        61: 'Slight rain',
+        63: 'Moderate rain',
+        65: 'Heavy rain',
+        66: 'Light freezing rain',
+        67: 'Heavy freezing rain',
+        71: 'Slight snow fall',
+        73: 'Moderate snow fall',
+        75: 'Heavy snow fall',
+        77: 'Snow grains',
+        80: 'Slight rain showers',
+        81: 'Moderate rain showers',
+        82: 'Violent rain showers',
+        85: 'Slight snow showers',
+        86: 'Heavy snow showers',
+        95: 'Thunderstorm',
+        96: 'Thunderstorm with slight hail',
+        99: 'Thunderstorm with heavy hail',
+    };
+    return conditions[code] || 'Unknown';
+}

package/templates/default/src/mastra/workflows/weather-workflow.ts

@@ -0,0 +1,198 @@
+import { createStep, createWorkflow } from '@mastra/core/workflows';
+import { hubWorkflow } from '@envisiongroup/alakazam';
+import { z } from 'zod';
+
+/** Datos que se comparten entre los pasos del workflow. */
+const forecastSchema = z.object({
+    date: z.string(),
+    maxTemp: z.number(),
+    minTemp: z.number(),
+    precipitationChance: z.number(),
+    condition: z.string(),
+    location: z.string(),
+});
+
+/** Convierte un código de Open-Meteo en una condición legible. */
+function getWeatherCondition(code: number): string {
+    const conditions: Record<number, string> = {
+        0: 'Clear sky',
+        1: 'Mainly clear',
+        2: 'Partly cloudy',
+        3: 'Overcast',
+        45: 'Foggy',
+        48: 'Depositing rime fog',
+        51: 'Light drizzle',
+        53: 'Moderate drizzle',
+        55: 'Dense drizzle',
+        61: 'Slight rain',
+        63: 'Moderate rain',
+        65: 'Heavy rain',
+        71: 'Slight snow fall',
+        73: 'Moderate snow fall',
+        75: 'Heavy snow fall',
+        95: 'Thunderstorm',
+    };
+    return conditions[code] || 'Unknown';
+}
+
+/** Busca la ubicación y obtiene el pronóstico del clima. */
+const fetchWeather = createStep({
+    id: 'fetch-weather',
+    description: 'Fetches weather forecast for a given city',
+    inputSchema: z.object({
+        city: z.string().describe('The city to get the weather for'),
+    }),
+    outputSchema: forecastSchema,
+    execute: async ({ inputData }) => {
+        if (!inputData) {
+            throw new Error('Input data not found');
+        }
+
+        const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(inputData.city)}&count=1`;
+        const geocodingResponse = await fetch(geocodingUrl);
+        const geocodingData = (await geocodingResponse.json()) as {
+            results: { latitude: number; longitude: number; name: string }[];
+        };
+
+        if (!geocodingData.results?.[0]) {
+            throw new Error(`Location '${inputData.city}' not found`);
+        }
+
+        const { latitude, longitude, name } = geocodingData.results[0];
+
+        const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+        const response = await fetch(weatherUrl);
+        const data = (await response.json()) as {
+            current: {
+                time: string;
+                precipitation: number;
+                weathercode: number;
+            };
+            hourly: {
+                precipitation_probability: number[];
+                temperature_2m: number[];
+            };
+        };
+
+        const forecast = {
+            date: new Date().toISOString(),
+            maxTemp: Math.max(...data.hourly.temperature_2m),
+            minTemp: Math.min(...data.hourly.temperature_2m),
+            condition: getWeatherCondition(data.current.weathercode),
+            precipitationChance: data.hourly.precipitation_probability.reduce(
+                (acc, curr) => Math.max(acc, curr),
+                0,
+            ),
+            location: name,
+        };
+
+        return forecast;
+    },
+});
+
+/** Usa el agente del clima para proponer actividades adecuadas. */
+const planActivities = createStep({
+    id: 'plan-activities',
+    description: 'Suggests activities based on weather conditions',
+    inputSchema: forecastSchema,
+    outputSchema: z.object({
+        activities: z.string(),
+    }),
+    execute: async ({ inputData, mastra }) => {
+        const forecast = inputData;
+
+        if (!forecast) {
+            throw new Error('Forecast data not found');
+        }
+
+        const agent = mastra?.getAgent('weatherAgent');
+        if (!agent) {
+            throw new Error('Weather agent not found');
+        }
+
+        const prompt = `Based on the following weather forecast for ${forecast.location}, suggest appropriate activities:
+      ${JSON.stringify(forecast, null, 2)}
+      For each day in the forecast, structure your response exactly as follows:
+
+      📅 [Day, Month Date, Year]
+      ═══════════════════════════
+
+      🌡️ WEATHER SUMMARY
+      • Conditions: [brief description]
+      • Temperature: [X°C/Y°F to A°C/B°F]
+      • Precipitation: [X% chance]
+
+      🌅 MORNING ACTIVITIES
+      Outdoor:
+      • [Activity Name] - [Brief description including specific location/route]
+        Best timing: [specific time range]
+        Note: [relevant weather consideration]
+
+      🌞 AFTERNOON ACTIVITIES
+      Outdoor:
+      • [Activity Name] - [Brief description including specific location/route]
+        Best timing: [specific time range]
+        Note: [relevant weather consideration]
+
+      🏠 INDOOR ALTERNATIVES
+      • [Activity Name] - [Brief description including specific venue]
+        Ideal for: [weather condition that would trigger this alternative]
+
+      ⚠️ SPECIAL CONSIDERATIONS
+      • [Any relevant weather warnings, UV index, wind conditions, etc.]
+
+      Guidelines:
+      - Suggest 2-3 time-specific outdoor activities per day
+      - Include 1-2 indoor backup options
+      - For precipitation >50%, lead with indoor activities
+      - All activities must be specific to the location
+      - Include specific venues, trails, or locations
+      - Consider activity intensity based on temperature
+      - Keep descriptions concise but informative
+
+      Maintain this exact formatting for consistency, using the emoji and section headers as shown.`;
+
+        const response = await agent.stream([
+            {
+                role: 'user',
+                content: prompt,
+            },
+        ]);
+
+        let activitiesText = '';
+
+        for await (const chunk of response.textStream) {
+            process.stdout.write(chunk);
+            activitiesText += chunk;
+        }
+
+        return {
+            activities: activitiesText,
+        };
+    },
+});
+
+/**
+ * Workflow de ejemplo con dos pasos: obtiene el clima y propone actividades.
+ */
+const weatherWorkflow = createWorkflow({
+    id: 'weather-workflow',
+    metadata: {
+        ...hubWorkflow({
+            catalog: { tags: ['weather', 'demo'] },
+            access: { public: true },
+        }),
+    },
+    inputSchema: z.object({
+        city: z.string().describe('The city to get the weather for'),
+    }),
+    outputSchema: z.object({
+        activities: z.string(),
+    }),
+})
+    .then(fetchWeather)
+    .then(planActivities);
+
+weatherWorkflow.commit();
+
+export { weatherWorkflow };

package/templates/default/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ES2022",
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "types": ["node"],
+        "skipLibCheck": true,
+        "noEmit": true,
+        "outDir": "dist"
+    },
+    "include": ["src/**/*"]
+}