@virtualkitchenco/multiverse-sdk 0.0.1

package/dist/report.js

@@ -0,0 +1,128 @@
+/**
+ * Report Card Generation
+ *
+ * Generates markdown report cards from test results
+ * for posting to PRs and CI output.
+ */
+/**
+ * Calculate tier from pass rate
+ */
+export function calculateTier(passRate) {
+    if (passRate >= 95)
+        return 'S';
+    if (passRate >= 85)
+        return 'A';
+    if (passRate >= 70)
+        return 'B';
+    if (passRate >= 50)
+        return 'C';
+    return 'D';
+}
+/**
+ * Get emoji for tier
+ */
+function tierEmoji(tier) {
+    switch (tier) {
+        case 'S': return '🏆';
+        case 'A': return '✅';
+        case 'B': return '⚠️';
+        case 'C': return '🔶';
+        case 'D': return '❌';
+        default: return '❓';
+    }
+}
+/**
+ * Generate markdown report card from test results
+ */
+export function generateReportCard(results, options = {}) {
+    const { dashboardUrl, detailed = true } = options;
+    const tier = calculateTier(results.passRate);
+    const emoji = tierEmoji(tier);
+    const lines = [];
+    // Header
+    lines.push('## 🔮 Multiverse Report');
+    lines.push('');
+    // Summary
+    lines.push(`**Tier ${tier}** ${emoji} · ${results.passRate}% pass rate`);
+    lines.push('');
+    // Stats
+    const passed = results.runs.filter(r => r.passed).length;
+    const failed = results.runs.length - passed;
+    lines.push(`| Metric | Value |`);
+    lines.push(`|--------|-------|`);
+    lines.push(`| Total Runs | ${results.runs.length} |`);
+    lines.push(`| Passed | ${passed} |`);
+    lines.push(`| Failed | ${failed} |`);
+    lines.push(`| Duration | ${(results.duration / 1000).toFixed(1)}s |`);
+    lines.push('');
+    // Scenario breakdown
+    if (detailed && results.runs.length > 0) {
+        const scenarioStats = aggregateByScenario(results.runs);
+        lines.push('### Scenarios');
+        lines.push('');
+        lines.push('| Scenario | Passed | Rate |');
+        lines.push('|----------|--------|------|');
+        for (const [name, stats] of scenarioStats) {
+            const rate = Math.round((stats.passed / stats.total) * 100);
+            const status = rate >= 80 ? '✅' : rate >= 50 ? '⚠️' : '❌';
+            lines.push(`| ${name} | ${stats.passed}/${stats.total} | ${status} ${rate}% |`);
+        }
+        lines.push('');
+    }
+    // Weak spots
+    if (results.weakSpots && results.weakSpots.length > 0) {
+        lines.push('### Weak Spots');
+        lines.push('');
+        for (const spot of results.weakSpots) {
+            lines.push(`- **${spot.scenario}**: ${spot.passRate}% pass rate`);
+        }
+        lines.push('');
+    }
+    // Dashboard link
+    if (dashboardUrl || results.url) {
+        const url = dashboardUrl || results.url;
+        lines.push(`[View full report →](${url})`);
+        lines.push('');
+    }
+    // Footer
+    lines.push('---');
+    lines.push('*Generated by [Multiverse](https://github.com/anthropics/multiverse)*');
+    return lines.join('\n');
+}
+/**
+ * Generate short summary for CI output
+ */
+export function generateSummary(results) {
+    const tier = calculateTier(results.passRate);
+    const passed = results.runs.filter(r => r.passed).length;
+    const failed = results.runs.length - passed;
+    return `Multiverse: Tier ${tier} (${results.passRate}%) - ${passed} passed, ${failed} failed`;
+}
+/**
+ * Aggregate run results by scenario
+ */
+function aggregateByScenario(runs) {
+    const stats = new Map();
+    for (const run of runs) {
+        const name = run.scenario.name;
+        const current = stats.get(name) || { passed: 0, total: 0 };
+        current.total++;
+        if (run.passed)
+            current.passed++;
+        stats.set(name, current);
+    }
+    return stats;
+}
+/**
+ * Generate badge URL (shields.io style)
+ */
+export function generateBadgeUrl(results) {
+    const tier = calculateTier(results.passRate);
+    const color = tier === 'S' || tier === 'A' ? 'brightgreen' :
+        tier === 'B' ? 'yellow' :
+            tier === 'C' ? 'orange' : 'red';
+    const label = encodeURIComponent('multiverse');
+    const message = encodeURIComponent(`Tier ${tier} (${results.passRate}%)`);
+    return `https://img.shields.io/badge/${label}-${message}-${color}`;
+}
+//# sourceMappingURL=report.js.map

package/dist/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"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"}

package/dist/simulate.d.ts

@@ -0,0 +1,49 @@
+/**
+ * LLM-based tool simulation with two-phase approach
+ *
+ * Phase 1 (Analysis): LLM analyzes world state vs query to decide action
+ * Phase 2 (Execution): Execute based on action (may skip LLM entirely)
+ *
+ * This ensures consistency - same tool + overlapping queries return consistent data.
+ */
+import type { World, Mutation, Scenario, Invariant, ZodLikeSchema, Effect, WorldStateAccessor } from '@multiverse/core';
+import type { LLMProvider } from './llm/index.js';
+export interface SimulationResult {
+    response: unknown;
+    mutations: Mutation[];
+    analysis?: AnalysisResult;
+}
+/**
+ * Conversation entry for context
+ */
+export interface ConversationEntry {
+    role: 'user' | 'agent';
+    content: string;
+}
+/**
+ * Tool simulation config
+ */
+export interface ToolSimConfig {
+    outputSchema?: ZodLikeSchema;
+    effects?: (output: unknown, world: WorldStateAccessor) => Effect[];
+    invariants?: Invariant[];
+}
+/**
+ * Two-phase simulation types
+ */
+export type SimulationAction = 'return_existing' | 'filter' | 'augment' | 'generate';
+export interface AnalysisResult {
+    action: SimulationAction;
+    matches: string[];
+    collection: string | null;
+    gaps: string[];
+    reasoning: string;
+}
+/**
+ * Simulate a tool call using two-phase approach
+ *
+ * Phase 1: Analyze world state vs query
+ * Phase 2: Execute based on analysis (may skip LLM entirely)
+ */
+export declare function simulateToolCall(toolName: string, toolDescription: string, input: unknown, world: World, llm: LLMProvider, scenario?: Scenario, conversationHistory?: ConversationEntry[], config?: ToolSimConfig): Promise<SimulationResult>;
+//# sourceMappingURL=simulate.d.ts.map

package/dist/simulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.d.ts","sourceRoot":"","sources":["../src/simulate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAa,SAAS,EAAE,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAU,MAAM,kBAAkB,CAAC;AAC3I,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,KAAK,MAAM,EAAE,CAAC;IACnE,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAErF,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AA6ZD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,WAAW,EAChB,QAAQ,CAAC,EAAE,QAAQ,EACnB,mBAAmB,CAAC,EAAE,iBAAiB,EAAE,EACzC,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAS3B"}

package/dist/simulate.js

@@ -0,0 +1,476 @@
+/**
+ * LLM-based tool simulation with two-phase approach
+ *
+ * Phase 1 (Analysis): LLM analyzes world state vs query to decide action
+ * Phase 2 (Execution): Execute based on action (may skip LLM entirely)
+ *
+ * This ensures consistency - same tool + overlapping queries return consistent data.
+ */
+/**
+ * Convert a zod schema to a JSON schema description for the LLM prompt
+ */
+function schemaToDescription(schema) {
+    // Try to get the shape from common zod schema structures
+    const s = schema;
+    // Check for zod's internal shape property
+    if (s._def && typeof s._def === 'object') {
+        const def = s._def;
+        if (def.shape && typeof def.shape === 'function') {
+            try {
+                const shape = def.shape();
+                return JSON.stringify(Object.fromEntries(Object.entries(shape).map(([k, v]) => [k, describeZodType(v)])), null, 2);
+            }
+            catch {
+                // Fall through
+            }
+        }
+        // Handle array types
+        if (def.typeName === 'ZodArray' && def.type) {
+            return `Array<${schemaToDescription(def.type)}>`;
+        }
+    }
+    // Fallback: just indicate there's a schema
+    return '(structured output - follow the shape implied by the tool description)';
+}
+/**
+ * Describe a single zod type for the prompt
+ */
+function describeZodType(zodType) {
+    const t = zodType;
+    if (!t._def)
+        return 'unknown';
+    const def = t._def;
+    const typeName = def.typeName;
+    switch (typeName) {
+        case 'ZodString':
+            return 'string';
+        case 'ZodNumber':
+            return 'number';
+        case 'ZodBoolean':
+            return 'boolean';
+        case 'ZodArray':
+            return `array<${describeZodType(def.type)}>`;
+        case 'ZodObject':
+            if (def.shape && typeof def.shape === 'function') {
+                const shape = def.shape();
+                return JSON.stringify(Object.fromEntries(Object.entries(shape).map(([k, v]) => [k, describeZodType(v)])));
+            }
+            return 'object';
+        case 'ZodEnum':
+            return `enum(${def.values.join('|')})`;
+        case 'ZodOptional':
+            return `${describeZodType(def.innerType)}?`;
+        default:
+            return typeName.replace('Zod', '').toLowerCase();
+    }
+}
+/**
+ * Validate invariants against world state
+ */
+function validateInvariants(world, invariants) {
+    const errors = [];
+    for (const inv of invariants) {
+        const collection = world.getCollection(inv.collection);
+        if (!collection)
+            continue;
+        for (const [id, entity] of collection) {
+            const fieldValue = entity.data[inv.field];
+            if (fieldValue === undefined || fieldValue === null)
+                continue;
+            // Cast to number for numeric comparisons
+            const numFieldValue = fieldValue;
+            const numInvValue = inv.value;
+            let passes = false;
+            switch (inv.condition) {
+                case 'gt':
+                    passes = numFieldValue > numInvValue;
+                    break;
+                case 'gte':
+                    passes = numFieldValue >= numInvValue;
+                    break;
+                case 'lt':
+                    passes = numFieldValue < numInvValue;
+                    break;
+                case 'lte':
+                    passes = numFieldValue <= numInvValue;
+                    break;
+                case 'eq':
+                    passes = fieldValue === inv.value;
+                    break;
+                case 'neq':
+                    passes = fieldValue !== inv.value;
+                    break;
+            }
+            if (!passes) {
+                errors.push(`Invariant violated: ${inv.collection}.${id}.${inv.field} (${fieldValue}) ${inv.condition} ${inv.value}`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Convert Effect to Mutation
+ */
+function effectToMutation(effect) {
+    return {
+        operation: effect.operation,
+        collection: effect.collection,
+        id: effect.id,
+        data: effect.data,
+    };
+}
+// ============================================================================
+// Two-Phase Simulation
+// ============================================================================
+/**
+ * Phase 1: Analyze the query against world state
+ * Determines what action to take (return existing, filter, augment, or generate)
+ */
+async function analyzeQuery(toolName, toolDescription, input, world, llm) {
+    const worldState = world.toJSON();
+    const isEmpty = Object.keys(worldState).length === 0 ||
+        Object.values(worldState).every(collection => Object.keys(collection).length === 0);
+    // Fast path: if world is empty, always generate
+    if (isEmpty) {
+        return {
+            action: 'generate',
+            matches: [],
+            collection: null,
+            gaps: ['World state is empty - generate all data'],
+            reasoning: 'No existing data in world state',
+        };
+    }
+    const prompt = `Analyze this tool call against the current world state.
+
+WORLD STATE:
+${JSON.stringify(worldState, null, 2)}
+
+TOOL: ${toolName}
+DESCRIPTION: ${toolDescription}
+INPUT: ${JSON.stringify(input)}
+
+Determine:
+1. Is this a READ (query/search/get/list/find) or WRITE (create/book/update/delete) operation?
+2. For READ: Do entities in world state match this query? Which ones?
+3. What gaps exist between existing data and query requirements?
+
+Return JSON only:
+{
+  "action": "return_existing" | "filter" | "augment" | "generate",
+  "collection": "<collection name that contains relevant data, or null>",
+  "matches": ["<entity IDs that match or partially match the query>"],
+  "gaps": ["<descriptions of what data is missing, if any>"],
+  "reasoning": "<brief 1-sentence explanation of your decision>"
+}
+
+ACTION MEANINGS:
+- return_existing: World has entities that FULLY satisfy this query - return them as-is
+- filter: World has MORE data than needed - filter down to matching subset
+- augment: World has SOME matching data but gaps exist - return existing + generate missing
+- generate: World has NO relevant data OR this is a WRITE operation - generate fresh
+
+IMPORTANT:
+- For WRITE operations (book, create, update), always use "generate"
+- For READ operations, prefer using existing data when available
+- Include ALL entity IDs that could be relevant in "matches"`;
+    const result = await llm.generate(prompt);
+    // Parse JSON from response
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+        // Fallback to generate if analysis fails
+        return {
+            action: 'generate',
+            matches: [],
+            collection: null,
+            gaps: ['Failed to parse analysis'],
+            reasoning: 'Analysis parsing failed, falling back to generation',
+        };
+    }
+    try {
+        return JSON.parse(jsonMatch[0]);
+    }
+    catch {
+        return {
+            action: 'generate',
+            matches: [],
+            collection: null,
+            gaps: ['Failed to parse analysis JSON'],
+            reasoning: 'Analysis JSON parsing failed, falling back to generation',
+        };
+    }
+}
+/**
+ * Infer the response key from tool name (e.g., searchUsers → users, getProducts → products)
+ */
+function inferResultKey(toolName) {
+    const match = toolName.match(/(?:search|get|list|find)(\w+)/i);
+    return match ? match[1].toLowerCase() : 'results';
+}
+/**
+ * Format entities as a tool response
+ */
+function formatAsToolResponse(toolName, entities, _config) {
+    const validEntities = entities.filter((e) => e !== undefined);
+    const response = { [inferResultKey(toolName)]: validEntities.map(e => e.data) };
+    return { response, mutations: [] }; // No new mutations for existing data
+}
+/**
+ * Generate only the gap data (for augment action)
+ */
+async function generateGapData(toolName, toolDescription, input, existing, gaps, world, llm, scenario, config) {
+    const currentDate = new Date().toISOString().split('T')[0];
+    const scenarioContext = scenario ? `
+SCENARIO CONTEXT:
+- Persona: ${scenario.persona.backstory}
+- Situation: ${scenario.persona.situation}
+- Style: ${scenario.persona.style}
+` : '';
+    const prompt = `Generate ONLY the missing data to fill gaps in this query.
+
+EXISTING DATA (do NOT duplicate these - they will be included automatically):
+${JSON.stringify(existing.map(e => e.data), null, 2)}
+
+${scenarioContext}
+TOOL: ${toolName}
+DESCRIPTION: ${toolDescription}
+INPUT: ${JSON.stringify(input)}
+CURRENT DATE: ${currentDate}
+
+GAPS TO FILL:
+${gaps.map(g => `- ${g}`).join('\n')}
+
+Generate NEW entities to fill these gaps. Be consistent with existing data:
+- Use similar price ranges
+- Use similar ID formats
+- Maintain realistic relationships
+
+Return JSON only:
+{
+  "newEntities": [<array of new entity data objects>],
+  "mutations": [
+    { "operation": "create", "collection": "<collection>", "id": "<id>", "data": {<entity data>} }
+  ]
+}`;
+    const result = await llm.generate(prompt);
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+        return { entities: [], mutations: [] };
+    }
+    try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        const mutations = parsed.mutations || [];
+        // Apply mutations to world state
+        for (const mutation of mutations) {
+            world.mutate(mutation);
+        }
+        // Convert new entities to Entity format
+        const newEntities = (parsed.newEntities || []).map((data, idx) => ({
+            id: data.id || `generated-${idx}`,
+            data,
+        }));
+        return { entities: newEntities, mutations };
+    }
+    catch {
+        return { entities: [], mutations: [] };
+    }
+}
+/**
+ * Phase 2: Execute based on analysis result
+ */
+async function executeAction(analysis, toolName, toolDescription, input, world, llm, scenario, conversationHistory, config) {
+    switch (analysis.action) {
+        case 'return_existing': {
+            // No LLM needed - just return matched entities from world state
+            const entities = analysis.matches.map(id => world.getEntity(analysis.collection, id));
+            const result = formatAsToolResponse(toolName, entities, config);
+            return { ...result, analysis };
+        }
+        case 'filter': {
+            // LLM already determined matches in Phase 1 - trust those matches
+            // Only do lightweight client-side filtering for obvious mismatches
+            const entities = analysis.matches.map(id => world.getEntity(analysis.collection, id));
+            // Filter out undefined entities (in case they were deleted)
+            const validEntities = entities.filter((e) => e !== undefined);
+            // Trust LLM's matches - it already analyzed which entities fit the query
+            const result = formatAsToolResponse(toolName, validEntities, config);
+            return { ...result, analysis };
+        }
+        case 'augment': {
+            // LLM generates ONLY the gaps, merge with existing
+            // IMPORTANT: Fetch ALL entities from collection, not just analysis.matches
+            // This prevents the LLM from regenerating entities it missed in analysis
+            const collection = analysis.collection ? world.getCollection(analysis.collection) : null;
+            const allExisting = [];
+            if (collection) {
+                // Get all entities from the collection
+                for (const [id, entity] of collection) {
+                    allExisting.push(entity);
+                }
+            }
+            else {
+                // Fallback to analysis.matches if no collection
+                const fromMatches = analysis.matches
+                    .map(id => world.getEntity(analysis.collection, id))
+                    .filter((e) => e !== undefined);
+                allExisting.push(...fromMatches);
+            }
+            const { entities: newEntities, mutations } = await generateGapData(toolName, toolDescription, input, allExisting, analysis.gaps, world, llm, scenario, config);
+            // Merge existing + new, dedupe by ID (prefer existing data)
+            const seenIds = new Set(allExisting.map(e => e.id));
+            const dedupedNew = newEntities.filter(e => !seenIds.has(e.id));
+            const allEntities = [...allExisting, ...dedupedNew];
+            const result = formatAsToolResponse(toolName, allEntities, config);
+            return { ...result, mutations, analysis };
+        }
+        case 'generate':
+        default: {
+            // Full LLM generation (current behavior)
+            const result = await generateFullResponse(toolName, toolDescription, input, world, llm, scenario, conversationHistory, config);
+            return { ...result, analysis };
+        }
+    }
+}
+/**
+ * Simulate a tool call using two-phase approach
+ *
+ * Phase 1: Analyze world state vs query
+ * Phase 2: Execute based on analysis (may skip LLM entirely)
+ */
+export async function simulateToolCall(toolName, toolDescription, input, world, llm, scenario, conversationHistory, config) {
+    // Phase 1: Analyze
+    const analysis = await analyzeQuery(toolName, toolDescription, input, world, llm);
+    // Phase 2: Execute based on analysis
+    return executeAction(analysis, toolName, toolDescription, input, world, llm, scenario, conversationHistory, config);
+}
+/**
+ * Generate full response via LLM (used when action is 'generate')
+ * Called when world state is empty or this is a write operation
+ *
+ * If outputSchema is provided, LLM is instructed to match that shape.
+ * If effects function is provided, mutations are computed from the response.
+ */
+async function generateFullResponse(toolName, toolDescription, input, world, llm, scenario, conversationHistory, config) {
+    const worldState = world.toJSON();
+    const hasSeededData = Object.keys(worldState).length > 0;
+    const currentDate = new Date().toISOString().split('T')[0];
+    const hasEffectsFunction = !!config?.effects;
+    // Extract scenario context for more accurate simulation
+    const scenarioContext = scenario ? `
+SCENARIO CONTEXT:
+- Persona: ${scenario.persona.backstory}
+- Situation: ${scenario.persona.situation}
+- Style: ${scenario.persona.style}
+${scenario.persona.constraints ? `- Constraints: ${JSON.stringify(scenario.persona.constraints)}` : ''}
+
+IMPORTANT: Generate data that matches the SCENARIO CONTEXT, not generic data.
+For example, if the persona wants items from category X, generate category X items.
+` : '';
+    // Include recent conversation for context (e.g., user said "February 14th")
+    const recentConversation = conversationHistory && conversationHistory.length > 0 ? `
+RECENT CONVERSATION (for context):
+${conversationHistory.slice(-6).map(e => `${e.role.toUpperCase()}: ${e.content}`).join('\n')}
+
+IMPORTANT: Use conversation context to understand what the user actually wants.
+For example, if user mentioned specific criteria, generate data matching those criteria even if not in tool input.
+` : '';
+    // Output schema instruction
+    const outputSchemaInstruction = config?.outputSchema ? `
+OUTPUT SCHEMA (you MUST match this structure exactly):
+${schemaToDescription(config.outputSchema)}
+` : '';
+    // Determine if we need mutations in the prompt
+    const mutationsInstruction = hasEffectsFunction
+        ? `\nNOTE: Do NOT include "mutations" in your response - they will be computed automatically.`
+        : `
+If this tool creates or modifies entities, include mutations.`;
+    const responseFormat = hasEffectsFunction
+        ? `Return JSON only:
+{
+  "response": <the tool response matching the output schema>
+}`
+        : `Return JSON only:
+{
+  "response": <the tool response - match the expected format>,
+  "mutations": [
+    { "operation": "create", "collection": "orders", "id": "ORD-123", "data": {...} },
+    { "operation": "update", "collection": "inventory", "id": "ITEM-456", "data": { "quantity": 49 } }
+  ]
+}`;
+    const prompt = `You are simulating a tool response for an AI agent test.
+
+CURRENT DATE: ${currentDate}
+${scenarioContext}${recentConversation}
+${hasSeededData ? `EXISTING WORLD STATE:
+${JSON.stringify(worldState, null, 2)}
+
+NOTE: If existing data doesn't match the scenario context (e.g., wrong routes), generate NEW contextually appropriate data instead.` : `WORLD STATE: (empty - generate plausible mock data)`}
+
+TOOL CALL:
+Name: ${toolName}
+Description: ${toolDescription}
+Input: ${JSON.stringify(input)}
+${outputSchemaInstruction}
+Generate a realistic response that makes sense for the scenario and input.
+${mutationsInstruction}
+
+RULES:
+1. PRIORITIZE scenario context over seeded data - generate data matching what the persona actually wants
+2. Use readable IDs (UA123, BK-7890) not UUIDs
+3. Be contextually realistic:
+   - Dates should be current or near-future (relative to ${currentDate})
+   - Prices should be realistic for the domain
+   - Routes/data should match what the persona actually wants
+4. For search/query operations: return 2-4 entities matching the INPUT parameters
+5. For create/write operations: create new entities and update related ones (e.g., decrement inventory)
+${hasEffectsFunction ? '' : '6. Always include mutations to track generated data in world state'}
+
+${responseFormat}`;
+    const result = await llm.generate(prompt);
+    // Parse JSON from response
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+        throw new Error(`Failed to parse simulated response for ${toolName}`);
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    let response = parsed.response;
+    // Validate against output schema if provided
+    if (config?.outputSchema) {
+        const validation = config.outputSchema.safeParse(response);
+        if (!validation.success) {
+            console.warn(`Simulated response for ${toolName} doesn't match output schema:`, validation.error);
+            // Try to use it anyway - LLM might have gotten close enough
+        }
+        else {
+            response = validation.data;
+        }
+    }
+    // Compute mutations
+    let mutations = [];
+    if (config?.effects) {
+        // Use effects function to compute mutations from response
+        // Pass world state so effects can access current state (e.g., for computing decrements)
+        const effects = config.effects(response, world);
+        mutations = effects.map(effectToMutation);
+    }
+    else if (parsed.mutations) {
+        // Use LLM-generated mutations (legacy path)
+        mutations = parsed.mutations;
+    }
+    // Apply mutations to world
+    for (const mutation of mutations) {
+        world.mutate(mutation);
+    }
+    // Validate invariants if provided
+    if (config?.invariants && config.invariants.length > 0) {
+        const { valid, errors } = validateInvariants(world, config.invariants);
+        if (!valid) {
+            console.warn(`Invariant violations after ${toolName}:`, errors);
+            // Could throw here to make it strict, but for now just warn
+        }
+    }
+    return {
+        response,
+        mutations,
+    };
+}
+//# sourceMappingURL=simulate.js.map