Cookbook

import { AsteroidClient, executeAgent, getExecutionStatus } from 'asteroid-odyssey';

async function monitorExecution() {
  const client = AsteroidClient('YOUR_API_KEY');

  const executionId = await executeAgent(client, 'YOUR_AGENT_ID', {
    dynamic_data: {
      DATA: "First name: John, Last name: Smith"
    },
    agent_profile_id: 'YOUR_AGENT_PROFILE_ID'
  });

  console.log('Execution started:', executionId);

  // Check status periodically
  const checkStatus = async () => {
    const status = await getExecutionStatus(client, executionId);
    console.log(`Status: ${status.status}`);

    // Continue checking if status is not final
    // Possible statuses: 'starting' | 'running' | 'paused' | 'awaiting_confirmation' | 'completed' | 'error' | 'cancelled'
    const finalStatuses = ['completed', 'error', 'cancelled'];
    if (!finalStatuses.includes(status.status)) {
      setTimeout(checkStatus, 2000); // Check again in 2 seconds
    } else {
      console.log('Execution finished with final status:', status.status);
    }
  };

  checkStatus();
}

monitorExecution().catch(console.error);

import { AsteroidClient, executeAgent, waitForExecutionResult } from 'asteroid-odyssey';

async function complexFormExample() {
  const client = AsteroidClient('YOUR_API_KEY');

  const formData = {
    personalInfo: {
      firstName: "John",
      lastName: "Smith",
      email: "[email protected]"
    },
    preferences: {
      newsletter: true,
      notifications: false
    },
    address: {
      street: "123 Main St",
      city: "Anytown",
      zipCode: "12345"
    }
  };

  const executionId = await executeAgent(client, 'YOUR_AGENT_ID', {
    dynamic_data: {
      DATA: JSON.stringify(formData)
    },
    agent_profile_id: 'YOUR_AGENT_PROFILE_ID'
  });

  const result = await waitForExecutionResult(client, executionId);
  console.log('Form submission result:', result);
}

complexFormExample().catch(console.error);

import { AsteroidClient, executeAgent, waitForExecutionResult } from 'asteroid-odyssey';

async function advancedVariablesExample() {
  const client = AsteroidClient('YOUR_API_KEY');

  // Your agent prompt might look like:
  // {{if .is_premium}}
  //   Navigate to premium dashboard and enable all features
  // {{else}}
  //   Navigate to free dashboard with limited features
  // {{end}}
  //
  // Fill the form with user info:
  // Name: {{.user.name}}
  // Email: {{.user.email}}
  //
  // {{range .items}}
  // - Add "{{.name}}" ({{.price}}) to cart
  // {{end}}

  const executionId = await executeAgent(client, 'YOUR_AGENT_ID', {
    dynamic_data: {
      // Booleans for conditionals
      is_premium: true,

      // Nested objects
      user: {
        name: "Jane Smith",
        email: "[email protected]",
        verified: true
      },

      // Arrays for loops
      items: [
        { name: "Product A", price: "$29.99" },
        { name: "Product B", price: "$49.99" },
        { name: "Product C", price: "$19.99" }
      ],

      // Numbers and strings
      max_quantity: 10,
      coupon_code: "SAVE20"
    },
    agent_profile_id: 'YOUR_AGENT_PROFILE_ID'
  });

  const result = await waitForExecutionResult(client, executionId);
  console.log('Execution result:', result);
}

advancedVariablesExample().catch(console.error);

import { AsteroidClient, executeAgent, getExecutionStatus, getLastNExecutionActivities, addMessageToExecution } from 'asteroid-odyssey';
import readline from 'readline';

// Configuration - Replace with your actual values
const CONFIG = {
  apiKey: "YOUR_API_KEY", // Replace with your Asteroid API key
  agentId: 'YOUR_AGENT_ID', // Replace with your agent ID
  inputData: "Thursday, First name: Ted, Last name: Clubber-Lang, email: [email protected]", // Replace with your input data
  pollInterval: 2000 // How often to check for updates (milliseconds)
};

const client = AsteroidClient(CONFIG.apiKey);
let executionId: string | null = null;

// Utility functions
const logHeader = (title: string, char = '═', width = 60) => {
  console.log(`\n${title}`);
  console.log(char.repeat(width));
};

const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

// Execute agent with data
async function startAgentExecution(): Promise<string> {
  logHeader('🚀 Starting Agent Execution');
  console.log(`🤖 Agent ID: ${CONFIG.agentId}`);
  console.log(`📝 Input: ${CONFIG.inputData}`);
  console.log('═'.repeat(60));

  try {
    const execId = await executeAgent(client, CONFIG.agentId, {
      dynamic_data: { data: CONFIG.inputData }
    });
    console.log('✅ Agent execution started successfully!');
    console.log('📋 Execution ID:', execId);
    return execId;
  } catch (error: any) {
    console.error('❌ Failed to start agent execution:', error.message);
    process.exit(1);
  }
}

// Handle terminal execution states
const handleTerminalStates = (status: any): boolean => {
  const states: Record<string, () => void> = {
    completed: () => { console.log('✅ Execution completed successfully!'); process.exit(0); },
    error: () => { console.log('❌ Execution error:', status.reason || 'Unknown error'); process.exit(1); },
    cancelled: () => { console.log('🛑 Execution was cancelled'); process.exit(0); }
  };

  if (states[status.status]) {
    states[status.status]();
    return true;
  }
  return false;
};

// Find and display agent's human input request
const findAndDisplayAgentRequest = async (): Promise<boolean> => {
  const activities = await getLastNExecutionActivities(client, executionId!, 20);

  // Filter all human input requests
  const humanInputRequests = activities.filter((activity: any) =>
    activity.payload?.activityType === 'action_started'
  );

  if (humanInputRequests.length === 0) return false;

  const humanInputRequest = humanInputRequests[0];

  const message = (humanInputRequest.payload.data as any).message;
  const timestamp = new Date(humanInputRequest.timestamp).toLocaleString();

  logHeader('🤖 Agent Request', '═', 80);
  console.log(`📅 ${timestamp}`);
  console.log(`💬 ${message}`);
  console.log('═'.repeat(80));

  return true;
};

async function waitForAgentInput(): Promise<void> {
  console.log('🔄 Monitoring execution for agent requests...\n');

  while (true) {
    try {
      const status = await getExecutionStatus(client, executionId!);

      if (handleTerminalStates(status)) return;

      if (status.status === 'paused_by_agent') {
        console.log('⏸️  Agent has paused execution and is requesting input!\n');
        if (await findAndDisplayAgentRequest()) return;
      } else {
        process.stdout.write(`\r📊 Current Status: ${status.status.toUpperCase()}${' '.repeat(20)}`);
      }

      await sleep(CONFIG.pollInterval);
    } catch (error: any) {
      console.error('\n❌ Error checking execution status:', error.message);
      await sleep(CONFIG.pollInterval);
    }
  }
}

// Get user input with readline
const getUserInput = (): Promise<string> => new Promise((resolve) => {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  rl.question('\n💭 Enter your response: ', (answer) => {
    rl.close();
    resolve(answer);
  });
});

// Send message to execution
const sendMessage = async (message: string): Promise<void> => {
  console.log('\n📤 Sending message...');
  await addMessageToExecution(client, executionId!, message);
  console.log('✅ Message sent successfully!\n🔄 Waiting for agent to continue...\n');
};

// Main interactive session loop
async function runInteractiveSession(): Promise<void> {
  while (true) {
    await waitForAgentInput();

    const userMessage = await getUserInput();

    if (userMessage.trim() === '') {
      console.log('⚠️  Empty message, please try again.');
      continue;
    }

    try {
      await sendMessage(userMessage);
    } catch (error: any) {
      console.error('❌ Error sending message:', error.message);
    }
  }
}

// Main execution flow
async function main(): Promise<void> {
  logHeader('🚀 Interactive Agent Session');
  console.log('💡 Press Ctrl+C to exit\n');

  executionId = await startAgentExecution();
  await runInteractiveSession();
}

// Graceful exit and error handling
process.on('SIGINT', () => {
  console.log('\n\n👋 Goodbye!');
  process.exit(0);
});

main().catch(error => {
  console.error('❌ Fatal error:', error.message);
  process.exit(1);
});

import { AsteroidClient, createAgentProfile, getAgentProfile, updateAgentProfile, executeAgent, waitForExecutionResult, deleteAgentProfile } from 'asteroid-odyssey';

(async () => {
  const client = AsteroidClient('YOUR_API_KEY');

  // 1) Create an agent profile with cookies
  const created = await createAgentProfile(client, {
    name: 'Profile With Cookies',
    description: 'Profile preloaded with site cookies',
    organization_id: 'YOUR_ORGANIZATION_ID',
    proxy_cc: 'us',
    proxy_type: 'residential',
    captcha_solver_active: false,
    sticky_ip: false,
    credentials: [],
    cookies: [
      {
        name: 'Session Cookie',
        key: 'session_id',
        value: 'abc123',
        domain: 'example.com',
        secure: true,
        http_only: true,
        same_site: 'Lax',
        expiry: '2026-01-01T00:00:00Z',
        created_at: new Date().toISOString()
      }
    ]
  });

  console.log('Created Profile ID:', created.id);

  // 2) Fetch the profile to confirm cookies
  const profile = await getAgentProfile(client, created.id);
  console.log('Cookies on profile:', profile.cookies);

  // 3) Update cookies: add one and remove one by ID
  const updated = await updateAgentProfile(client, created.id, {
    cookies_to_add: [
      {
        name: 'Auth Token',
        key: 'auth_token',
        value: 'new-token',
        domain: 'example.com',
        secure: true,
        http_only: true,
        same_site: 'Strict',
        created_at: new Date().toISOString()
      }
    ],
    // Replace with a real cookie id from profile.cookies
    cookies_to_delete: profile.cookies.length ? [profile.cookies[0].id as string] : []
  });

  console.log('Updated cookie count:', updated.cookies.length);

  // 4) Execute an agent using the profile with cookies
  // Replace with your actual agent ID and any dynamic_data expected by your agent
  const executionId = await executeAgent(client, 'YOUR_AGENT_ID', {
    agent_profile_id: created.id,
    dynamic_data: {
      DATA: 'Form input or other structured data'
    }
  });
  console.log('Execution started with ID:', executionId);

  // Optionally wait for the result
  const result = await waitForExecutionResult(client, executionId, 2000);
  console.log('Execution result:', result);

  // 5) Cleanup: delete the agent profile
  await deleteAgentProfile(client, created.id);
  console.log('Deleted profile:', created.id);
})().catch((err) => {
  console.error(err);
  process.exit(1);
});