Agentic Workflows

import { ApiRouteConfig, Handlers } from 'motia'
import { z } from 'zod'
import { TSStore } from './ts-store'
 
const createPetSchema = z.object({
  name: z.string().min(1, 'Name is required').trim(),
  species: z.enum(['dog', 'cat', 'bird', 'other']),
  ageMonths: z.number().int().min(0, 'Age must be a positive number')
})
 
export const config: ApiRouteConfig = {
  type: 'api',
  name: 'TsCreatePet',
  path: '/ts/pets',
  method: 'POST',
  emits: ['ts.pet.created', 'ts.feeding.reminder.enqueued'],
  flows: ['TsPetManagement']
}
 
export const handler: Handlers['TsCreatePet'] = async (req, { emit, logger }) => {
  try {
    const validatedData = createPetSchema.parse(req.body)
    
    const pet = TSStore.create({ 
      name: validatedData.name, 
      species: validatedData.species, 
      ageMonths: validatedData.ageMonths 
    })
    
    if (logger) {
      logger.info('🐾 Pet created', { petId: pet.id, name: pet.name, species: pet.species, status: pet.status })
    }
    
    if (emit) {
      await (emit as any)({
        topic: 'ts.pet.created',
        data: { petId: pet.id, event: 'pet.created', name: pet.name, species: validatedData.species }
      })
      
      await (emit as any)({
        topic: 'ts.feeding.reminder.enqueued',
        data: { petId: pet.id, enqueuedAt: Date.now() }
      })
    }
 
  return { status: 201, body: pet }
    
  } catch (error) {
    if (error instanceof z.ZodError) {
      return {
        status: 400,
        body: {
          message: 'Validation error',
          errors: error.errors
        }
      }
    }
    
    return {
      status: 500,
      body: { message: 'Internal server error' }
    }
  }
}

// steps/typescript/ai-profile-enrichment.step.ts
import { EventConfig, Handlers } from 'motia';
import { TSStore, PetProfile } from './ts-store';
 
export const config = {
  type: 'event',
  name: 'TsAiProfileEnrichment',
  description: 'Agentic step that enriches pet profiles using OpenAI',
  subscribes: ['ts.pet.created'],
  emits: [],
  flows: ['TsPetManagement']
};
 
export const handler: Handlers['TsAiProfileEnrichment'] = async (input, { logger }) => {
  const { petId, name, species } = input;
 
  if (logger) {
    logger.info('🤖 AI Profile Enrichment started', { petId, name, species });
  }
 
  try {
    const apiKey = process.env.OPENAI_API_KEY;
    if (!apiKey) {
      throw new Error('OPENAI_API_KEY environment variable is not set');
    }
 
    const prompt = `Generate a pet profile for adoption purposes. Pet details:
- Name: ${name}
- Species: ${species}
 
Please provide a JSON response with these fields:
- bio: A warm, engaging 2-3 sentence description that would appeal to potential adopters
- breedGuess: Your best guess at the breed or breed mix (be specific but realistic)
- temperamentTags: An array of 3-5 personality traits (e.g., "friendly", "energetic", "calm")
- adopterHints: Practical advice for potential adopters (family type, living situation, care needs)
 
Keep it positive, realistic, and adoption-focused.`;
 
    const response = await fetch('https://api.openai.com/v1/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'gpt-3.5-turbo',
        messages: [
          {
            role: 'system',
            content: 'You are a pet adoption specialist who creates compelling, accurate pet profiles. Always respond with valid JSON only.'
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        max_tokens: 500,
        temperature: 0.7,
      }),
    });
 
    if (!response.ok) {
      throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
    }
 
    const data = await response.json();
    const aiResponse = data.choices[0]?.message?.content;
 
    if (!aiResponse) {
      throw new Error('No response from OpenAI API');
    }
 
    let profile: PetProfile;
    try {
      profile = JSON.parse(aiResponse);
    } catch (parseError) {
      profile = {
        bio: `${name} is a wonderful ${species} looking for a loving home. This pet has a unique personality and would make a great companion.`,
        breedGuess: species === 'dog' ? 'Mixed Breed' : species === 'cat' ? 'Domestic Shorthair' : 'Mixed Breed',
        temperamentTags: ['friendly', 'loving', 'loyal'],
        adopterHints: `${name} would do well in a caring home with patience and love.`
      };
      
      if (logger) {
        logger.warn('⚠️ AI response parsing failed, using fallback profile', { petId, parseError: parseError instanceof Error ? parseError.message : String(parseError) });
      }
    }
 
    const updatedPet = TSStore.updateProfile(petId, profile);
    
    if (!updatedPet) {
      throw new Error(`Pet not found: ${petId}`);
    }
 
    if (logger) {
      logger.info('✅ AI Profile Enrichment completed', { 
        petId, 
        profile: {
          bio: profile.bio.substring(0, 50) + '...',
          breedGuess: profile.breedGuess,
          temperamentTags: profile.temperamentTags,
          adopterHints: profile.adopterHints.substring(0, 50) + '...'
        }
      });
    }
 
  } catch (error: any) {
    if (logger) {
      logger.error('❌ AI Profile Enrichment failed', { 
        petId, 
        error: error.message 
      });
    }
 
    const fallbackProfile: PetProfile = {
      bio: `${name} is a lovely ${species} with a unique personality, ready to find their forever home.`,
      breedGuess: species === 'dog' ? 'Mixed Breed' : species === 'cat' ? 'Domestic Shorthair' : 'Mixed Breed',
      temperamentTags: ['friendly', 'adaptable'],
      adopterHints: `${name} is looking for a patient and loving family.`
    };
 
    TSStore.updateProfile(petId, fallbackProfile);
  }
};

// steps/typescript/health-review-agent.step.ts
import { ApiRouteConfig, Handlers } from 'motia';
import { TSStore } from './ts-store';
import { 
  HEALTH_REVIEW_EMITS, 
  buildAgentContext, 
  callAgentDecision,
  getAgentArtifacts
} from './agent-decision-framework';
 
export const config: ApiRouteConfig = {
  type: 'api',
  name: 'TsHealthReviewAgent',
  path: '/ts/pets/:id/health-review',
  method: 'POST',
  emits: ['ts.health.treatment_required', 'ts.health.no_treatment_needed'],
  flows: ['TsPetManagement']
};
 
export const handler: Handlers['TsHealthReviewAgent'] = async (req, { emit, logger }) => {
  const petId = req.pathParams?.id;
 
  if (!petId) {
    return { status: 400, body: { message: 'Pet ID is required' } };
  }
 
  const pet = TSStore.get(petId);
  if (!pet) {
    return { status: 404, body: { message: 'Pet not found' } };
  }
 
  if (logger) {
    logger.info('🏥 Health Review Agent triggered', { 
      petId, 
      currentStatus: pet.status,
      symptoms: pet.symptoms || []
    });
  }
 
  if (!['healthy', 'in_quarantine', 'available'].includes(pet.status)) {
    return {
      status: 400,
      body: {
        message: 'Health review can only be performed on healthy, quarantined, or available pets',
        currentStatus: pet.status
      }
    };
  }
 
  const agentContext = buildAgentContext(pet);
 
  const recentArtifacts = getAgentArtifacts(petId)
    .filter(a => 
      a.agentType === 'health-review' && 
      a.success && 
      a.inputs.currentStatus === pet.status &&
      (Date.now() - a.timestamp) < 60000
    );
 
  if (recentArtifacts.length > 0) {
    const recent = recentArtifacts[recentArtifacts.length - 1];
    if (logger) {
      logger.info('🔄 Idempotent health review - returning cached decision', {
        petId,
        chosenEmit: recent.parsedDecision.chosenEmit,
        timestamp: recent.timestamp
      });
    }
 
    return {
      status: 200,
      body: {
        message: 'Health review completed (cached)',
        petId,
        agentDecision: recent.parsedDecision,
        artifact: {
          timestamp: recent.timestamp,
          success: recent.success
        }
      }
    };
  }
 
  try {
    if (logger) {
      logger.info('🔍 Starting agent decision call', { petId, agentContext });
    }
    
    const artifact = await callAgentDecision(
      'health-review',
      agentContext,
      HEALTH_REVIEW_EMITS,
      logger
    );
    
    if (logger) {
      logger.info('✅ Agent decision call completed', { petId, success: artifact.success });
    }
 
    if (!artifact.success) {
      if (logger) {
        logger.warn('⚠️ Agent decision failed, but returning error response', {
          petId,
          error: artifact.error
        });
      }
      
      return {
        status: 500,
        body: {
          message: 'Agent decision failed',
          error: artifact.error,
          petId,
          suggestion: 'Check OpenAI API key and try again'
        }
      };
    }
 
    const chosenEmitDef = HEALTH_REVIEW_EMITS.find(e => e.id === artifact.parsedDecision.chosenEmit);
    if (!chosenEmitDef) {
      return {
        status: 500,
        body: {
          message: 'Invalid emit chosen by agent',
          chosenEmit: artifact.parsedDecision.chosenEmit
        }
      };
    }
 
    if (emit) {
      (emit as any)({
        topic: chosenEmitDef.topic as 'ts.health.treatment_required' | 'ts.health.no_treatment_needed',
        data: {
          petId,
          event: chosenEmitDef.id.replace('emit.', ''),
          agentDecision: artifact.parsedDecision,
          timestamp: artifact.timestamp,
          context: agentContext
        }
      });
 
      if (logger) {
        logger.info('✅ Health review emit fired', {
          petId,
          chosenEmit: artifact.parsedDecision.chosenEmit,
          topic: chosenEmitDef.topic,
          rationale: artifact.parsedDecision.rationale
        });
      }
    }
 
    return {
      status: 200,
      body: {
        message: 'Health review completed',
        petId,
        agentDecision: artifact.parsedDecision,
        emitFired: chosenEmitDef.topic,
        artifact: {
          timestamp: artifact.timestamp,
          success: artifact.success,
          availableEmits: artifact.availableEmits.map(e => e.id)
        }
      }
    };
 
  } catch (error: any) {
    if (logger) {
      logger.error('❌ Health review agent error', {
        petId,
        error: error.message
      });
    }
 
    return {
      status: 500,
      body: {
        message: 'Health review failed',
        error: error.message,
        petId
      }
    };
  }
};

export const config = {
  type: 'event',
  name: 'TsPetLifecycleOrchestrator',
  description: 'Pet lifecycle state management with staff interaction points',
  subscribes: [
    'ts.feeding.reminder.completed',
    'ts.pet.status.update.requested',
    'ts.health.treatment_required',       // From Health Review Agentic Step
    'ts.health.no_treatment_needed',      // From Health Review Agentic Step
    'ts.adoption.needs_data',             // From Adoption Review Agentic Step
    'ts.adoption.ready'                   // From Adoption Review Agentic Step
  ],
  emits: [
    'ts.treatment.required',
    'ts.adoption.ready',
    'ts.treatment.completed'
  ],
  flows: ['TsPetManagement']
}
 
// The orchestrator has transition rules that handle agentic step events
const TRANSITION_RULES: TransitionRule[] = [
  // ... other rules ...
  
  // Agentic step-driven health transitions
  {
    from: ["healthy", "in_quarantine"],
    to: "ill",
    event: "health.treatment_required",
    description: "Agent assessment - pet requires medical treatment"
  },
  {
    from: ["healthy", "in_quarantine"],
    to: "healthy",
    event: "health.no_treatment_needed",
    description: "Agent assessment - pet remains healthy"
  },
  // Agentic step-driven adoption transitions
  {
    from: ["healthy"],
    to: "healthy",
    event: "adoption.needs_data",
    description: "Agent assessment - pet needs additional data before adoption",
    flagAction: { action: 'add', flag: 'needs_data' }
  },
  {
    from: ["healthy"],
    to: "available",
    event: "adoption.ready",
    description: "Agent assessment - pet ready for adoption",
    guards: ['no_needs_data_flag']
  }
]